This graph shows which files directly or indirectly include this file:

Typedefs
typedef struct PGSemaphoreData *	PGSemaphore

Functions
Size	PGSemaphoreShmemSize (int maxSemas)

void	PGReserveSemaphores (int maxSemas)

PGSemaphore	PGSemaphoreCreate (void)

void	PGSemaphoreReset (PGSemaphore sema)

void	PGSemaphoreLock (PGSemaphore sema)

void	PGSemaphoreUnlock (PGSemaphore sema)

bool	PGSemaphoreTryLock (PGSemaphore sema)

Typedef Documentation

◆ PGSemaphore

typedef struct PGSemaphoreData* PGSemaphore

Definition at line 34 of file pg_sema.h.

Function Documentation

◆ PGReserveSemaphores()

void PGReserveSemaphores ( int maxSemas )

Definition at line 196 of file posix_sema.c.

 {
     struct stat statbuf;
  
     /*
      * We use the data directory's inode number to seed the search for free
      * semaphore keys.  This minimizes the odds of collision with other
      * postmasters, while maximizing the odds that we will detect and clean up
      * semaphores left over from a crashed postmaster in our own directory.
      */
     if (stat(DataDir, &statbuf) < 0)
         ereport(FATAL,
                 (errcode_for_file_access(),
                  errmsg("could not stat data directory \"%s\": %m",
                         DataDir)));
  
 #ifdef USE_NAMED_POSIX_SEMAPHORES
     mySemPointers = (sem_t **) malloc(maxSemas * sizeof(sem_t *));
     if (mySemPointers == NULL)
         elog(PANIC, "out of memory");
 #else
  
     /*
      * We must use ShmemAllocUnlocked(), since the spinlock protecting
      * ShmemAlloc() won't be ready yet.  (This ordering is necessary when we
      * are emulating spinlocks with semaphores.)
      */
     sharedSemas = (PGSemaphore)
         ShmemAllocUnlocked(PGSemaphoreShmemSize(maxSemas));
 #endif
  
     numSems = 0;
     maxSems = maxSemas;
     nextSemKey = statbuf.st_ino;
  
     on_shmem_exit(ReleaseSemaphores, 0);
 }

References DataDir, elog, ereport, errcode_for_file_access(), errmsg(), FATAL, malloc, maxSemaSets, maxSems, maxSharedSemas, mySemaSets, mySemSet, nextSemaKey, nextSemaNumber, nextSemKey, numSemaSets, numSems, numSharedSemas, on_shmem_exit(), PANIC, PGSemaphoreShmemSize(), ReleaseSemaphores(), SEMAS_PER_SET, sharedSemas, ShmemAllocUnlocked(), stat::st_ino, and stat.

Referenced by CreateSharedMemoryAndSemaphores().

◆ PGSemaphoreCreate()

PGSemaphore PGSemaphoreCreate ( void )

Definition at line 262 of file posix_sema.c.

 {
     PGSemaphore sema;
     sem_t      *newsem;
  
     /* Can't do this in a backend, because static state is postmaster's */
     Assert(!IsUnderPostmaster);
  
     if (numSems >= maxSems)
         elog(PANIC, "too many semaphores created");
  
 #ifdef USE_NAMED_POSIX_SEMAPHORES
     newsem = PosixSemaphoreCreate();
     /* Remember new sema for ReleaseSemaphores */
     mySemPointers[numSems] = newsem;
     sema = (PGSemaphore) newsem;
 #else
     sema = &sharedSemas[numSems];
     newsem = PG_SEM_REF(sema);
     PosixSemaphoreCreate(newsem);
 #endif
  
     numSems++;
  
     return sema;
 }

References Assert, elog, ereport, errmsg(), IpcSemaphoreCreate(), IpcSemaphoreInitialize(), IsUnderPostmaster, maxSemaSets, maxSems, maxSharedSemas, mySemaSets, mySemSet, nextSemaNumber, numSemaSets, numSems, numSharedSemas, PANIC, PG_SEM_REF, PosixSemaphoreCreate(), SEMAS_PER_SET, PGSemaphoreData::semId, PGSemaphoreData::semNum, and sharedSemas.

Referenced by InitProcGlobal(), and SpinlockSemaInit().

◆ PGSemaphoreLock()

void PGSemaphoreLock ( PGSemaphore sema )

Definition at line 320 of file posix_sema.c.

 {
     int         errStatus;
  
     /* See notes in sysv_sema.c's implementation of PGSemaphoreLock. */
     do
     {
         errStatus = sem_wait(PG_SEM_REF(sema));
     } while (errStatus < 0 && errno == EINTR);
  
     if (errStatus < 0)
         elog(FATAL, "sem_wait failed: %m");
 }

References CHECK_FOR_INTERRUPTS, EINTR, elog, ereport, errmsg(), FATAL, PG_SEM_REF, pgwin32_dispatch_queued_signals(), pgwin32_signal_event, PGSemaphoreData::semId, and PGSemaphoreData::semNum.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), LWLockDequeueSelf(), LWLockWaitForVar(), ProcArrayGroupClearXid(), and TransactionGroupUpdateXidStatus().

◆ PGSemaphoreReset()

void PGSemaphoreReset ( PGSemaphore sema )

Definition at line 295 of file posix_sema.c.

 {
     /*
      * There's no direct API for this in POSIX, so we have to ratchet the
      * semaphore down to 0 with repeated trywait's.
      */
     for (;;)
     {
         if (sem_trywait(PG_SEM_REF(sema)) < 0)
         {
             if (errno == EAGAIN || errno == EDEADLK)
                 break;          /* got it down to 0 */
             if (errno == EINTR)
                 continue;       /* can this happen? */
             elog(FATAL, "sem_trywait failed: %m");
         }
     }
 }

References EAGAIN, EINTR, elog, FATAL, IpcSemaphoreInitialize(), PG_SEM_REF, PGSemaphoreTryLock(), PGSemaphoreData::semId, and PGSemaphoreData::semNum.

Referenced by InitAuxiliaryProcess(), and InitProcess().

◆ PGSemaphoreShmemSize()

Size PGSemaphoreShmemSize ( int maxSemas )

Definition at line 165 of file posix_sema.c.

 {
 #ifdef USE_NAMED_POSIX_SEMAPHORES
     /* No shared memory needed in this case */
     return 0;
 #else
     /* Need a PGSemaphoreData per semaphore */
     return mul_size(maxSemas, sizeof(PGSemaphoreData));
 #endif
 }

References mul_size().

Referenced by CalculateShmemSize(), and PGReserveSemaphores().

◆ PGSemaphoreTryLock()

bool PGSemaphoreTryLock ( PGSemaphore sema )

Definition at line 365 of file posix_sema.c.

 {
     int         errStatus;
  
     /*
      * Note: if errStatus is -1 and errno == EINTR then it means we returned
      * from the operation prematurely because we were sent a signal.  So we
      * try and lock the semaphore again.
      */
     do
     {
         errStatus = sem_trywait(PG_SEM_REF(sema));
     } while (errStatus < 0 && errno == EINTR);
  
     if (errStatus < 0)
     {
         if (errno == EAGAIN || errno == EDEADLK)
             return false;       /* failed to lock it */
         /* Otherwise we got trouble */
         elog(FATAL, "sem_trywait failed: %m");
     }
  
     return true;
 }

References EAGAIN, EINTR, elog, ereport, errmsg(), EWOULDBLOCK, FATAL, IPC_NOWAIT, PG_SEM_REF, PGSemaphoreData::semId, and PGSemaphoreData::semNum.

Referenced by PGSemaphoreReset(), and tas_sema().

◆ PGSemaphoreUnlock()

void PGSemaphoreUnlock ( PGSemaphore sema )

Definition at line 340 of file posix_sema.c.

 {
     int         errStatus;
  
     /*
      * Note: if errStatus is -1 and errno == EINTR then it means we returned
      * from the operation prematurely because we were sent a signal.  So we
      * try and unlock the semaphore again. Not clear this can really happen,
      * but might as well cope.
      */
     do
     {
         errStatus = sem_post(PG_SEM_REF(sema));
     } while (errStatus < 0 && errno == EINTR);
  
     if (errStatus < 0)
         elog(FATAL, "sem_post failed: %m");
 }

References EINTR, elog, ereport, errmsg(), FATAL, PG_SEM_REF, PGSemaphoreData::semId, and PGSemaphoreData::semNum.

Referenced by IpcSemaphoreCreate(), LWLockAcquire(), LWLockAcquireOrWait(), LWLockDequeueSelf(), LWLockUpdateVar(), LWLockWaitForVar(), LWLockWakeup(), ProcArrayGroupClearXid(), s_unlock_sema(), and TransactionGroupUpdateXidStatus().

Typedefs

Functions