sysv_sema.c File Reference

#include "postgres.h"
#include <signal.h>
#include <unistd.h>
#include <sys/file.h>
#include <sys/ipc.h>
#include <sys/sem.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 sysv_sema.c:

Go to the source code of this file.

Data Structures
struct	PGSemaphoreData
union	semun

Macros
#define	SEMAS_PER_SET   16
#define	IPCProtection   (0600) /* access/modify by user only */
#define	PGSemaMagic   537 /* must be less than SEMVMX */

Typedefs
typedef struct PGSemaphoreData	PGSemaphoreData
typedef key_t	IpcSemaphoreKey
typedef int	IpcSemaphoreId

Functions
static IpcSemaphoreId	InternalIpcSemaphoreCreate (IpcSemaphoreKey semKey, int numSems, bool retry_ok)
static void	IpcSemaphoreInitialize (IpcSemaphoreId semId, int semNum, int value)
static void	IpcSemaphoreKill (IpcSemaphoreId semId)
static int	IpcSemaphoreGetValue (IpcSemaphoreId semId, int semNum)
static pid_t	IpcSemaphoreGetLastPID (IpcSemaphoreId semId, int semNum)
static IpcSemaphoreId	IpcSemaphoreCreate (int numSems)
static void	ReleaseSemaphores (int status, Datum arg)
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	numSharedSemas
static int	maxSharedSemas
static IpcSemaphoreId *	mySemaSets
static int	numSemaSets
static int	maxSemaSets
static IpcSemaphoreKey	nextSemaKey
static int	nextSemaNumber

Macro Definition Documentation

IPCProtection

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

Definition at line 56 of file sysv_sema.c.

PGSemaMagic

#define PGSemaMagic   537 /* must be less than SEMVMX */

Definition at line 58 of file sysv_sema.c.

SEMAS_PER_SET

#define SEMAS_PER_SET   16

Definition at line 54 of file sysv_sema.c.

Typedef Documentation

IpcSemaphoreId

typedef int IpcSemaphoreId

Definition at line 46 of file sysv_sema.c.

IpcSemaphoreKey

typedef key_t IpcSemaphoreKey

Definition at line 45 of file sysv_sema.c.

PGSemaphoreData

typedef struct PGSemaphoreData PGSemaphoreData

Function Documentation

InternalIpcSemaphoreCreate()

static IpcSemaphoreId InternalIpcSemaphoreCreate ( IpcSemaphoreKey  semKey, int  numSems, bool  retry_ok  )

static

Definition at line 97 of file sysv_sema.c.

{
    int         semId;
 
    semId = semget(semKey, numSems, IPC_CREAT | IPC_EXCL | IPCProtection);
 
    if (semId < 0)
    {
        int         saved_errno = errno;
 
        /*
         * Fail quietly if error suggests a collision with an existing set and
         * our caller has not lost patience.
         *
         * One would expect EEXIST, given that we said IPC_EXCL, but perhaps
         * we could get a permission violation instead.  On some platforms
         * EINVAL will be reported if the existing set has too few semaphores.
         * Also, EIDRM might occur if an old set is slated for destruction but
         * not gone yet.
         *
         * EINVAL is the key reason why we need the caller-level loop limit,
         * as it can also mean that the platform's SEMMSL is less than
         * numSems, and that condition can't be fixed by trying another key.
         */
        if (retry_ok &&
            (saved_errno == EEXIST
             || saved_errno == EACCES
             || saved_errno == EINVAL
#ifdef EIDRM
             || saved_errno == EIDRM
#endif
             ))
            return -1;
 
        /*
         * Else complain and abort
         */
        ereport(FATAL,
                (errmsg("could not create semaphores: %m"),
                 errdetail("Failed system call was semget(%lu, %d, 0%o).",
                           (unsigned long) semKey, numSems,
                           IPC_CREAT | IPC_EXCL | IPCProtection),
                 (saved_errno == ENOSPC) ?
                 errhint("This error does *not* mean that you have run out of disk space.  "
                         "It occurs when either the system limit for the maximum number of "
                         "semaphore sets (SEMMNI), or the system wide maximum number of "
                         "semaphores (SEMMNS), would be exceeded.  You need to raise the "
                         "respective kernel parameter.  Alternatively, reduce PostgreSQL's "
                         "consumption of semaphores by reducing its \"max_connections\" parameter.\n"
                         "The PostgreSQL documentation contains more information about "
                         "configuring your system for PostgreSQL.") : 0));
    }
 
    return semId;
}

References EIDRM, ereport, errdetail(), errhint(), errmsg(), FATAL, IPC_CREAT, IPC_EXCL, IPCProtection, and numSems.

Referenced by IpcSemaphoreCreate().

IpcSemaphoreCreate()

static IpcSemaphoreId IpcSemaphoreCreate ( int  numSems )

static

Definition at line 223 of file sysv_sema.c.

{
    int         num_tries = 0;
    IpcSemaphoreId semId;
    union semun semun;
    PGSemaphoreData mysema;
 
    /* Loop till we find a free IPC key */
    for (nextSemaKey++;; nextSemaKey++, num_tries++)
    {
        pid_t       creatorPID;
 
        /*
         * Try to create new semaphore set.  Give up after trying 1000
         * distinct IPC keys.
         */
        semId = InternalIpcSemaphoreCreate(nextSemaKey, numSems + 1,
                                           num_tries < 1000);
        if (semId >= 0)
            break;              /* successful create */
 
        /* See if it looks to be leftover from a dead Postgres process */
        semId = semget(nextSemaKey, numSems + 1, 0);
        if (semId < 0)
            continue;           /* failed: must be some other app's */
        if (IpcSemaphoreGetValue(semId, numSems) != PGSemaMagic)
            continue;           /* sema belongs to a non-Postgres app */
 
        /*
         * If the creator PID is my own PID or does not belong to any extant
         * process, it's safe to zap it.
         */
        creatorPID = IpcSemaphoreGetLastPID(semId, numSems);
        if (creatorPID <= 0)
            continue;           /* oops, GETPID failed */
        if (creatorPID != getpid())
        {
            if (kill(creatorPID, 0) == 0 || errno != ESRCH)
                continue;       /* sema belongs to a live process */
        }
 
        /*
         * The sema set appears to be from a dead Postgres process, or from a
         * previous cycle of life in this same process.  Zap it, if possible.
         * This probably shouldn't fail, but if it does, assume the sema set
         * belongs to someone else after all, and continue quietly.
         */
        semun.val = 0;          /* unused, but keep compiler quiet */
        if (semctl(semId, 0, IPC_RMID, semun) < 0)
            continue;
 
        /*
         * Now try again to create the sema set.
         */
        semId = InternalIpcSemaphoreCreate(nextSemaKey, numSems + 1, true);
        if (semId >= 0)
            break;              /* successful create */
 
        /*
         * Can only get here if some other process managed to create the same
         * sema key before we did.  Let him have that one, loop around to try
         * next key.
         */
    }
 
    /*
     * OK, we created a new sema set.  Mark it as created by this process. We
     * do this by setting the spare semaphore to PGSemaMagic-1 and then
     * incrementing it with semop().  That leaves it with value PGSemaMagic
     * and sempid referencing this process.
     */
    IpcSemaphoreInitialize(semId, numSems, PGSemaMagic - 1);
    mysema.semId = semId;
    mysema.semNum = numSems;
    PGSemaphoreUnlock(&mysema);
 
    return semId;
}

References InternalIpcSemaphoreCreate(), IPC_RMID, IpcSemaphoreGetLastPID(), IpcSemaphoreGetValue(), IpcSemaphoreInitialize(), kill, nextSemaKey, numSems, PGSemaMagic, PGSemaphoreUnlock(), and semun::val.

Referenced by PGSemaphoreCreate().

IpcSemaphoreGetLastPID()

static pid_t IpcSemaphoreGetLastPID ( IpcSemaphoreId  semId, int  semNum  )

static

Definition at line 203 of file sysv_sema.c.

{
    union semun dummy;          /* for Solaris */
 
    dummy.val = 0;              /* unused */
 
    return semctl(semId, semNum, GETPID, dummy);
}

References GETPID, and semun::val.

Referenced by IpcSemaphoreCreate().

IpcSemaphoreGetValue()

static int IpcSemaphoreGetValue ( IpcSemaphoreId  semId, int  semNum  )

static

Definition at line 192 of file sysv_sema.c.

{
    union semun dummy;          /* for Solaris */
 
    dummy.val = 0;              /* unused */
 
    return semctl(semId, semNum, GETVAL, dummy);
}

References GETVAL, and semun::val.

Referenced by IpcSemaphoreCreate().

IpcSemaphoreInitialize()

static void IpcSemaphoreInitialize ( IpcSemaphoreId  semId, int  semNum, int  value  )

static

Definition at line 157 of file sysv_sema.c.

{
    union semun semun;
 
    semun.val = value;
    if (semctl(semId, semNum, SETVAL, semun) < 0)
    {
        int         saved_errno = errno;
 
        ereport(FATAL,
                (errmsg_internal("semctl(%d, %d, SETVAL, %d) failed: %m",
                                 semId, semNum, value),
                 (saved_errno == ERANGE) ?
                 errhint("You possibly need to raise your kernel's SEMVMX value to be at least "
                         "%d.  Look into the PostgreSQL documentation for details.",
                         value) : 0));
    }
}

References ereport, errhint(), errmsg_internal(), FATAL, SETVAL, semun::val, and value.

Referenced by IpcSemaphoreCreate(), PGSemaphoreCreate(), and PGSemaphoreReset().

IpcSemaphoreKill()

static void IpcSemaphoreKill ( IpcSemaphoreId  semId )

static

Definition at line 180 of file sysv_sema.c.

{
    union semun semun;
 
    semun.val = 0;              /* unused, but keep compiler quiet */
 
    if (semctl(semId, 0, IPC_RMID, semun) < 0)
        elog(LOG, "semctl(%d, 0, IPC_RMID, ...) failed: %m", semId);
}

References elog, IPC_RMID, LOG, and semun::val.

Referenced by ReleaseSemaphores().

PGReserveSemaphores()

void PGReserveSemaphores

(

int

maxSemas

)

Definition at line 330 of file sysv_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)));
 
    sharedSemas = (PGSemaphore)
        ShmemAlloc(PGSemaphoreShmemSize(maxSemas));
    numSharedSemas = 0;
    maxSharedSemas = maxSemas;
 
    maxSemaSets = (maxSemas + SEMAS_PER_SET - 1) / SEMAS_PER_SET;
    mySemaSets = (IpcSemaphoreId *)
        malloc(maxSemaSets * sizeof(IpcSemaphoreId));
    if (mySemaSets == NULL)
        elog(PANIC, "out of memory");
    numSemaSets = 0;
    nextSemaKey = statbuf.st_ino;
    nextSemaNumber = SEMAS_PER_SET; /* force sema set alloc on 1st call */
 
    on_shmem_exit(ReleaseSemaphores, 0);
}

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

PGSemaphoreCreate()

PGSemaphore PGSemaphoreCreate

(

void

)

Definition at line 384 of file sysv_sema.c.

{
    PGSemaphore sema;
 
    /* Can't do this in a backend, because static state is postmaster's */
    Assert(!IsUnderPostmaster);
 
    if (nextSemaNumber >= SEMAS_PER_SET)
    {
        /* Time to allocate another semaphore set */
        if (numSemaSets >= maxSemaSets)
            elog(PANIC, "too many semaphores created");
        mySemaSets[numSemaSets] = IpcSemaphoreCreate(SEMAS_PER_SET);
        numSemaSets++;
        nextSemaNumber = 0;
    }
    /* Use the next shared PGSemaphoreData */
    if (numSharedSemas >= maxSharedSemas)
        elog(PANIC, "too many semaphores created");
    sema = &sharedSemas[numSharedSemas++];
    /* Assign the next free semaphore in the current set */
    sema->semId = mySemaSets[numSemaSets - 1];
    sema->semNum = nextSemaNumber++;
    /* Initialize it to count 1 */
    IpcSemaphoreInitialize(sema->semId, sema->semNum, 1);
 
    return sema;
}

References Assert(), elog, IpcSemaphoreCreate(), IpcSemaphoreInitialize(), IsUnderPostmaster, maxSemaSets, maxSharedSemas, mySemaSets, nextSemaNumber, numSemaSets, numSharedSemas, PANIC, SEMAS_PER_SET, PGSemaphoreData::semId, PGSemaphoreData::semNum, and sharedSemas.

PGSemaphoreLock()

void PGSemaphoreLock

(

PGSemaphore

sema

)

Definition at line 430 of file sysv_sema.c.

{
    int         errStatus;
    struct sembuf sops;
 
    sops.sem_op = -1;           /* decrement */
    sops.sem_flg = 0;
    sops.sem_num = sema->semNum;
 
    /*
     * 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.
     *
     * We used to check interrupts here, but that required servicing
     * interrupts directly from signal handlers. Which is hard to do safely
     * and portably.
     */
    do
    {
        errStatus = semop(sema->semId, &sops, 1);
    } while (errStatus < 0 && errno == EINTR);
 
    if (errStatus < 0)
        elog(FATAL, "semop(id=%d) failed: %m", sema->semId);
}

References EINTR, elog, FATAL, PGSemaphoreData::semId, and PGSemaphoreData::semNum.

PGSemaphoreReset()

void PGSemaphoreReset

(

PGSemaphore

sema

)

Definition at line 419 of file sysv_sema.c.

{
    IpcSemaphoreInitialize(sema->semId, sema->semNum, 0);
}

References IpcSemaphoreInitialize(), PGSemaphoreData::semId, and PGSemaphoreData::semNum.

PGSemaphoreShmemSize()

Size PGSemaphoreShmemSize

(

int

maxSemas

)

Definition at line 307 of file sysv_sema.c.

{
    return mul_size(maxSemas, sizeof(PGSemaphoreData));
}

References mul_size().

Referenced by PGReserveSemaphores().

PGSemaphoreTryLock()

bool PGSemaphoreTryLock

(

PGSemaphore

sema

)

Definition at line 493 of file sysv_sema.c.

{
    int         errStatus;
    struct sembuf sops;
 
    sops.sem_op = -1;           /* decrement */
    sops.sem_flg = IPC_NOWAIT;  /* but don't block */
    sops.sem_num = sema->semNum;
 
    /*
     * 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 = semop(sema->semId, &sops, 1);
    } while (errStatus < 0 && errno == EINTR);
 
    if (errStatus < 0)
    {
        /* Expect EAGAIN or EWOULDBLOCK (platform-dependent) */
#ifdef EAGAIN
        if (errno == EAGAIN)
            return false;       /* failed to lock it */
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
        if (errno == EWOULDBLOCK)
            return false;       /* failed to lock it */
#endif
        /* Otherwise we got trouble */
        elog(FATAL, "semop(id=%d) failed: %m", sema->semId);
    }
 
    return true;
}

References EAGAIN, EINTR, elog, EWOULDBLOCK, FATAL, IPC_NOWAIT, PGSemaphoreData::semId, and PGSemaphoreData::semNum.

PGSemaphoreUnlock()

void PGSemaphoreUnlock

(

PGSemaphore

sema

)

Definition at line 463 of file sysv_sema.c.

{
    int         errStatus;
    struct sembuf sops;
 
    sops.sem_op = 1;            /* increment */
    sops.sem_flg = 0;
    sops.sem_num = sema->semNum;
 
    /*
     * 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 = semop(sema->semId, &sops, 1);
    } while (errStatus < 0 && errno == EINTR);
 
    if (errStatus < 0)
        elog(FATAL, "semop(id=%d) failed: %m", sema->semId);
}

References EINTR, elog, FATAL, PGSemaphoreData::semId, and PGSemaphoreData::semNum.

Referenced by IpcSemaphoreCreate().

ReleaseSemaphores()

static void ReleaseSemaphores ( int  status, Datum  arg  )

static

Definition at line 369 of file sysv_sema.c.

{
    int         i;
 
    for (i = 0; i < numSemaSets; i++)
        IpcSemaphoreKill(mySemaSets[i]);
    free(mySemaSets);
}

References free, i, IpcSemaphoreKill(), mySemaSets, and numSemaSets.

Referenced by PGReserveSemaphores().

Variable Documentation

maxSemaSets

int maxSemaSets

static

Definition at line 66 of file sysv_sema.c.

Referenced by PGReserveSemaphores(), and PGSemaphoreCreate().

maxSharedSemas

int maxSharedSemas

static

Definition at line 63 of file sysv_sema.c.

Referenced by PGReserveSemaphores(), and PGSemaphoreCreate().

mySemaSets

IpcSemaphoreId* mySemaSets

static

Definition at line 64 of file sysv_sema.c.

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

nextSemaKey

IpcSemaphoreKey nextSemaKey

static

Definition at line 67 of file sysv_sema.c.

Referenced by IpcSemaphoreCreate(), and PGReserveSemaphores().

nextSemaNumber

int nextSemaNumber

static

Definition at line 68 of file sysv_sema.c.

Referenced by PGReserveSemaphores(), and PGSemaphoreCreate().

numSemaSets

int numSemaSets

static

Definition at line 65 of file sysv_sema.c.

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

numSharedSemas

int numSharedSemas

static

Definition at line 62 of file sysv_sema.c.

Referenced by PGReserveSemaphores(), and PGSemaphoreCreate().

sharedSemas

PGSemaphore sharedSemas

static

Definition at line 61 of file sysv_sema.c.

Referenced by PGReserveSemaphores(), and PGSemaphoreCreate().