Question

I have a file with a double-linked-list that contains a set of process identifiers and some state information.

struct pr7_process 
{ 
  pid_t pid;        /* process ID, supplied from fork() */ 
                /* if 0, this entry is currently not in use */ 
  int   state;      /* process state, your own definition */ 
  int   exit_status;    /* supplied from wait() if process has finished */
  struct pr7_process *next;   // a pointer to the next process
  struct pr7_process *prev;
};

/* the process list */

struct process_list
{
   struct pr7_process *head;
   struct pr7_process *tail;
};

I have a method to remove an element of my list:

{
struct pr7_process *cur;
  for(cur = list->head; cur != NULL; cur = cur->next)
    {
      if (cur->pid == pid)
        {
          printf("cur pid: %d\n", cur->pid);
          cur->state = STATE_NONE;
          if(list->head == list->tail)
         {
           free(cur);
         }
         else
          {
            cur->prev->next = cur->next;
            cur->next->prev = cur->prev;
            free(cur);
          }
          break;
        }
     } 
  } 

What is wrong with my remove function? I seem to get an infinite loop when I try to print my list. Previously I thought it was the way I used free() but apparently not from the replies 🙂

Thanks!

Answer 1

When you add a node set next to NULL.

Then when you free all, free until next == NULL.

When you remove a node. Update links and free node.

Also; free on NULL is an noop.

Valgrind is a invaluable tool when working on such things.

---

Believe you have to do some more checks; I.e.:

struct pr7_process {
    int pid;
    ...
} const new_proc = {
    0, 44, 0, NULL, NULL
};

void del(struct process_list *list, int pid)
{
    struct pr7_process *cur;

    for (cur = list->head; cur != NULL; cur = cur->next) {
        if (cur->pid == pid) {

            printf("cur pid: %d\n", cur->pid);

            if(list->head == list->tail) {
                free(cur);
                list->head = NULL;
                list->tail = NULL;
            } else if (cur == list->head) {
                list->head = list->head->next;
                free(cur);
                list->head->prev = NULL;
            } else if (cur == list->tail) {
                list->tail = cur->prev;
                free(cur);
                list->tail->next = NULL;
            } else {
                cur->prev->next = cur->next;
                cur->next->prev = cur->prev;
                free(cur);
            }
            break;
        }
    }
}

---

Given that you build the list something like i.e.:

int push(struct process_list *list, int pid, int state)
{
    if (list->head == NULL) { /* or move this to where ever you see fit */
        if ((list->head  = malloc(sizeof(struct pr7_process))) == NULL)
            return -1;
        list->tail  = list->head;
        *list->tail = new_proc;
    } else {
        if ((list->tail->next  = malloc(sizeof(struct pr7_process))) == NULL)
            return -1;
        *list->tail->next = new_proc;
        list->tail->next->prev = list->tail;
        list->tail = list->tail->next;
    }
    list->tail->pid = pid;
    list->tail->state = state;

    return 0;
}

void wipe(struct process_list *list)
{
    struct pr7_process *node = list->tail;

    while (node != list->head) {
        node = list->tail->prev;
        free(list->tail);
        list->tail = node;
    }
    free(list->head);
    list->head = NULL;
    list->tail = NULL;
}

void prnt(struct process_list list, int dir)
{
    if (dir == 1) {
        while (list.head != NULL) {
            printf("%4d: %d\n", list.head->pid, list.head->state);
            list.head = list.head->next;
        }
    } else {
        while (list.tail != NULL) {
            printf("%4d: %d\n", list.tail->pid, list.tail->state);
            list.tail = list.tail->prev;
        }
    }
}

int main(void)
{
    struct process_list list = {NULL, NULL};

    push(&list, 331, 2); /* if(push() != -1) ... */
    push(&list, 332, 66);
    push(&list, 333, 47);

    prnt(list, 1);

    del(&list, 332);
    prnt(list, 1);

    wipe(&list);
    prnt(list, 1);

    return 0;
}