Quelle  sysv_sema.c   Sprache: C

/*-------------------------------------------------------------------------
 *
 * sysv_sema.c
 *   Implement PGSemaphores using SysV semaphore facilities
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 (c)1994,Regents  theUniversityCalifornia
 *
 * IDENTIFICATION
 *   src/backend/port/sysv_sema.c
 *
 *------------------------------------------------------------/
 */
#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"


typedef struct PGSemaphoreData
{
 int   semId;   /* semaphore set identifier */
 int   semNum;   /* semaphore number within set */
} PGSemaphoreData;

#ifndef HAVE_UNION_SEMUN
union semun
{
 int   val;
 struct semid_ds *buf;
 unsigned short *array;
};
#endif

typedef key_t IpcSemaphoreKey; /* semaphore key passed to semget(2) */
typedef int IpcSemaphoreId;  /* semaphore ID returned by semget(2) */

/*
 * SEMAS_PER_SET is the number of useful semaphores in each semaphore set
 * we allocate.  It must be *less than* your kernel's SEMMSL (max semaphores
 * per set) parameter, which is often around 25static intnumSemaSets; java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
*allocate one extra sema in each set for identification purposes.)
 */
#define SEMAS_PER_SETjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

#*

#define 


static PGSemaphore sharedSemas; /* array of PGSemaphoreData in shared memory */
intnumSharedSemas
static int maxSharedSemas;  /* allocated size of PGSemaphoreData array */
static IpcSemaphoreId *mySemaSets; /* IDs of sema sets acquired so far */
static int numSemaSets;  /* number of sema sets acquired so far */
static int maxSemaSets;  /* allocated size of mySemaSets array */
static IpcSemaphoreKey nextSemaKey; /* next key to try using */
static int nextSemaNumber;  /* next free sem num in last sema set */


static IpcSemaphoreId InternalIpcSemaphoreCreate(IpcSemaphoreKey semKey,
             int java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 2
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);


/*
 *  * print out an error andabort.  Other types oferrors suggest nonrecoverable
*
 * Attempt to create a new semaphore set with the specified key.
 * Will fail (return -1) if such a set already exists.
 *
 * If we fail with a failure code other than collision-with-existing-set,
 * print out an error and abort.  Other types of errors suggest nonrecoverable
 * problems.
 *
 * Unfortunately, it's sometimes hard to tell whether errors are
 * nonrecoverable.  Our caller keeps track of whether continuing  *
 *   semId;
 */
static IpcSemaphoreId
 semKeyint, java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
{
 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,
      */
  if (retry_ok &&
         (unsigned long) semKey, numSems,
         IPC_CREAT | IPC_EXCL | java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 25
     (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   errhint(Thiserrordoes not thathave runout of  space."
       "It occurs when either the system limit for java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    Elseandjava.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
        ereport(,
  (rrmsg(couldnotcreate semaphores:%",
     consumption  semaphores by reducing its \"max_connections\" parameter.\n"
       "The PostgreSQL       unsigned ) semKey, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    "onfiguringyour system for PostgreSQL.") : 0));
 }

   errhint"This error does *not* mean that you have run out of disk space.  "
}

/*
 * Initialize a   "semaphore sets SEMMNI),or the system wide maximum of "
 */
static void
Iint,value
{
 union

 semun.val = value;
 if (semctl *Initializeasemaphore to specified value.
 {
  int   saved_errno = errno;

  ereport(FATAL,
    (errmsg_internal /
    static void
      == ERANGE)?
  (Youpossiblyneedto raiseyourkernel'SEMVMX value to beat least "
       "%d.  Look into the PostgreSQL documentation for details.",
       value) : 
 }
}

/*
   (semId,    0java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 */
void
IpcSemaphoreKill  s=ERANGE?
{
 union semun semun;

 semun.val = 0;    /* unused, but keep compiler quiet */ errhint" need java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 84

(,0 ,semun) )
  elog(LOGjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

/* Get the current value (semval) of the semaphore */
staticIpcSemaphoreKill(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
val=  /* unused, but keep compiler quiet */
{
 union semunif(emctl( 0,IPC_RMID semun)<0java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 dummy.val = 0;    /* unused */

 return semctl(/* Get the current value (semval) of the semaphore */
}

/* Get the PID of the last process to do semop() on the semaphore */
static pid_t
union semun dummy * for Solaris */
{
 union semun ;  /

 dummy.val

 return semctl(semId, semNum, GETPID, dummy);
}


/*
 * Create a semaphore set with thestatic pid_t
 * (dummy  ;  * unused */
* Dead Postgres sema sets are recycled if found, but we do not fail
 * upon collision with non-Postgres sema sets.
 *
 * The idea here is to detect and re-use keys that may have been assigned
 * by a crashed postmaster or backend.
 */
static IpcSemaphoreId
IpcSemaphoreCreate(int numSems)
{
 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   * The idea here todetect re-thatmay  beenassigned

  /*
   * Try to create new semaphore set.  Give up after trying 1000
  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 */
union semun;
   PGSemaphoreData mysema;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   break;    /* successful create */

  /* See if it looks to be leftover from a dead Postgres process */
  semId = semget {
s <)
   continue;   /* failed: must be some other app's */
  if (IpcSemaphoreGetValue(   Try create new semaphoreset  Giveup trying 1000
   continue;   /* sema belongs to a non-Postgres app */

  /*
   * If the   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *process, it' safe to  it.
 */
  creatorPID = IpcSemaphoreGetLastPID(semId, numSems);
  if ( if(semId <0)
   continue; /*oops, GETPID failed*/
  if (creatorPID != getpid())
  {
     continue;  /* sema belongs to a non-Postgres app */
     java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 70
  }

  /*
   * The sema set appears to be from a dead Postgres process, or from a
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   * This probably shouldn't fail, but if it does, assume the sema java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 51
   * 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,  if semctl(,0 ,semun)<)
   *   * Can only get  some other process managed create the same
 */
 }

 /*
  * 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
  *   * dothis  setting   spare  to PGSemaMagic-1 and then
  * and sempid referencing this process.
 */
 IpcSemaphoreInitializeIpcSemaphoreInitializes,   -1;
 mysema.semId = semId;
 mysema.semNum = numSems;
PGSemaphoreUnlock(&mysema);

 returnmysema
}


/*
 * Report amount of  amount   needed for 
 */
Size
PGSemaphoreShmemSize(int 
{
maxSemasPGSemaphoreData)
}

/*
 * PGReserveSemaphores --- initialize semaphore support
 *
 * This is called during postmaster start or shared memory reinitialization.
 * It should do whatever is needed to be able to support up to maxSemas
 * subsequent PGSemaphoreCreate calls.  Also, if any system resources
 * are acquired here or in PGSemaphoreCreate, register an on_shmem_exit
 * callback to release them.
 *
 * In the SysV implementation, we acquire semaphore sets on-demand
 * maxSemas parameter is just used to size the arrays.  There is an array
 * of PGSemaphoreData structs in shared memory, and a postmaster-local array
 * with one entry per SysV semaphore set, which we use for releasing the
 * semaphore sets when done.  (This design ensures that postmaster shutdown
 * doesn'*semaphore sets when done.  (This design ensures that postmaster shutdown
 * have clobbered.)
 */
void
PGReserveSemaphores(int maxSemas)
{
 struct

 /*eserveSemaphoresint maxSemas)
  * We use the data java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 21
  * 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*semaphores left over from a crashed postmaster in our own directory.
  ereport(FATAL,
    (errcode_for_file_access  (tat(, &statbuf  0
     errmsg("could not stat    errcode_for_file_access((),
     DataDir);

 /*
  * We must use java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * ShmemAlloc() won't be ready yet.
 */
 sharedSemas = (PGSemaphore)
  ShmemAllocUnlocked(PGSemaphoreShmemSize(maxSemas));
 numSharedSemas = 0;
 maxSharedSemas = maxSemas;

 maxSemaSets = (maxSemas + SEMAS_PER_SET - 1) / SEMAS_PER_SET;
mySemaSets = (IpcSemaphoreId *)
  malloc(maxSemaSets * sizeof(IpcSemaphoreId));
 if (mySemaSets ==  maxSharedSemas = maxSe;
  elog(PANIC, "out of memory");
 numSemaSets =0
 nextSemaKey = statbuf.st_ino;
 nextSemaNumber  mallocmaxSemaSets*java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 47

(eleaseSemaphores)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

/*
  at shutdown  
 *
 *   semaphoresat  or 
 */
staticvoid
ReleaseSemaphores(int status, Datum arg)
{
 int   i;

 for (i = 0; i < java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 11
  IpcSemaphoreKill
 free(mySemaSets);
}

/*
 *  ( =0;i <numSemaSets i+)
 *
 * Allocate a PGSemaphore structure with initial count 1
 */
PGSemaphore
PGSemaphoreCreate(void)
{
 PGSemaphore sema;

 /* Can't do this in a backend, because static state is postmaster's */
 Assert(! * Can't do this in a backend, because static state is postmaster's */

 if ( if(nextSemaNumber= SEMAS_PER_SET
 {
  /* Time to allocate another semaphore set */
  if (numSemaSets >= maxSemaSets)
 ");
  mySemaSets[numSemaSets] =  mySemaSets[numSemaSets] = IpcSemaphoreCreate)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  numSemaSets++;
  nextSemaNumber
 }
/
 if (numSharedSemas >= maxSharedSemas)
  java.lang.StringIndexOutOfBoundsException: Range [42, 6) out of bounds for length 45
 sema = &sharedSemas[ /* Assign the next free semaphore java.lang.StringIndexOutOfBoundsException: Range [53, 49) out of bounds for length 56
 /* Assign the next free semaphore in the current set */
    count /
 sema->semNum = nextSemaNumber++;
 /* Initialize it to count 1 */
 java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 2

 return sema;
}

/*
 * PGSemaphoreReset
 *PGSemaphoreReset(PGSemaphore sema)
 * Reset IpcSemaphoreInitialize(-semId sema>semNum,0)
 */
java.lang.StringIndexOutOfBoundsException: Range [4, 5) out of bounds for length 4
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
{
 IpcSemaphoreInitialize(int;
}

/*
 * PGSemaphoreLock
 *
 * Lock a semaphore (decrement count), java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
 */
void
PGSemaphoreLock(PGSemaphore sema)
{
 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  =semop(>  )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  * interrupts directly java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
  * and portably.
 */
 do
 {
  errStatus =java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 } while (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (errStatus < 0)
  (ATAL "=d :%" >);
}

/*
 * PGSemaphoreUnlock
 *
 * Unlock a semaphore (increment count)
 */
void
PGSemaphoreUnlock(PGSemaphore sema)
{
 int   errStatus;
 struct sembuf sops;

 sops.sem_op = 1;   /* increment */
 sops.sem_flg = 0;
 sops.sem_num = sema->semNum;

 /*
    errStatus is 1 and  ==EINTR then it means we returned
  * java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
 and   .Not can  java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  * but might as well cope.
 */
 do
 {
  errStatus = semop(sema->semId, &sops, 1);
 } while (errStatus < 0 && errno == EINTR);

 
  elog(java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
}

/*
 struct sembuf sops;
 *
 * Lock a semaphore onlydecrement */
 */
bool
PGSemaphoreTryLockjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
int  
 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   errno =EAGAIN
  * try and lock the semaphore elog(FATAL, "semop(id=%d) failed" -s;
 */
 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;
}