posix_sema.c File Reference

#include "postgres.h"
#include <fcntl.h>
#include <semaphore.h>
#include <signal.h>
#include <unistd.h>
#include <sys/stat.h>
#include "miscadmin.h"
#include "storage/ipc.h"
#include "storage/pg_sema.h"
#include "storage/shmem.h"

Include dependency graph for posix_sema.c:

Go to the source code of this file.

Data Structures
union	SemTPadded
struct	PGSemaphoreData

Macros
#define	PG_SEM_REF(x)   (&(x)->sem_padded.pgsem)
#define	IPCProtection   (0600) /* access/modify by user only */

Typedefs
typedef union SemTPadded	SemTPadded
typedef struct PGSemaphoreData	PGSemaphoreData

Functions
static void	ReleaseSemaphores (int status, Datum arg)
static void	PosixSemaphoreCreate (sem_t *sem)
static void	PosixSemaphoreKill (sem_t *sem)
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)

Variables
static PGSemaphore	sharedSemas
static int	numSems
static int	maxSems
static int	nextSemKey

Macro Definition Documentation

IPCProtection

#define IPCProtection   (0600) /* access/modify by user only */

Definition at line 59 of file posix_sema.c.

PG_SEM_REF

#define PG_SEM_REF

(

x

)

(&(x)->sem_padded.pgsem)

Definition at line 57 of file posix_sema.c.

Typedef Documentation

PGSemaphoreData

typedef struct PGSemaphoreData PGSemaphoreData

SemTPadded

typedef union SemTPadded SemTPadded

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.
     */
    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, maxSems, nextSemKey, numSems, on_shmem_exit(), PANIC, PGSemaphoreShmemSize(), ReleaseSemaphores(), sharedSemas, ShmemAllocUnlocked(), stat::st_ino, and stat.

Referenced by CreateSharedMemoryAndSemaphores().

PGSemaphoreCreate()

PGSemaphore PGSemaphoreCreate

(

void

)

Definition at line 261 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, IsUnderPostmaster, maxSems, numSems, PANIC, PG_SEM_REF, PosixSemaphoreCreate(), and sharedSemas.

Referenced by InitProcGlobal().

PGSemaphoreLock()

void PGSemaphoreLock

(

PGSemaphore

sema

)

Definition at line 319 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 EINTR, elog, FATAL, and PG_SEM_REF.

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

PGSemaphoreReset()

void PGSemaphoreReset

(

PGSemaphore

sema

)

Definition at line 294 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, and PG_SEM_REF.

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 364 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, FATAL, and PG_SEM_REF.

PGSemaphoreUnlock()

void PGSemaphoreUnlock

(

PGSemaphore

sema

)

Definition at line 339 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, FATAL, and PG_SEM_REF.

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

PosixSemaphoreCreate()

static void PosixSemaphoreCreate ( sem_t *  sem )

static

Definition at line 135 of file posix_sema.c.

{
    if (sem_init(sem, 1, 1) < 0)
        elog(FATAL, "sem_init failed: %m");
}

References elog, FATAL, and sem.

Referenced by PGSemaphoreCreate().

PosixSemaphoreKill()

static void PosixSemaphoreKill ( sem_t *  sem )

static

Definition at line 147 of file posix_sema.c.

{
#ifdef USE_NAMED_POSIX_SEMAPHORES
    /* Got to use sem_close for named semaphores */
    if (sem_close(sem) < 0)
        elog(LOG, "sem_close failed: %m");
#else
    /* Got to use sem_destroy for unnamed semaphores */
    if (sem_destroy(sem) < 0)
        elog(LOG, "sem_destroy failed: %m");
#endif
}

References elog, LOG, and sem.

Referenced by ReleaseSemaphores().

ReleaseSemaphores()

static void ReleaseSemaphores ( int  status, Datum  arg  )

static

Definition at line 239 of file posix_sema.c.

{
    int         i;
 
#ifdef USE_NAMED_POSIX_SEMAPHORES
    for (i = 0; i < numSems; i++)
        PosixSemaphoreKill(mySemPointers[i]);
    free(mySemPointers);
#endif
 
#ifdef USE_UNNAMED_POSIX_SEMAPHORES
    for (i = 0; i < numSems; i++)
        PosixSemaphoreKill(PG_SEM_REF(sharedSemas + i));
#endif
}

References free, i, numSems, PG_SEM_REF, PosixSemaphoreKill(), and sharedSemas.

Referenced by PGReserveSemaphores().

Variable Documentation

maxSems

int maxSems

static

Definition at line 67 of file posix_sema.c.

Referenced by PGReserveSemaphores(), and PGSemaphoreCreate().

nextSemKey

int nextSemKey

static

Definition at line 68 of file posix_sema.c.

Referenced by PGReserveSemaphores().

numSems

int numSems

static

Definition at line 66 of file posix_sema.c.

Referenced by InternalIpcSemaphoreCreate(), IpcSemaphoreCreate(), PGReserveSemaphores(), PGSemaphoreCreate(), and ReleaseSemaphores().

sharedSemas

PGSemaphore sharedSemas

static

Definition at line 64 of file posix_sema.c.

Referenced by PGReserveSemaphores(), PGSemaphoreCreate(), and ReleaseSemaphores().