util/zebra-lock.c

   1
   2 #include <assert.h>
   3
   4 #include <zebra-lock.h>
   5
   6 int zebra_mutex_init (Zebra_mutex *p)
   7 {
   8     pthread_mutex_init (&p->mutex, 0);
   9     return 0;
  10 }
  11
  12 int zebra_mutex_destroy (Zebra_mutex *p)
  13 {
  14     pthread_mutex_destroy (&p->mutex);
  15     return 0;
  16 }
  17
  18 int zebra_mutex_lock (Zebra_mutex *p)
  19 {
  20     pthread_mutex_lock (&p->mutex);
  21     return 0;
  22 }
  23
  24 int zebra_mutex_unlock (Zebra_mutex *p)
  25 {
  26     pthread_mutex_unlock (&p->mutex);
  27     return 0;
  28 }
  29
  30 int zebra_lock_rdwr_init (Zebra_lock_rdwr *p)
  31 {
  32     p->readers_reading = 0;
  33     p->writers_writing = 0;
  34     pthread_mutex_init (&p->mutex, 0);
  35     pthread_cond_init (&p->lock_free, 0);
  36     return 0;
  37 }
  38
  39 int zebra_lock_rdwr_destroy (Zebra_lock_rdwr *p)
  40 {
  41     assert (p->readers_reading == 0);
  42     assert (p->writers_writing == 0);
  43     pthread_mutex_destroy (&p->mutex);
  44     pthread_cond_destroy (&p->lock_free);
  45     return 0;
  46 }
  47
  48 int zebra_lock_rdwr_rlock (Zebra_lock_rdwr *p)
  49 {
  50     pthread_mutex_lock (& p->mutex);
  51     while (p->writers_writing)
  52         pthread_cond_wait (&p->lock_free, &p->mutex);
  53     p->readers_reading++;
  54     pthread_mutex_unlock(&p->mutex);
  55     return 0;
  56 }
  57
  58 int zebra_lock_rdwr_wlock (Zebra_lock_rdwr *p)
  59 {
  60     pthread_mutex_lock (&p->mutex);
  61     while (p->writers_writing || p->readers_reading)
  62         pthread_cond_wait (&p->lock_free, &p->mutex);
  63     p->writers_writing++;
  64     pthread_mutex_unlock (&p->mutex);
  65     return 0;
  66 }
  67
  68 int zebra_lock_rdwr_runlock (Zebra_lock_rdwr *p)
  69 {
  70     pthread_mutex_lock (&p->mutex);
  71     if (p->readers_reading == 0)
  72     {
  73         pthread_mutex_unlock (&p->mutex);
  74         return -1;
  75     }
  76     else
  77     {
  78         p->readers_reading--;
  79         if (p->readers_reading == 0)
  80             pthread_cond_signal (&p->lock_free);
  81         pthread_mutex_unlock (&p->mutex);
  82     }
  83     return 0;
  84 }
  85
  86 int zebra_lock_rdwr_wunlock (Zebra_lock_rdwr *p)
  87 {
  88     pthread_mutex_lock (&p->mutex);
  89     if (p->writers_writing == 0)
  90     {
  91         pthread_mutex_unlock (&p->mutex);
  92         return -1;
  93     }
  94     else
  95     {
  96         p->writers_writing--;
  97         pthread_cond_broadcast(&p->lock_free);
  98         pthread_mutex_unlock(&p->mutex);
  99     }
 100     return 0;
 101 }
 102
 103 int zebra_mutex_cond_init (Zebra_mutex_cond *p)
 104 {
 105     pthread_cond_init (&p->cond, 0);
 106     pthread_mutex_init (&p->mutex, 0);
 107     return 0;
 108 }
 109
 110 int zebra_mutex_cond_destroy (Zebra_mutex_cond *p)
 111 {
 112     pthread_cond_destroy (&p->cond);
 113     pthread_mutex_destroy (&p->mutex);
 114     return 0;
 115 }
 116
 117 int zebra_mutex_cond_lock (Zebra_mutex_cond *p)
 118 {
 119     return pthread_mutex_lock (&p->mutex);
 120 }
 121
 122 int zebra_mutex_cond_unlock (Zebra_mutex_cond *p)
 123 {
 124     return pthread_mutex_unlock (&p->mutex);
 125 }
 126
 127 int zebra_mutex_cond_wait (Zebra_mutex_cond *p)
 128 {
 129     return pthread_cond_wait (&p->cond, &p->mutex);
 130 }
 131
 132 int zebra_mutex_cond_signal (Zebra_mutex_cond *p)
 133 {
 134     return pthread_cond_signal (&p->cond);
 135 }
 136