home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / storage / ipc / spin.c < prev   
Encoding:
C/C++ Source or Header  |  1993-04-15  |  6.2 KB  |  266 lines
  1. /*
  2.  * spin.c -- routines for managing spin locks
  3.  *
  4.  * Identification:
  5.  *    $Header: /private/postgres/src/storage/ipc/RCS/spin.c,v 1.13 1992/04/13 21:33:36 mer Exp $
  6.  *
  7.  * POSTGRES has two kinds of locks: semaphores (which put the
  8.  * process to sleep) and spinlocks (which are supposed to be
  9.  * short term locks).  Currently both are implemented as SysV
  10.  * semaphores, but presumably this can change if we move to
  11.  * a machine with a test-and-set (TAS) instruction.  Its probably
  12.  * a good idea to think about (and allocate) short term and long
  13.  * term semaphores separately anyway.
  14.  *
  15.  * NOTE: These routines are not supposed to be widely used in Postgres.
  16.  *     They are preserved solely for the purpose of porting Mark Sullivan's
  17.  *     buffer manager to Postgres.
  18.  */
  19. #include <errno.h>
  20. #include "tmp/postgres.h"
  21. #include "storage/ipc.h"
  22. #include "storage/ipci.h"
  23. #include "storage/shmem.h"
  24. #include "storage/spin.h"
  25. #include "storage/proc.h"
  26. #include "utils/log.h"
  27.  
  28. /* globals used in this file */
  29. IpcSemaphoreId    SpinLockId;
  30.  
  31. #ifdef HAS_TEST_AND_SET
  32. /* real spin lock implementations */
  33.  
  34. CreateSpinlocks(key)
  35. IPCKey key;
  36. { 
  37.    /* the spin lock shared memory must have been created by now */
  38.    return(TRUE); 
  39. }
  40.  
  41. AttachSpinLocks(key)
  42. {
  43.     /* the spin lock shared memory must have been attached by now */
  44.     return(TRUE);
  45. }
  46.  
  47. InitSpinLocks(init, key)
  48. int init;
  49. IPCKey key;
  50. {
  51.   extern SPINLOCK ShmemLock;
  52.   extern SPINLOCK BindingLock;
  53.   extern SPINLOCK BufMgrLock;
  54.   extern SPINLOCK LockMgrLock;
  55.   extern SPINLOCK ProcStructLock;
  56.   extern SPINLOCK SInvalLock;
  57.   extern SPINLOCK OidGenLockId;
  58.  
  59. #ifdef SONY_JUKEBOX
  60.   extern SPINLOCK SJCacheLock;
  61.   extern SPINLOCK JBSpinLock;
  62. #endif /* SONY_JUKEBOX */
  63.  
  64. #ifdef MAIN_MEMORY
  65.   extern SPINLOCK MMCacheLock;
  66. #endif /* SONY_JUKEBOX */
  67.  
  68.   /* These six spinlocks have fixed location is shmem */
  69.   ShmemLock = (SPINLOCK) SHMEMLOCKID;
  70.   BindingLock = (SPINLOCK) BINDINGLOCKID;
  71.   BufMgrLock = (SPINLOCK) BUFMGRLOCKID;
  72.   LockMgrLock = (SPINLOCK) LOCKMGRLOCKID;
  73.   ProcStructLock = (SPINLOCK) PROCSTRUCTLOCKID;
  74.   SInvalLock = (SPINLOCK) SINVALLOCKID;
  75.   OidGenLockId = (SPINLOCK) OIDGENLOCKID;
  76.  
  77. #ifdef SONY_JUKEBOX
  78.   SJCacheLock = (SPINLOCK) SJCACHELOCKID;
  79.   JBSpinLock = (SPINLOCK) JBSPINLOCKID;
  80. #endif /* SONY_JUKEBOX */
  81.  
  82. #ifdef MAIN_MEMORY
  83.   MMCacheLock = (SPINLOCK) MMCACHELOCKID;
  84. #endif /* MAIN_MEMORY */
  85.  
  86.   return(TRUE);
  87. }
  88.  
  89. SpinAcquire(lock)
  90. SPINLOCK lock;
  91. {
  92.     ExclusiveLock(lock);
  93.     PROC_INCR_SLOCK(lock);
  94. }
  95.  
  96. SpinRelease(lock)
  97. SPINLOCK lock;
  98. {
  99.     PROC_DECR_SLOCK(lock);
  100.     ExclusiveUnlock(lock);
  101. }
  102.  
  103. SpinIsLocked(lock)
  104. SPINLOCK lock;
  105. {
  106.     return(!LockIsFree(lock));
  107. }
  108. #else /* HAS_TEST_AND_SET */
  109. /* Spinlocks are implemented using SysV semaphores */
  110.  
  111.  
  112. /*
  113.  * SpinAcquire -- try to grab a spinlock
  114.  *
  115.  * FAILS if the semaphore is corrupted.
  116.  */
  117. SpinAcquire(lock) 
  118. SPINLOCK    lock;
  119. {
  120.   IpcSemaphoreLock(SpinLockId, lock, IpcExclusiveLock);
  121.   PROC_INCR_SLOCK(lock);
  122. }
  123.  
  124. /*
  125.  * SpinRelease -- release a spin lock
  126.  * 
  127.  * FAILS if the semaphore is corrupted
  128.  */
  129. SpinRelease(lock) 
  130. SPINLOCK    lock;
  131. {
  132.   Assert(SpinIsLocked(lock))
  133.   PROC_DECR_SLOCK(lock);
  134.   IpcSemaphoreUnlock(SpinLockId, lock, IpcExclusiveLock);
  135. }
  136.  
  137. int
  138. SpinIsLocked(lock)
  139. SPINLOCK    lock;
  140. {
  141.    int semval;
  142.  
  143.    semval = IpcSemaphoreGetValue(SpinLockId, lock);
  144.    return(semval < IpcSemaphoreDefaultStartValue);
  145. }
  146.  
  147. /*
  148.  * CreateSpinlocks -- Create a sysV semaphore array for
  149.  *    the spinlocks
  150.  *
  151.  */
  152. CreateSpinlocks(key)
  153. IPCKey key;
  154. {
  155.  
  156.   int status;
  157.   IpcSemaphoreId semid;
  158.   semid = IpcSemaphoreCreate(key, MAX_SPINS, IPCProtection, 
  159.                  IpcSemaphoreDefaultStartValue, &status);
  160.   if (status == IpcSemIdExist) {
  161.     IpcSemaphoreKill(key);
  162.     elog(NOTICE,"Destroying old spinlock semaphore");
  163.     semid = IpcSemaphoreCreate(key, MAX_SPINS, IPCProtection, 
  164.                    IpcSemaphoreDefaultStartValue, &status);
  165.     }
  166.  
  167.   if (semid >= 0) {
  168.     SpinLockId = semid;
  169.     return(TRUE);
  170.   }
  171.   /* cannot create spinlocks */
  172.   elog(FATAL,"CreateSpinlocks: cannot create spin locks");
  173.   return(FALSE);
  174. }
  175.  
  176. /*
  177.  * Attach to existing spinlock set
  178.  */
  179. AttachSpinLocks(key)
  180. IPCKey key;
  181. {
  182.   IpcSemaphoreId id;
  183.  
  184. #ifdef linux
  185.   id = semget (key, MAX_SPINS, 0600);
  186. #else
  187.   id = semget (key, MAX_SPINS, 0);
  188. #endif
  189.   if (id < 0) {
  190.     if (errno == EEXIST) {
  191.       /* key is the name of someone else's semaphore */
  192.       elog (FATAL,"AttachSpinlocks: SPIN_KEY belongs to someone else");
  193.     }
  194.     /* cannot create spinlocks */
  195.     elog(FATAL,"AttachSpinlocks: cannot create spin locks");
  196.     return(FALSE);
  197.   }
  198.   SpinLockId = id;
  199.   return(TRUE);
  200. }
  201.  
  202. /*
  203.  * InitSpinLocks -- Spinlock bootstrapping
  204.  * 
  205.  * We need several spinlocks for bootstrapping:
  206.  * BindingLock (for the shmem binding table) and
  207.  * ShmemLock (for the shmem allocator), BufMgrLock (for buffer
  208.  * pool exclusive access), LockMgrLock (for the lock table), and
  209.  * ProcStructLock (a spin lock for the shared process structure).
  210.  * If there's a Sony WORM drive attached, we also have a spinlock
  211.  * (SJCacheLock) for it.  Same story for the main memory storage mgr.
  212.  *
  213.  */
  214. InitSpinLocks(init, key)
  215. int init;
  216. IPCKey key;
  217. {
  218.   extern SPINLOCK ShmemLock;
  219.   extern SPINLOCK BindingLock;
  220.   extern SPINLOCK BufMgrLock;
  221.   extern SPINLOCK LockMgrLock;
  222.   extern SPINLOCK ProcStructLock;
  223.   extern SPINLOCK SInvalLock;
  224.   extern SPINLOCK OidGenLockId;
  225.  
  226. #ifdef SONY_JUKEBOX
  227.   extern SPINLOCK SJCacheLock;
  228.   extern SPINLOCK JBSpinLock;
  229. #endif /* SONY_JUKEBOX */
  230.  
  231. #ifdef MAIN_MEMORY
  232.   extern SPINLOCK MMCacheLock;
  233. #endif /* MAIN_MEMORY */
  234.  
  235.   if (!init || key != IPC_PRIVATE) {
  236.       /* if bootstrap and key is IPC_PRIVATE, it means that we are running
  237.        * backend by itself.  no need to attach spinlocks
  238.        */
  239.       if (! AttachSpinLocks(key)) {
  240.         elog(FATAL,"InitSpinLocks: couldnt attach spin locks");
  241.         return(FALSE);
  242.       }
  243.     }
  244.  
  245.   /* These five (or six) spinlocks have fixed location is shmem */
  246.   ShmemLock = (SPINLOCK) SHMEMLOCKID;
  247.   BindingLock = (SPINLOCK) BINDINGLOCKID;
  248.   BufMgrLock = (SPINLOCK) BUFMGRLOCKID;
  249.   LockMgrLock = (SPINLOCK) LOCKMGRLOCKID;
  250.   ProcStructLock = (SPINLOCK) PROCSTRUCTLOCKID;
  251.   SInvalLock = (SPINLOCK) SINVALLOCKID;
  252.   OidGenLockId = (SPINLOCK) OIDGENLOCKID;
  253.  
  254. #ifdef SONY_JUKEBOX
  255.   SJCacheLock = (SPINLOCK) SJCACHELOCKID;
  256.   JBSpinLock = (SPINLOCK) JBSPINLOCKID;
  257. #endif /* SONY_JUKEBOX */
  258.  
  259. #ifdef MAIN_MEMORY
  260.   MMCacheLock = (SPINLOCK) MMCACHELOCKID;
  261. #endif /* MAIN_MEMORY */
  262.   
  263.   return(TRUE);
  264. }
  265. #endif /* HAS_TEST_AND_SET */
  266.