Why my double linked list insertion fail? - c

Question

I am writting a simple timer with a double linked list.If I define the linked list head as below,It will work.
struct timer_head
{
struct timer* prev;
struct timer* next;
pthread_spinlock_t lock;
};
But if I define the head as below, then the insertion will fail,I will lost the previous node after each insertion.
struct timer_head
{
struct timer* next;
struct timer* prev;
pthread_spinlock_t lock;
};
Part of my code:
struct timer
{
struct timer* prev;
struct timer* next;
struct timespec start;
struct timespec interval;
void* par, *par2;
/*if handle return 0 */
/*then delete this timer */
/*else restart it */
int (*handler) (void* par);
};
struct timer_head
{
struct timer* prev;
struct timer* next;
/*
*if i changed the previous definition to
*code below, then my list insertion will failed
*why?
*/
/* struct timer* next;
struct timer* prev;
*/
pthread_spinlock_t lock;
};
void timer_queue_init(struct timer_head* lst)
{
pthread_spin_init(&lst->lock, PTHREAD_PROCESS_SHARED);
lst->next = lst->prev = (struct timer*)lst;
}
static void print_queue(struct timer_head* lst)
{
pthread_spin_lock(&(lst->lock));
struct timer* fst = lst->next;
printf("list travserse:\t");
while (fst != (struct timer*) lst)
{
printf("inteval : %ld, ", fst->interval.tv_nsec);
fst = fst->next;
}
printf("\n");
pthread_spin_unlock(&(lst->lock));
}
void timer_queue_insert(struct timer_head* lst, struct timer* nt)
{
pthread_spin_lock(&(lst->lock));
struct timer* ptr = lst->next;
/*insert into list, sorted as earlist execute time */
while (ptr != (struct timer*) lst &&
timespec_cmp(&(ptr->start), &(ptr->interval),
&(nt->start), &(nt->interval)) <= 0)
{
printf("next\n");
ptr = ptr->next;
}
nt->next = ptr;
nt->prev = ptr->prev;
nt->prev->next = nt;
ptr->prev = nt;
/* send signal to manage thread */
if (!qlen)
{
printf("start :%ld s, %ld ns ", nt->start.tv_sec, nt->start.tv_nsec);
printf("interval :%lds, %ld ns\n", nt->interval.tv_sec, nt->interval.tv_nsec);
pthread_cond_signal(&wait);
}
++qlen;
pthread_spin_unlock(&(lst->lock));
printf("traver after insert\t");
print_queue(lst);
}

Answer 1

This code casts a pointer to a struct timer_head to a pointer to a struct timer.
void timer_queue_init(struct timer_head* lst)
{
pthread_spin_init(&lst->lock, PTHREAD_PROCESS_SHARED);
lst->next = lst->prev = (struct timer*)lst; /* HERE */
}
This works (by luck) so long as they have the same structure. Your struct timer looks like this:
struct timer
{
struct timer* prev;
struct timer* next;
...
So putting prev before next allows the cast to "happen to" preserve the values of prev and next, though you definitely shouldn't do it. The problem with code that "happens to" work is that sometimes it will happen not to work.

Answer 2

Looking at your code, the problem is that you cast a timer_head * to timer *. If timer_head looks like
struct {
struct timer * next;
struct timer * prev;
...
}
then in memory you (may) have the following layout
[next][prev]
. If at the same time timer looks like
struct {
struct timer * prev;
struct timer * next;
...
}
, as in your code, it has a different layout in memory, i.e. something like
[prev][next]
. Your cast from one pointer to the other changes what prev and next stand for. (In one case the first and second pointer in memory, in the other case the second and first pointer in memory).