Удаление и блокировка двунаправленных списков.

struct main_struct (*main_list_map)[NUMBER_OF_THREADS];

DEFINE_SPINLOCK(main_head_list_spinlock);


/* добавление элемента списка */
int func_add(int num_1, int num_2)
{
  struct main_struct *main_struct_ptr = vmalloc(sizeof(struct main_struct));
  if(main_struct_ptr == NULL) return 0;
  memset(main_struct_ptr, 0, sizeof(struct main_struct));

  /* сохраняем числа структуры */
  main_struct_ptr->number_1 = num_1;
  main_struct_ptr->number_2 = num_2;


  spin_lock(&main_head_list_spinlock);
    list_add(&main_struct_ptr->list, &main_head_list);
  spin_unlock(&main_head_list_spinlock);
}




/* удаление элемента списка */
void func_del(int num_1, int num_2)
{
  struct main_struct *main_struct_ptr = NULL; 
  struct list_head *list_ptr, *tmp;

 spin_lock(&main_head_list_spinlock);
  list_for_each_safe(list_ptr, tmp, &main_head_list)
  {
    main_struct_ptr = list_entry(list_ptr, struct main_struct, list);
    
    if( main_struct_ptr->number_1 == num_1 && main_struct_ptr->number_2 == num_2)
    {
      /* удаляем найденый элемент */
      list_del(&main_struct_ptr->list);
      if(main_struct_ptr) vfree(main_struct_ptr);
    }
  }
 spin_unlock(&main_head_list_spinlock);
return; 
}









/* действия потоков выполнения */
запуск потока.
-----
(тут поток делает всё что угодно)
--------
-----------
int num_1 = любое число;
int num_2 = любое число;



/* заносим в список два числа */
if(func_add(int num_1, int num_2) == 0 ) return ERROR;

--------
(тут снова процесс делает всё что угодно)
----
-------
----------

/* производим удаление элемента из двунаправленного списка */
func_del(num_1, num_2);

for (p = list_head; p != list_end; p = p->next)
    /* if we remove p here, we brake the loop, since p->next is gone */

for (p = list_head; tmp = p->next, p != list_end; p = tmp)
    /* it's safe to remove p now, since we saved p->next for next iteration */

static DEFINE_SPINLOCK(xxx_lock);

	unsigned long flags;

	spin_lock_irqsave(&xxx_lock, flags);
	... critical section here ..
	spin_unlock_irqrestore(&xxx_lock, flags);

The reasons you mustn't use these versions if you have interrupts that
play with the spinlock is that >>> you can get deadlocks <<<:

	spin_lock(&lock);
	...
		<- interrupt comes in:
			spin_lock(&lock);

#include	<stdio.h>
#include	<stdlib.h>
#include	<pthread.h>

#define	MAXNITEMS 		1000000
#define	MAXNTHREADS			100

int		nitems;			

struct node* List ;

struct {
  pthread_mutex_t	mutex;
  pthread_cond_t	cond;
  int				nready;	
  int	count;
  long producer_sum  ;
  struct node* List ;
} put = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER };

struct {
  pthread_mutex_t	mutex;
  pthread_cond_t	cond;
  int				nready;	
  int	count;
  long consumer_sum  ;
  struct node* List ;
} get = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER };

void	*produce(void *), *consume(void *);
int  Length(char * name , struct node* head);
int  Pop(struct node** headRef);
void Add(struct node** headRef, int num) ;
 
int main(int argc, char **argv)
{
	int			i, nthreads, count[MAXNTHREADS] , count2[MAXNTHREADS];
	pthread_t	tid_produce[MAXNTHREADS], tid_consume[MAXNTHREADS];

	List = NULL ;

	if (argc != 3)
	{
		printf("usage: prodcons <#items> <#threads>\n");
		exit(0);
	}
	nitems = atoi(argv[1]);
	nthreads = atoi(argv[2]);

	for (i = 0; i < nthreads; i++) 
	{
		count[i] = 0;
		pthread_create(&tid_produce[i], NULL, produce, &count[i]);
		count2[i] = 0;
		pthread_create(&tid_consume[i], NULL, consume, &count2[i]);
	}

	for (i = 0; i < nthreads; i++) 
	{
		pthread_join(tid_produce[i], NULL);
		pthread_join(tid_consume[i], NULL);
		printf("count[%d] = %d  count2[%d] = %d\n", i, count[i], i, count2[i]);	
	}

	printf("producer_sum =%d  consumer_sum =%d\n" , put.producer_sum , get.consumer_sum);  // results in len == 3
	printf("producer counter =%d  consumer counter =%d\n" , put.count , get.count);  // results in len == 3
    printf("queue length =%d\n",Length("List",List));  // results in len == 3

	exit(0);
}

void * produce(void *arg)
{
	for ( ; ; ) {
		pthread_mutex_lock(&put.mutex);
		if (put.count >= nitems) {
			pthread_mutex_unlock(&put.mutex);
			return(NULL);		/* array is full, we're done */
		}
		Add(&List, put.count ); 
		put.producer_sum +=put.count;
		put.count++;
		printf("producer =%d  consumer =%d\n" , put.count , get.count);  // results in len == 3
		pthread_mutex_unlock(&put.mutex);

		pthread_mutex_lock(&get.mutex);
		if (get.nready == 0)
			pthread_cond_signal(&get.cond);
		get.nready++;
		pthread_mutex_unlock(&get.mutex);

		*((int *) arg) += 1;
	}
	return(NULL);		/* array is full, we're done */
}

void * consume(void *arg)
{
	for ( ; ; ) {
			pthread_mutex_lock(&get.mutex);
			if (get.count >= nitems ) 
			{
				pthread_mutex_unlock(&get.mutex);
				return(NULL);		/* array is full, we're done */
			}
			if(get.count < put.count)
			{
				int queue = Pop(&List ); 
				get.consumer_sum += queue;
				get.count ++;
				printf("producer =%d  consumer =%d\n" , put.count , get.count);  // results in len == 3
				*((int *) arg) += 1;
			}
			pthread_mutex_unlock(&get.mutex);
	
			pthread_mutex_lock(&put.mutex);
			if (put.nready == 0)
				pthread_cond_signal(&put.cond);
			put.nready++;
			pthread_mutex_unlock(&put.mutex);
	}
	return(NULL);
}