Threads Problem

Hi, i have a little problem in my code .

void thread_exit() { thread_t running_thread = list->element; thread_t next_thread = list->next->element; remove_list(&list, running_thread); thread_switch(running_thread->context, next_thread->context); }

This function terminate a thread that is running, removing her from the list, and
after removing her, switch the execution context of the thread with the next thread on the list. The problem is that i have to free the structure(running_thread) and her context, but i cant do it before the thread_switch(), neither immediately after, so how can i resolve this problem.

I use a list implementation that I once found in a book.
The node is defined as:

struct llnode
{
  struct llnode *prev;  // previous element
  struct llnode *next;  // next element
  void *info;           // pointer to the struct that keeps the actual info (let's say struct xx)
  int len;              // size of struct xx
};

The function remove_list (in my case ll_remove) will remove the node from the list but not free the info pointer (I guess that my info is your context).
The function ll_remove will return the info pointer. You can use that pointer for the thread_switch and free it afterwards (either after the call to thread_switch or maybe in thread_switch).

void * ll_remove(struct llhead *head, struct llnode *node)
{
void *info;

  if(node==NULL)
    return NULL;

  info=node->info;

  // move some pointers around
  // so the node is removed
  .....
  // free the memory occupied by the node
  free(node);

  return info;
}

Your modified code will look like:

void thread_exit() {
  void *context;
  thread_t running_thread = list->element;
  thread_t next_thread = list->next->element;
  context=(void*)remove_list(&list, running_thread);
  thread_switch(context, next_thread->context);
  free(context);
}