source/tdb/spinlock.c

   1 #if STANDALONE
   2 #if HAVE_CONFIG_H
   3 #include <config.h>
   4 #endif
   5
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <unistd.h>
   9 #include <string.h>
  10 #include <fcntl.h>
  11 #include <errno.h>
  12 #include <sys/stat.h>
  13 #include <time.h>
  14 #include "tdb.h"
  15 #include "spinlock.h"
  16
  17 #define DEBUG
  18 #else
  19 #include "includes.h"
  20 #endif
  21
  22 #ifdef USE_SPINLOCKS
  23
  24 /*
  25  * ARCH SPECIFIC
  26  */
  27
  28 #if defined(SPARC_SPINLOCKS)
  29
  30 static inline int __spin_trylock(spinlock_t *lock)
  31 {
  32         unsigned int result;
  33
  34         asm volatile("ldstub    [%1], %0"
  35                 : "=r" (result)
  36                 : "r" (lock)
  37                 : "memory");
  38
  39         return (result == 0) ? 0 : EBUSY;
  40 }
  41
  42 static inline void __spin_unlock(spinlock_t *lock)
  43 {
  44         *lock = 0;
  45 }
  46
  47 static inline void __spin_lock_init(spinlock_t *lock)
  48 {
  49         *lock = 0;
  50 }
  51
  52 static inline int __spin_is_locked(spinlock_t *lock)
  53 {
  54         return (*lock != 0);
  55 }
  56
  57 #elif defined(POWERPC_SPINLOCKS)
  58
  59 static inline int __spin_trylock(spinlock_t *lock)
  60 {
  61         int result;
  62
  63         __asm__ __volatile__ (
  64                 "       eieio;"
  65                 "0:     lwarx %0,0,%1;"
  66                 "       cmpwi 0,%0,0;"
  67                 "       bne- 1f;"
  68                 "       stwcx. %2,0,%1;"
  69                 "       bne- 0b;"
  70                 "       sync;"
  71                 "1:"
  72                 : "=&r"(result)
  73                 : "r"(lock), "r"(1)
  74                 : "cr0", "memory");
  75
  76         return (result == 0) ? 0 : EBUSY;
  77 }
  78
  79 static inline void __spin_unlock(spinlock_t *lock)
  80 {
  81         asm volatile("sync");
  82         *lock = 0;
  83 }
  84
  85 static inline void __spin_lock_init(spinlock_t *lock)
  86 {
  87         *lock = 0;
  88 }
  89
  90 static inline int __spin_is_locked(spinlock_t *lock)
  91 {
  92         return (*lock != 0);
  93 }
  94
  95 #elif defined(INTEL_SPINLOCKS)
  96
  97 static inline int __spin_trylock(spinlock_t *lock)
  98 {
  99         int oldval;
 100
 101         asm volatile("xchgl %0,%1"
 102                 : "=r" (oldval), "=m" (*lock)
 103                 : "0" (0));
 104         return oldval > 0 ? 0 : EBUSY;
 105 }
 106
 107 static inline void __spin_unlock(spinlock_t *lock)
 108 {
 109         *lock = 1;
 110 }
 111
 112 static inline void __spin_lock_init(spinlock_t *lock)
 113 {
 114         *lock = 1;
 115 }
 116
 117 static inline int __spin_is_locked(spinlock_t *lock)
 118 {
 119         return (*lock != 1);
 120 }
 121
 122 #elif defined(MIPS_SPINLOCKS)
 123
 124 static inline unsigned int load_linked(unsigned long addr)
 125 {
 126         unsigned int res;
 127
 128         __asm__ __volatile__("ll\t%0,(%1)"
 129                 : "=r" (res)
 130                 : "r" (addr));
 131
 132         return res;
 133 }
 134
 135 static inline unsigned int store_conditional(unsigned long addr, unsigned int value)
 136 {
 137         unsigned int res;
 138
 139         __asm__ __volatile__("sc\t%0,(%2)"
 140                 : "=r" (res)
 141                 : "0" (value), "r" (addr));
 142         return res;
 143 }
 144
 145 static inline int __spin_trylock(spinlock_t *lock)
 146 {
 147         unsigned int mw;
 148
 149         do {
 150                 mw = load_linked(lock);
 151                 if (mw)
 152                         return EBUSY;
 153         } while (!store_conditional(lock, 1));
 154
 155         return 0;
 156 }
 157
 158 static inline void __spin_unlock(spinlock_t *lock)
 159 {
 160         *lock = 0;
 161 }
 162
 163 static inline void __spin_lock_init(spinlock_t *lock)
 164 {
 165         *lock = 0;
 166 }
 167
 168 static inline int __spin_is_locked(spinlock_t *lock)
 169 {
 170         return (*lock != 0);
 171 }
 172
 173 #else
 174 #error Need to implement spinlock code in spinlock.c
 175 #endif
 176
 177 /*
 178  * OS SPECIFIC
 179  */
 180
 181 static void yield_cpu(void)
 182 {
 183         struct timespec tm;
 184
 185 #ifdef USE_SCHED_YIELD
 186         sched_yield();
 187 #else
 188         /* Linux will busy loop for delays < 2ms on real time tasks */
 189         tm.tv_sec = 0;
 190         tm.tv_nsec = 2000000L + 1;
 191         nanosleep(&tm, NULL);
 192 #endif
 193 }
 194
 195 static int this_is_smp(void)
 196 {
 197         return 0;
 198 }
 199
 200 /*
 201  * GENERIC
 202  */
 203
 204 static int smp_machine = 0;
 205
 206 static inline void __spin_lock(spinlock_t *lock)
 207 {
 208         int ntries = 0;
 209
 210         while(__spin_trylock(lock)) {
 211                 while(__spin_is_locked(lock)) {
 212                         if (smp_machine && ntries++ < MAX_BUSY_LOOPS)
 213                                 continue;
 214                         yield_cpu();
 215                 }
 216         }
 217 }
 218
 219 static void __read_lock(rwlock_t *rwlock)
 220 {
 221         int ntries = 0;
 222
 223         while(1) {
 224                 __spin_lock(&rwlock->lock);
 225
 226                 if (!(rwlock->count & RWLOCK_BIAS)) {
 227                         rwlock->count++;
 228                         __spin_unlock(&rwlock->lock);
 229                         return;
 230                 }
 231
 232                 __spin_unlock(&rwlock->lock);
 233
 234                 while(rwlock->count & RWLOCK_BIAS) {
 235                         if (smp_machine && ntries++ < MAX_BUSY_LOOPS)
 236                                 continue;
 237                         yield_cpu();
 238                 }
 239         }
 240 }
 241
 242 static void __write_lock(rwlock_t *rwlock)
 243 {
 244         int ntries = 0;
 245
 246         while(1) {
 247                 __spin_lock(&rwlock->lock);
 248
 249                 if (rwlock->count == 0) {
 250                         rwlock->count |= RWLOCK_BIAS;
 251                         __spin_unlock(&rwlock->lock);
 252                         return;
 253                 }
 254
 255                 __spin_unlock(&rwlock->lock);
 256
 257                 while(rwlock->count != 0) {
 258                         if (smp_machine && ntries++ < MAX_BUSY_LOOPS)
 259                                 continue;
 260                         yield_cpu();
 261                 }
 262         }
 263 }
 264
 265 static void __write_unlock(rwlock_t *rwlock)
 266 {
 267         __spin_lock(&rwlock->lock);
 268
 269 #ifdef DEBUG
 270         if (!(rwlock->count & RWLOCK_BIAS))
 271                 fprintf(stderr, "bug: write_unlock\n");
 272 #endif
 273
 274         rwlock->count &= ~RWLOCK_BIAS;
 275         __spin_unlock(&rwlock->lock);
 276 }
 277
 278 static void __read_unlock(rwlock_t *rwlock)
 279 {
 280         __spin_lock(&rwlock->lock);
 281
 282 #ifdef DEBUG
 283         if (!rwlock->count)
 284                 fprintf(stderr, "bug: read_unlock\n");
 285
 286         if (rwlock->count & RWLOCK_BIAS)
 287                 fprintf(stderr, "bug: read_unlock\n");
 288 #endif
 289
 290         rwlock->count--;
 291         __spin_unlock(&rwlock->lock);
 292 }
 293
 294 /* TDB SPECIFIC */
 295
 296 /* lock a list in the database. list -1 is the alloc list */
 297 int tdb_spinlock(TDB_CONTEXT *tdb, int list, int rw_type)
 298 {
 299         rwlock_t *rwlocks;
 300
 301         if (!tdb->map_ptr) return -1;
 302         rwlocks = (rwlock_t *)((char *)tdb->map_ptr + tdb->header.rwlocks);
 303
 304         switch(rw_type) {
 305         case F_RDLCK:
 306                 __read_lock(&rwlocks[list+1]);
 307                 break;
 308
 309         case F_WRLCK:
 310                 __write_lock(&rwlocks[list+1]);
 311                 break;
 312
 313         default:
 314                 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
 315         }
 316         return 0;
 317 }
 318
 319 /* unlock the database. */
 320 int tdb_spinunlock(TDB_CONTEXT *tdb, int list, int rw_type)
 321 {
 322         rwlock_t *rwlocks;
 323
 324         if (!tdb->map_ptr) return -1;
 325         rwlocks = (rwlock_t *)((char *)tdb->map_ptr + tdb->header.rwlocks);
 326
 327         switch(rw_type) {
 328         case F_RDLCK:
 329                 __read_unlock(&rwlocks[list+1]);
 330                 break;
 331
 332         case F_WRLCK:
 333                 __write_unlock(&rwlocks[list+1]);
 334                 break;
 335
 336         default:
 337                 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
 338         }
 339
 340         return 0;
 341 }
 342
 343 int tdb_create_rwlocks(int fd, unsigned int hash_size)
 344 {
 345         unsigned size, i;
 346         rwlock_t *rwlocks;
 347
 348         size = (hash_size + 1) * sizeof(rwlock_t);
 349         rwlocks = malloc(size);
 350         if (!rwlocks)
 351                 return -1;
 352
 353         for(i = 0; i < hash_size+1; i++) {
 354                 __spin_lock_init(&rwlocks[i].lock);
 355                 rwlocks[i].count = 0;
 356         }
 357
 358         /* Write it out (appending to end) */
 359         if (write(fd, rwlocks, size) != size) {
 360                 free(rwlocks);
 361                 return -1;
 362         }
 363         smp_machine = this_is_smp();
 364         free(rwlocks);
 365         return 0;
 366 }
 367
 368 int tdb_clear_spinlocks(TDB_CONTEXT *tdb)
 369 {
 370         rwlock_t *rwlocks;
 371         unsigned i;
 372
 373         if (tdb->header.rwlocks == 0) return 0;
 374         if (!tdb->map_ptr) return -1;
 375
 376         /* We're mmapped here */
 377         rwlocks = (rwlock_t *)((char *)tdb->map_ptr + tdb->header.rwlocks);
 378         for(i = 0; i < tdb->header.hash_size+1; i++) {
 379                 __spin_lock_init(&rwlocks[i].lock);
 380                 rwlocks[i].count = 0;
 381         }
 382         return 0;
 383 }
 384 #else
 385 int tdb_create_rwlocks(int fd, unsigned int hash_size) { return 0; }
 386 int tdb_spinlock(TDB_CONTEXT *tdb, int list, int rw_type) { return -1; }
 387 int tdb_spinunlock(TDB_CONTEXT *tdb, int list, int rw_type) { return -1; }
 388
 389 /* Non-spinlock version: remove spinlock pointer */
 390 int tdb_clear_spinlocks(TDB_CONTEXT *tdb)
 391 {
 392         tdb_off off = (tdb_off)((char *)&tdb->header.rwlocks
 393                                 - (char *)&tdb->header);
 394
 395         tdb->header.rwlocks = 0;
 396         if (lseek(tdb->fd, off, SEEK_SET) != off
 397             || write(tdb->fd, (void *)&tdb->header.rwlocks,
 398                      sizeof(tdb->header.rwlocks))
 399             != sizeof(tdb->header.rwlocks))
 400                 return -1;
 401         return 0;
 402 }
 403 #endif