mirror of https://github.com/postgres/postgres
As proof of concept, provide an alternate implementation based on POSIX semaphores. Also push the SysV shared-memory implementation into a separate file so that it can be replaced conveniently.ecpg_big_bison
Tom Lane
23 years ago
parent
91fc10fdac
commit
72a3902a66
@ -0,0 +1,357 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* posix_sema.c |
||||
* Implement PGSemaphores using POSIX semaphore facilities |
||||
* |
||||
* We prefer the unnamed style of POSIX semaphore (the kind made with |
||||
* sem_init). We can cope with the kind made with sem_open, however. |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* IDENTIFICATION |
||||
* $Header: /cvsroot/pgsql/src/backend/port/posix_sema.c,v 1.1 2002/05/05 00:03:28 tgl Exp $ |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#include "postgres.h" |
||||
|
||||
#include <errno.h> |
||||
#include <signal.h> |
||||
#include <unistd.h> |
||||
|
||||
#include "storage/pg_sema.h" |
||||
|
||||
|
||||
#ifdef USE_NAMED_POSIX_SEMAPHORES |
||||
/* PGSemaphore is pointer to pointer to sem_t */ |
||||
#define PG_SEM_REF(x) (*(x)) |
||||
#else |
||||
/* PGSemaphore is pointer to sem_t */ |
||||
#define PG_SEM_REF(x) (x) |
||||
#endif |
||||
|
||||
|
||||
#define IPCProtection (0600) /* access/modify by user only */ |
||||
|
||||
static sem_t **mySemPointers; /* keep track of created semaphores */ |
||||
static int numSems; /* number of semas acquired so far */ |
||||
static int maxSems; /* allocated size of mySemaPointers array */ |
||||
static int nextSemKey; /* next name to try */ |
||||
|
||||
|
||||
static void ReleaseSemaphores(int status, Datum arg); |
||||
|
||||
|
||||
#ifdef USE_NAMED_POSIX_SEMAPHORES |
||||
|
||||
/*
|
||||
* PosixSemaphoreCreate |
||||
* |
||||
* Attempt to create a new named semaphore. |
||||
* |
||||
* If we fail with a failure code other than collision-with-existing-sema, |
||||
* print out an error and abort. Other types of errors suggest nonrecoverable |
||||
* problems. |
||||
*/ |
||||
static sem_t * |
||||
PosixSemaphoreCreate(void) |
||||
{ |
||||
int semKey; |
||||
char semname[64]; |
||||
sem_t *mySem; |
||||
|
||||
for (;;) |
||||
{ |
||||
semKey = nextSemKey++; |
||||
|
||||
snprintf(semname, sizeof(semname), "/pgsql-%d", semKey); |
||||
|
||||
mySem = sem_open(semname, O_CREAT | O_EXCL, |
||||
(mode_t) IPCProtection, (unsigned) 1); |
||||
if (mySem != SEM_FAILED) |
||||
break; |
||||
|
||||
/* Loop if error indicates a collision */ |
||||
if (errno == EEXIST || errno == EACCES || errno == EINTR) |
||||
continue; |
||||
|
||||
/*
|
||||
* Else complain and abort |
||||
*/ |
||||
fprintf(stderr, "PosixSemaphoreCreate: sem_open(%s) failed: %s\n", |
||||
semname, strerror(errno)); |
||||
proc_exit(1); |
||||
} |
||||
|
||||
/*
|
||||
* Unlink the semaphore immediately, so it can't be accessed externally. |
||||
* This also ensures that it will go away if we crash. |
||||
*/ |
||||
sem_unlink(semname); |
||||
|
||||
return mySem; |
||||
} |
||||
|
||||
#else /* !USE_NAMED_POSIX_SEMAPHORES */ |
||||
|
||||
/*
|
||||
* PosixSemaphoreCreate |
||||
* |
||||
* Attempt to create a new unnamed semaphore. |
||||
*/ |
||||
static void |
||||
PosixSemaphoreCreate(sem_t *sem) |
||||
{ |
||||
if (sem_init(sem, 1, 1) < 0) |
||||
{ |
||||
fprintf(stderr, "PosixSemaphoreCreate: sem_init failed: %s\n", |
||||
strerror(errno)); |
||||
proc_exit(1); |
||||
} |
||||
} |
||||
|
||||
#endif /* USE_NAMED_POSIX_SEMAPHORES */ |
||||
|
||||
|
||||
/*
|
||||
* PosixSemaphoreKill - removes a semaphore |
||||
*/ |
||||
static void |
||||
PosixSemaphoreKill(sem_t *sem) |
||||
{ |
||||
#ifdef USE_NAMED_POSIX_SEMAPHORES |
||||
/* Got to use sem_close for named semaphores */ |
||||
if (sem_close(sem) < 0) |
||||
fprintf(stderr, "PosixSemaphoreKill: sem_close failed: %s\n", |
||||
strerror(errno)); |
||||
#else |
||||
/* Got to use sem_destroy for unnamed semaphores */ |
||||
if (sem_destroy(sem) < 0) |
||||
fprintf(stderr, "PosixSemaphoreKill: sem_destroy failed: %s\n", |
||||
strerror(errno)); |
||||
#endif |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* 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. |
||||
* |
||||
* The port number is passed for possible use as a key (for Posix, we use |
||||
* it to generate the starting semaphore name). In a standalone backend, |
||||
* zero will be passed. |
||||
* |
||||
* In the Posix implementation, we acquire semaphores on-demand; the |
||||
* maxSemas parameter is just used to size the array that keeps track of |
||||
* acquired semas for subsequent releasing. |
||||
*/ |
||||
void |
||||
PGReserveSemaphores(int maxSemas, int port) |
||||
{ |
||||
mySemPointers = (sem_t **) malloc(maxSemas * sizeof(sem_t *)); |
||||
if (mySemPointers == NULL) |
||||
elog(PANIC, "Out of memory in PGReserveSemaphores"); |
||||
numSems = 0; |
||||
maxSems = maxSemas; |
||||
nextSemKey = port * 1000; |
||||
|
||||
on_shmem_exit(ReleaseSemaphores, 0); |
||||
} |
||||
|
||||
/*
|
||||
* Release semaphores at shutdown or shmem reinitialization |
||||
* |
||||
* (called as an on_shmem_exit callback, hence funny argument list) |
||||
*/ |
||||
static void |
||||
ReleaseSemaphores(int status, Datum arg) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < numSems; i++) |
||||
PosixSemaphoreKill(mySemPointers[i]); |
||||
free(mySemPointers); |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreCreate |
||||
* |
||||
* Initialize a PGSemaphore structure to represent a sema with count 1 |
||||
*/ |
||||
void |
||||
PGSemaphoreCreate(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, "PGSemaphoreCreate: too many semaphores created"); |
||||
|
||||
#ifdef USE_NAMED_POSIX_SEMAPHORES |
||||
*sema = newsem = PosixSemaphoreCreate(); |
||||
#else |
||||
PosixSemaphoreCreate(sema); |
||||
newsem = sema; |
||||
#endif |
||||
|
||||
/* Remember new sema for ReleaseSemaphores */ |
||||
mySemPointers[numSems++] = newsem; |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreReset |
||||
* |
||||
* Reset a previously-initialized PGSemaphore to have count 0 |
||||
*/ |
||||
void |
||||
PGSemaphoreReset(PGSemaphore sema) |
||||
{ |
||||
/*
|
||||
* 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? */ |
||||
fprintf(stderr, "PGSemaphoreReset: sem_trywait failed: %s\n", |
||||
strerror(errno)); |
||||
proc_exit(1); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreLock |
||||
* |
||||
* Lock a semaphore (decrement count), blocking if count would be < 0 |
||||
*/ |
||||
void |
||||
PGSemaphoreLock(PGSemaphore sema, bool interruptOK) |
||||
{ |
||||
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. |
||||
* |
||||
* Each time around the loop, we check for a cancel/die interrupt. We |
||||
* assume that if such an interrupt comes in while we are waiting, it |
||||
* will cause the sem_wait() call to exit with errno == EINTR, so that we |
||||
* will be able to service the interrupt (if not in a critical section |
||||
* already). |
||||
* |
||||
* Once we acquire the lock, we do NOT check for an interrupt before |
||||
* returning. The caller needs to be able to record ownership of the |
||||
* lock before any interrupt can be accepted. |
||||
* |
||||
* There is a window of a few instructions between CHECK_FOR_INTERRUPTS |
||||
* and entering the sem_wait() call. If a cancel/die interrupt occurs in |
||||
* that window, we would fail to notice it until after we acquire the |
||||
* lock (or get another interrupt to escape the sem_wait()). We can |
||||
* avoid this problem by temporarily setting ImmediateInterruptOK to |
||||
* true before we do CHECK_FOR_INTERRUPTS; then, a die() interrupt in |
||||
* this interval will execute directly. However, there is a huge |
||||
* pitfall: there is another window of a few instructions after the |
||||
* sem_wait() before we are able to reset ImmediateInterruptOK. If an |
||||
* interrupt occurs then, we'll lose control, which means that the |
||||
* lock has been acquired but our caller did not get a chance to |
||||
* record the fact. Therefore, we only set ImmediateInterruptOK if the |
||||
* caller tells us it's OK to do so, ie, the caller does not need to |
||||
* record acquiring the lock. (This is currently true for lockmanager |
||||
* locks, since the process that granted us the lock did all the |
||||
* necessary state updates. It's not true for Posix semaphores used to |
||||
* implement LW locks or emulate spinlocks --- but the wait time for |
||||
* such locks should not be very long, anyway.) |
||||
*/ |
||||
do |
||||
{ |
||||
ImmediateInterruptOK = interruptOK; |
||||
CHECK_FOR_INTERRUPTS(); |
||||
errStatus = sem_wait(PG_SEM_REF(sema)); |
||||
ImmediateInterruptOK = false; |
||||
} while (errStatus < 0 && errno == EINTR); |
||||
|
||||
if (errStatus < 0) |
||||
{ |
||||
fprintf(stderr, "PGSemaphoreLock: sem_wait failed: %s\n", |
||||
strerror(errno)); |
||||
proc_exit(255); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreUnlock |
||||
* |
||||
* Unlock a semaphore (increment count) |
||||
*/ |
||||
void |
||||
PGSemaphoreUnlock(PGSemaphore sema) |
||||
{ |
||||
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) |
||||
{ |
||||
fprintf(stderr, "PGSemaphoreUnlock: sem_post failed: %s\n", |
||||
strerror(errno)); |
||||
proc_exit(255); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreTryLock |
||||
* |
||||
* Lock a semaphore only if able to do so without blocking |
||||
*/ |
||||
bool |
||||
PGSemaphoreTryLock(PGSemaphore sema) |
||||
{ |
||||
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 */ |
||||
fprintf(stderr, "PGSemaphoreTryLock: sem_trywait failed: %s\n", |
||||
strerror(errno)); |
||||
proc_exit(255); |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
@ -0,0 +1,522 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* sysv_sema.c |
||||
* Implement PGSemaphores using SysV semaphore facilities |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* IDENTIFICATION |
||||
* $Header: /cvsroot/pgsql/src/backend/port/sysv_sema.c,v 1.1 2002/05/05 00:03:28 tgl Exp $ |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#include "postgres.h" |
||||
|
||||
#include <errno.h> |
||||
#include <signal.h> |
||||
#include <unistd.h> |
||||
#include <sys/file.h> |
||||
#include <sys/types.h> |
||||
#ifdef HAVE_SYS_IPC_H |
||||
#include <sys/ipc.h> |
||||
#endif |
||||
#ifdef HAVE_SYS_SEM_H |
||||
#include <sys/sem.h> |
||||
#endif |
||||
#ifdef HAVE_KERNEL_OS_H |
||||
#include <kernel/OS.h> |
||||
#endif |
||||
|
||||
#include "miscadmin.h" |
||||
#include "storage/ipc.h" |
||||
#include "storage/pg_sema.h" |
||||
|
||||
|
||||
#ifndef HAVE_UNION_SEMUN |
||||
union semun |
||||
{ |
||||
int val; |
||||
struct semid_ds *buf; |
||||
unsigned short *array; |
||||
}; |
||||
#endif |
||||
|
||||
typedef uint32 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 25. (Less than, because we |
||||
* allocate one extra sema in each set for identification purposes.) |
||||
*/ |
||||
#define SEMAS_PER_SET 16 |
||||
|
||||
#define IPCProtection (0600) /* access/modify by user only */ |
||||
|
||||
#define PGSemaMagic 537 /* must be less than SEMVMX */ |
||||
|
||||
|
||||
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 numSems); |
||||
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); |
||||
|
||||
|
||||
/*
|
||||
* InternalIpcSemaphoreCreate |
||||
* |
||||
* 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. |
||||
*/ |
||||
static IpcSemaphoreId |
||||
InternalIpcSemaphoreCreate(IpcSemaphoreKey semKey, int numSems) |
||||
{ |
||||
int semId; |
||||
|
||||
semId = semget(semKey, numSems, IPC_CREAT | IPC_EXCL | IPCProtection); |
||||
|
||||
if (semId < 0) |
||||
{ |
||||
/*
|
||||
* Fail quietly if error indicates a collision with existing set. |
||||
* One would expect EEXIST, given that we said IPC_EXCL, but |
||||
* perhaps we could get a permission violation instead? Also, |
||||
* EIDRM might occur if an old set is slated for destruction but |
||||
* not gone yet. |
||||
*/ |
||||
if (errno == EEXIST || errno == EACCES |
||||
#ifdef EIDRM |
||||
|| errno == EIDRM |
||||
#endif |
||||
) |
||||
return -1; |
||||
|
||||
/*
|
||||
* Else complain and abort |
||||
*/ |
||||
fprintf(stderr, "IpcSemaphoreCreate: semget(key=%d, num=%d, 0%o) failed: %s\n", |
||||
(int) semKey, numSems, (IPC_CREAT | IPC_EXCL | IPCProtection), |
||||
strerror(errno)); |
||||
|
||||
if (errno == ENOSPC) |
||||
fprintf(stderr, |
||||
"\nThis error does *not* mean that you have run out of disk space.\n" |
||||
"\n" |
||||
"It occurs when either the system limit for the maximum number of\n" |
||||
"semaphore sets (SEMMNI), or the system wide maximum number of\n" |
||||
"semaphores (SEMMNS), would be exceeded. You need to raise the\n" |
||||
"respective kernel parameter. Alternatively, reduce PostgreSQL's\n" |
||||
"consumption of semaphores by reducing its max_connections parameter\n" |
||||
"(currently %d).\n" |
||||
"\n" |
||||
"The PostgreSQL Administrator's Guide contains more information about\n" |
||||
"configuring your system for PostgreSQL.\n\n", |
||||
MaxBackends); |
||||
|
||||
proc_exit(1); |
||||
} |
||||
|
||||
return semId; |
||||
} |
||||
|
||||
/*
|
||||
* Initialize a semaphore to the specified value. |
||||
*/ |
||||
static void |
||||
IpcSemaphoreInitialize(IpcSemaphoreId semId, int semNum, int value) |
||||
{ |
||||
union semun semun; |
||||
|
||||
semun.val = value; |
||||
if (semctl(semId, semNum, SETVAL, semun) < 0) |
||||
{ |
||||
fprintf(stderr, "IpcSemaphoreInitialize: semctl(id=%d, %d, SETVAL, %d) failed: %s\n", |
||||
semId, semNum, value, strerror(errno)); |
||||
|
||||
if (errno == ERANGE) |
||||
fprintf(stderr, |
||||
"You possibly need to raise your kernel's SEMVMX value to be at least\n" |
||||
"%d. Look into the PostgreSQL documentation for details.\n", |
||||
value); |
||||
|
||||
proc_exit(1); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* IpcSemaphoreKill(semId) - removes a semaphore set |
||||
*/ |
||||
static void |
||||
IpcSemaphoreKill(IpcSemaphoreId semId) |
||||
{ |
||||
union semun semun; |
||||
|
||||
semun.val = 0; /* unused, but keep compiler quiet */ |
||||
|
||||
if (semctl(semId, 0, IPC_RMID, semun) < 0) |
||||
fprintf(stderr, "IpcSemaphoreKill: semctl(%d, 0, IPC_RMID, ...) failed: %s\n", |
||||
semId, strerror(errno)); |
||||
|
||||
/*
|
||||
* We used to report a failure via elog(WARNING), but that's pretty |
||||
* pointless considering any client has long since disconnected ... |
||||
*/ |
||||
} |
||||
|
||||
/* Get the current value (semval) of the semaphore */ |
||||
static int |
||||
IpcSemaphoreGetValue(IpcSemaphoreId semId, int semNum) |
||||
{ |
||||
union semun dummy; /* for Solaris */ |
||||
|
||||
dummy.val = 0; /* unused */ |
||||
|
||||
return semctl(semId, semNum, GETVAL, dummy); |
||||
} |
||||
|
||||
/* Get the PID of the last process to do semop() on the semaphore */ |
||||
static pid_t |
||||
IpcSemaphoreGetLastPID(IpcSemaphoreId semId, int semNum) |
||||
{ |
||||
union semun dummy; /* for Solaris */ |
||||
|
||||
dummy.val = 0; /* unused */ |
||||
|
||||
return semctl(semId, semNum, GETPID, dummy); |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Create a semaphore set with the given number of useful semaphores |
||||
* (an additional sema is actually allocated to serve as identifier). |
||||
* 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) |
||||
{ |
||||
IpcSemaphoreId semId; |
||||
union semun semun; |
||||
PGSemaphoreData mysema; |
||||
|
||||
/* Loop till we find a free IPC key */ |
||||
for (nextSemaKey++; ; nextSemaKey++) |
||||
{ |
||||
pid_t creatorPID; |
||||
|
||||
/* Try to create new semaphore set */ |
||||
semId = InternalIpcSemaphoreCreate(nextSemaKey, numSems + 1); |
||||
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); |
||||
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; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* 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. |
||||
* |
||||
* The port number is passed for possible use as a key (for SysV, we use |
||||
* it to generate the starting semaphore key). In a standalone backend, |
||||
* zero will be passed. |
||||
* |
||||
* In the SysV implementation, we acquire semaphore sets on-demand; the |
||||
* maxSemas parameter is just used to size the array that keeps track of |
||||
* acquired sets for subsequent releasing. |
||||
*/ |
||||
void |
||||
PGReserveSemaphores(int maxSemas, int port) |
||||
{ |
||||
maxSemaSets = (maxSemas + SEMAS_PER_SET-1) / SEMAS_PER_SET; |
||||
mySemaSets = (IpcSemaphoreId *) |
||||
malloc(maxSemaSets * sizeof(IpcSemaphoreId)); |
||||
if (mySemaSets == NULL) |
||||
elog(PANIC, "Out of memory in PGReserveSemaphores"); |
||||
numSemaSets = 0; |
||||
nextSemaKey = port * 1000; |
||||
nextSemaNumber = SEMAS_PER_SET; /* force sema set alloc on 1st call */ |
||||
|
||||
on_shmem_exit(ReleaseSemaphores, 0); |
||||
} |
||||
|
||||
/*
|
||||
* Release semaphores at shutdown or shmem reinitialization |
||||
* |
||||
* (called as an on_shmem_exit callback, hence funny argument list) |
||||
*/ |
||||
static void |
||||
ReleaseSemaphores(int status, Datum arg) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < numSemaSets; i++) |
||||
IpcSemaphoreKill(mySemaSets[i]); |
||||
free(mySemaSets); |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreCreate |
||||
* |
||||
* Initialize a PGSemaphore structure to represent a sema with count 1 |
||||
*/ |
||||
void |
||||
PGSemaphoreCreate(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, "PGSemaphoreCreate: too many semaphores created"); |
||||
mySemaSets[numSemaSets] = IpcSemaphoreCreate(SEMAS_PER_SET); |
||||
numSemaSets++; |
||||
nextSemaNumber = 0; |
||||
} |
||||
/* 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); |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreReset |
||||
* |
||||
* Reset a previously-initialized PGSemaphore to have count 0 |
||||
*/ |
||||
void |
||||
PGSemaphoreReset(PGSemaphore sema) |
||||
{ |
||||
IpcSemaphoreInitialize(sema->semId, sema->semNum, 0); |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreLock |
||||
* |
||||
* Lock a semaphore (decrement count), blocking if count would be < 0 |
||||
*/ |
||||
void |
||||
PGSemaphoreLock(PGSemaphore sema, bool interruptOK) |
||||
{ |
||||
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. |
||||
* |
||||
* Each time around the loop, we check for a cancel/die interrupt. We |
||||
* assume that if such an interrupt comes in while we are waiting, it |
||||
* will cause the semop() call to exit with errno == EINTR, so that we |
||||
* will be able to service the interrupt (if not in a critical section |
||||
* already). |
||||
* |
||||
* Once we acquire the lock, we do NOT check for an interrupt before |
||||
* returning. The caller needs to be able to record ownership of the |
||||
* lock before any interrupt can be accepted. |
||||
* |
||||
* There is a window of a few instructions between CHECK_FOR_INTERRUPTS |
||||
* and entering the semop() call. If a cancel/die interrupt occurs in |
||||
* that window, we would fail to notice it until after we acquire the |
||||
* lock (or get another interrupt to escape the semop()). We can |
||||
* avoid this problem by temporarily setting ImmediateInterruptOK to |
||||
* true before we do CHECK_FOR_INTERRUPTS; then, a die() interrupt in |
||||
* this interval will execute directly. However, there is a huge |
||||
* pitfall: there is another window of a few instructions after the |
||||
* semop() before we are able to reset ImmediateInterruptOK. If an |
||||
* interrupt occurs then, we'll lose control, which means that the |
||||
* lock has been acquired but our caller did not get a chance to |
||||
* record the fact. Therefore, we only set ImmediateInterruptOK if the |
||||
* caller tells us it's OK to do so, ie, the caller does not need to |
||||
* record acquiring the lock. (This is currently true for lockmanager |
||||
* locks, since the process that granted us the lock did all the |
||||
* necessary state updates. It's not true for SysV semaphores used to |
||||
* implement LW locks or emulate spinlocks --- but the wait time for |
||||
* such locks should not be very long, anyway.) |
||||
*/ |
||||
do |
||||
{ |
||||
ImmediateInterruptOK = interruptOK; |
||||
CHECK_FOR_INTERRUPTS(); |
||||
errStatus = semop(sema->semId, &sops, 1); |
||||
ImmediateInterruptOK = false; |
||||
} while (errStatus < 0 && errno == EINTR); |
||||
|
||||
if (errStatus < 0) |
||||
{ |
||||
fprintf(stderr, "PGSemaphoreLock: semop(id=%d) failed: %s\n", |
||||
sema->semId, strerror(errno)); |
||||
proc_exit(255); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* 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; |
||||
|
||||
/*
|
||||
* 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) |
||||
{ |
||||
fprintf(stderr, "PGSemaphoreUnlock: semop(id=%d) failed: %s\n", |
||||
sema->semId, strerror(errno)); |
||||
proc_exit(255); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* PGSemaphoreTryLock |
||||
* |
||||
* Lock a semaphore only if able to do so without blocking |
||||
*/ |
||||
bool |
||||
PGSemaphoreTryLock(PGSemaphore sema) |
||||
{ |
||||
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 */ |
||||
fprintf(stderr, "PGSemaphoreTryLock: semop(id=%d) failed: %s\n", |
||||
sema->semId, strerror(errno)); |
||||
proc_exit(255); |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
@ -0,0 +1,400 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* sysv_shmem.c |
||||
* Implement shared memory using SysV facilities |
||||
* |
||||
* These routines represent a fairly thin layer on top of SysV shared |
||||
* memory functionality. |
||||
* |
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* IDENTIFICATION |
||||
* $Header: /cvsroot/pgsql/src/backend/port/sysv_shmem.c,v 1.1 2002/05/05 00:03:28 tgl Exp $ |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#include "postgres.h" |
||||
|
||||
#include <errno.h> |
||||
#include <signal.h> |
||||
#include <unistd.h> |
||||
#include <sys/file.h> |
||||
#include <sys/types.h> |
||||
#ifdef HAVE_SYS_IPC_H |
||||
#include <sys/ipc.h> |
||||
#endif |
||||
#ifdef HAVE_SYS_SHM_H |
||||
#include <sys/shm.h> |
||||
#endif |
||||
#ifdef HAVE_KERNEL_OS_H |
||||
#include <kernel/OS.h> |
||||
#endif |
||||
|
||||
#include "miscadmin.h" |
||||
#include "storage/ipc.h" |
||||
#include "storage/pg_shmem.h" |
||||
|
||||
|
||||
typedef uint32 IpcMemoryKey; /* shared memory key passed to shmget(2) */ |
||||
typedef int IpcMemoryId; /* shared memory ID returned by shmget(2) */ |
||||
|
||||
#define IPCProtection (0600) /* access/modify by user only */ |
||||
|
||||
|
||||
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, uint32 size); |
||||
static void IpcMemoryDetach(int status, Datum shmaddr); |
||||
static void IpcMemoryDelete(int status, Datum shmId); |
||||
static void *PrivateMemoryCreate(uint32 size); |
||||
static void PrivateMemoryDelete(int status, Datum memaddr); |
||||
|
||||
|
||||
/*
|
||||
* InternalIpcMemoryCreate(memKey, size) |
||||
* |
||||
* Attempt to create a new shared memory segment with the specified key. |
||||
* Will fail (return NULL) if such a segment already exists. If successful, |
||||
* attach the segment to the current process and return its attached address. |
||||
* On success, callbacks are registered with on_shmem_exit to detach and |
||||
* delete the segment when on_shmem_exit is called. |
||||
* |
||||
* If we fail with a failure code other than collision-with-existing-segment, |
||||
* print out an error and abort. Other types of errors are not recoverable. |
||||
*/ |
||||
static void * |
||||
InternalIpcMemoryCreate(IpcMemoryKey memKey, uint32 size) |
||||
{ |
||||
IpcMemoryId shmid; |
||||
void *memAddress; |
||||
|
||||
shmid = shmget(memKey, size, IPC_CREAT | IPC_EXCL | IPCProtection); |
||||
|
||||
if (shmid < 0) |
||||
{ |
||||
/*
|
||||
* Fail quietly if error indicates a collision with existing |
||||
* segment. One would expect EEXIST, given that we said IPC_EXCL, |
||||
* but perhaps we could get a permission violation instead? Also, |
||||
* EIDRM might occur if an old seg is slated for destruction but |
||||
* not gone yet. |
||||
*/ |
||||
if (errno == EEXIST || errno == EACCES |
||||
#ifdef EIDRM |
||||
|| errno == EIDRM |
||||
#endif |
||||
) |
||||
return NULL; |
||||
|
||||
/*
|
||||
* Else complain and abort |
||||
*/ |
||||
fprintf(stderr, "IpcMemoryCreate: shmget(key=%d, size=%u, 0%o) failed: %s\n", |
||||
(int) memKey, size, (IPC_CREAT | IPC_EXCL | IPCProtection), |
||||
strerror(errno)); |
||||
|
||||
if (errno == EINVAL) |
||||
fprintf(stderr, |
||||
"\nThis error usually means that PostgreSQL's request for a shared memory\n" |
||||
"segment exceeded your kernel's SHMMAX parameter. You can either\n" |
||||
"reduce the request size or reconfigure the kernel with larger SHMMAX.\n" |
||||
"To reduce the request size (currently %u bytes), reduce\n" |
||||
"PostgreSQL's shared_buffers parameter (currently %d) and/or\n" |
||||
"its max_connections parameter (currently %d).\n" |
||||
"\n" |
||||
"If the request size is already small, it's possible that it is less than\n" |
||||
"your kernel's SHMMIN parameter, in which case raising the request size or\n" |
||||
"reconfiguring SHMMIN is called for.\n" |
||||
"\n" |
||||
"The PostgreSQL Administrator's Guide contains more information about\n" |
||||
"shared memory configuration.\n\n", |
||||
size, NBuffers, MaxBackends); |
||||
|
||||
else if (errno == ENOMEM) |
||||
fprintf(stderr, |
||||
"\nThis error usually means that PostgreSQL's request for a shared\n" |
||||
"memory segment exceeded available memory or swap space.\n" |
||||
"To reduce the request size (currently %u bytes), reduce\n" |
||||
"PostgreSQL's shared_buffers parameter (currently %d) and/or\n" |
||||
"its max_connections parameter (currently %d).\n" |
||||
"\n" |
||||
"The PostgreSQL Administrator's Guide contains more information about\n" |
||||
"shared memory configuration.\n\n", |
||||
size, NBuffers, MaxBackends); |
||||
|
||||
else if (errno == ENOSPC) |
||||
fprintf(stderr, |
||||
"\nThis error does *not* mean that you have run out of disk space.\n" |
||||
"\n" |
||||
"It occurs either if all available shared memory IDs have been taken,\n" |
||||
"in which case you need to raise the SHMMNI parameter in your kernel,\n" |
||||
"or because the system's overall limit for shared memory has been\n" |
||||
"reached. If you cannot increase the shared memory limit,\n" |
||||
"reduce PostgreSQL's shared memory request (currently %u bytes),\n" |
||||
"by reducing its shared_buffers parameter (currently %d) and/or\n" |
||||
"its max_connections parameter (currently %d).\n" |
||||
"\n" |
||||
"The PostgreSQL Administrator's Guide contains more information about\n" |
||||
"shared memory configuration.\n\n", |
||||
size, NBuffers, MaxBackends); |
||||
|
||||
proc_exit(1); |
||||
} |
||||
|
||||
/* Register on-exit routine to delete the new segment */ |
||||
on_shmem_exit(IpcMemoryDelete, Int32GetDatum(shmid)); |
||||
|
||||
/* OK, should be able to attach to the segment */ |
||||
#if defined(solaris) && defined(__sparc__) |
||||
/* use intimate shared memory on SPARC Solaris */ |
||||
memAddress = shmat(shmid, 0, SHM_SHARE_MMU); |
||||
#else |
||||
memAddress = shmat(shmid, 0, 0); |
||||
#endif |
||||
|
||||
if (memAddress == (void *) -1) |
||||
{ |
||||
fprintf(stderr, "IpcMemoryCreate: shmat(id=%d) failed: %s\n", |
||||
shmid, strerror(errno)); |
||||
proc_exit(1); |
||||
} |
||||
|
||||
/* Register on-exit routine to detach new segment before deleting */ |
||||
on_shmem_exit(IpcMemoryDetach, PointerGetDatum(memAddress)); |
||||
|
||||
/* Record key and ID in lockfile for data directory. */ |
||||
RecordSharedMemoryInLockFile((unsigned long) memKey, |
||||
(unsigned long) shmid); |
||||
|
||||
return memAddress; |
||||
} |
||||
|
||||
/****************************************************************************/ |
||||
/* IpcMemoryDetach(status, shmaddr) removes a shared memory segment */ |
||||
/* from process' address spaceq */ |
||||
/* (called as an on_shmem_exit callback, hence funny argument list) */ |
||||
/****************************************************************************/ |
||||
static void |
||||
IpcMemoryDetach(int status, Datum shmaddr) |
||||
{ |
||||
if (shmdt(DatumGetPointer(shmaddr)) < 0) |
||||
fprintf(stderr, "IpcMemoryDetach: shmdt(%p) failed: %s\n", |
||||
DatumGetPointer(shmaddr), strerror(errno)); |
||||
|
||||
/*
|
||||
* We used to report a failure via elog(WARNING), but that's pretty |
||||
* pointless considering any client has long since disconnected ... |
||||
*/ |
||||
} |
||||
|
||||
/****************************************************************************/ |
||||
/* IpcMemoryDelete(status, shmId) deletes a shared memory segment */ |
||||
/* (called as an on_shmem_exit callback, hence funny argument list) */ |
||||
/****************************************************************************/ |
||||
static void |
||||
IpcMemoryDelete(int status, Datum shmId) |
||||
{ |
||||
if (shmctl(DatumGetInt32(shmId), IPC_RMID, (struct shmid_ds *) NULL) < 0) |
||||
fprintf(stderr, "IpcMemoryDelete: shmctl(%d, %d, 0) failed: %s\n", |
||||
DatumGetInt32(shmId), IPC_RMID, strerror(errno)); |
||||
|
||||
/*
|
||||
* We used to report a failure via elog(WARNING), but that's pretty |
||||
* pointless considering any client has long since disconnected ... |
||||
*/ |
||||
} |
||||
|
||||
/*
|
||||
* PGSharedMemoryIsInUse |
||||
* |
||||
* Is a previously-existing shmem segment still existing and in use? |
||||
*/ |
||||
bool |
||||
PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2) |
||||
{ |
||||
IpcMemoryId shmId = (IpcMemoryId) id2; |
||||
struct shmid_ds shmStat; |
||||
|
||||
/*
|
||||
* We detect whether a shared memory segment is in use by seeing |
||||
* whether it (a) exists and (b) has any processes are attached to it. |
||||
* |
||||
* If we are unable to perform the stat operation for a reason other than |
||||
* nonexistence of the segment (most likely, because it doesn't belong |
||||
* to our userid), assume it is in use. |
||||
*/ |
||||
if (shmctl(shmId, IPC_STAT, &shmStat) < 0) |
||||
{ |
||||
/*
|
||||
* EINVAL actually has multiple possible causes documented in the |
||||
* shmctl man page, but we assume it must mean the segment no |
||||
* longer exists. |
||||
*/ |
||||
if (errno == EINVAL) |
||||
return false; |
||||
/* Else assume segment is in use */ |
||||
return true; |
||||
} |
||||
/* If it has attached processes, it's in use */ |
||||
if (shmStat.shm_nattch != 0) |
||||
return true; |
||||
return false; |
||||
} |
||||
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* private memory support |
||||
* |
||||
* Rather than allocating shmem segments with IPC_PRIVATE key, we |
||||
* just malloc() the requested amount of space. This code emulates |
||||
* the needed shmem functions. |
||||
* ---------------------------------------------------------------- |
||||
*/ |
||||
|
||||
static void * |
||||
PrivateMemoryCreate(uint32 size) |
||||
{ |
||||
void *memAddress; |
||||
|
||||
memAddress = malloc(size); |
||||
if (!memAddress) |
||||
{ |
||||
fprintf(stderr, "PrivateMemoryCreate: malloc(%u) failed\n", size); |
||||
proc_exit(1); |
||||
} |
||||
MemSet(memAddress, 0, size); /* keep Purify quiet */ |
||||
|
||||
/* Register on-exit routine to release storage */ |
||||
on_shmem_exit(PrivateMemoryDelete, PointerGetDatum(memAddress)); |
||||
|
||||
return memAddress; |
||||
} |
||||
|
||||
static void |
||||
PrivateMemoryDelete(int status, Datum memaddr) |
||||
{ |
||||
free(DatumGetPointer(memaddr)); |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* PGSharedMemoryCreate |
||||
* |
||||
* Create a shared memory segment of the given size and initialize its |
||||
* standard header. Also, register an on_shmem_exit callback to release |
||||
* the storage. |
||||
* |
||||
* Dead Postgres segments are recycled if found, but we do not fail upon |
||||
* collision with non-Postgres shmem segments. The idea here is to detect and |
||||
* re-use keys that may have been assigned by a crashed postmaster or backend. |
||||
* |
||||
* The port number is passed for possible use as a key (for SysV, we use |
||||
* it to generate the starting shmem key). In a standalone backend, |
||||
* zero will be passed. |
||||
*/ |
||||
PGShmemHeader * |
||||
PGSharedMemoryCreate(uint32 size, bool makePrivate, int port) |
||||
{ |
||||
IpcMemoryKey NextShmemSegID; |
||||
void *memAddress; |
||||
PGShmemHeader *hdr; |
||||
|
||||
/* Room for a header? */ |
||||
Assert(size > MAXALIGN(sizeof(PGShmemHeader))); |
||||
|
||||
/* Loop till we find a free IPC key */ |
||||
NextShmemSegID = port * 1000; |
||||
|
||||
for (NextShmemSegID++;; NextShmemSegID++) |
||||
{ |
||||
IpcMemoryId shmid; |
||||
|
||||
/* Special case if creating a private segment --- just malloc() it */ |
||||
if (makePrivate) |
||||
{ |
||||
memAddress = PrivateMemoryCreate(size); |
||||
break; |
||||
} |
||||
|
||||
/* Try to create new segment */ |
||||
memAddress = InternalIpcMemoryCreate(NextShmemSegID, size); |
||||
if (memAddress) |
||||
break; /* successful create and attach */ |
||||
|
||||
/* See if it looks to be leftover from a dead Postgres process */ |
||||
shmid = shmget(NextShmemSegID, sizeof(PGShmemHeader), 0); |
||||
if (shmid < 0) |
||||
continue; /* failed: must be some other app's */ |
||||
|
||||
#if defined(solaris) && defined(__sparc__) |
||||
/* use intimate shared memory on SPARC Solaris */ |
||||
memAddress = shmat(shmid, 0, SHM_SHARE_MMU); |
||||
#else |
||||
memAddress = shmat(shmid, 0, 0); |
||||
#endif |
||||
|
||||
if (memAddress == (void *) -1) |
||||
continue; /* failed: must be some other app's */ |
||||
hdr = (PGShmemHeader *) memAddress; |
||||
if (hdr->magic != PGShmemMagic) |
||||
{ |
||||
shmdt(memAddress); |
||||
continue; /* segment 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. |
||||
*/ |
||||
if (hdr->creatorPID != getpid()) |
||||
{ |
||||
if (kill(hdr->creatorPID, 0) == 0 || |
||||
errno != ESRCH) |
||||
{ |
||||
shmdt(memAddress); |
||||
continue; /* segment belongs to a live process */ |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* The segment 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 segment belongs to someone else after all, and continue |
||||
* quietly. |
||||
*/ |
||||
shmdt(memAddress); |
||||
if (shmctl(shmid, IPC_RMID, (struct shmid_ds *) NULL) < 0) |
||||
continue; |
||||
|
||||
/*
|
||||
* Now try again to create the segment. |
||||
*/ |
||||
memAddress = InternalIpcMemoryCreate(NextShmemSegID, size); |
||||
if (memAddress) |
||||
break; /* successful create and attach */ |
||||
|
||||
/*
|
||||
* Can only get here if some other process managed to create the |
||||
* same shmem key before we did. Let him have that one, loop |
||||
* around to try next key. |
||||
*/ |
||||
} |
||||
|
||||
/*
|
||||
* OK, we created a new segment. Mark it as created by this process. |
||||
* The order of assignments here is critical so that another Postgres |
||||
* process can't see the header as valid but belonging to an invalid |
||||
* PID! |
||||
*/ |
||||
hdr = (PGShmemHeader *) memAddress; |
||||
hdr->creatorPID = getpid(); |
||||
hdr->magic = PGShmemMagic; |
||||
|
||||
/*
|
||||
* Initialize space allocation status for segment. |
||||
*/ |
||||
hdr->totalsize = size; |
||||
hdr->freeoffset = MAXALIGN(sizeof(PGShmemHeader)); |
||||
|
||||
return hdr; |
||||
} |
||||
@ -0,0 +1,76 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* pg_sema.h |
||||
* Platform-independent API for semaphores. |
||||
* |
||||
* PostgreSQL requires counting semaphores (the kind that keep track of |
||||
* multiple unlock operations, and will allow an equal number of subsequent |
||||
* lock operations before blocking). The underlying implementation is |
||||
* not the same on every platform. This file defines the API that must |
||||
* be provided by each port. |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* $Id: pg_sema.h,v 1.1 2002/05/05 00:03:29 tgl Exp $ |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#ifndef PG_SEMA_H |
||||
#define PG_SEMA_H |
||||
|
||||
/*
|
||||
* PGSemaphoreData and pointer type PGSemaphore are the data structure |
||||
* representing an individual semaphore. The contents of PGSemaphoreData |
||||
* vary across implementations and must never be touched by platform- |
||||
* independent code. PGSemaphoreData structures are always allocated |
||||
* in shared memory (to support implementations where the data changes during |
||||
* lock/unlock). |
||||
* |
||||
* pg_config.h must define exactly one of the USE_xxx_SEMAPHORES symbols. |
||||
*/ |
||||
|
||||
#ifdef USE_NAMED_POSIX_SEMAPHORES |
||||
|
||||
#include <semaphore.h> |
||||
|
||||
typedef sem_t *PGSemaphoreData; |
||||
|
||||
#endif |
||||
|
||||
#ifdef USE_UNNAMED_POSIX_SEMAPHORES |
||||
|
||||
#include <semaphore.h> |
||||
|
||||
typedef sem_t PGSemaphoreData; |
||||
|
||||
#endif |
||||
|
||||
#ifdef USE_SYSV_SEMAPHORES |
||||
|
||||
typedef struct PGSemaphoreData |
||||
{ |
||||
int semId; /* semaphore set identifier */ |
||||
int semNum; /* semaphore number within set */ |
||||
} PGSemaphoreData; |
||||
|
||||
#endif |
||||
|
||||
typedef PGSemaphoreData *PGSemaphore; |
||||
|
||||
|
||||
/* Module initialization (called during postmaster start or shmem reinit) */ |
||||
extern void PGReserveSemaphores(int maxSemas, int port); |
||||
/* Initialize a PGSemaphore structure to represent a sema with count 1 */ |
||||
extern void PGSemaphoreCreate(PGSemaphore sema); |
||||
/* Reset a previously-initialized PGSemaphore to have count 0 */ |
||||
extern void PGSemaphoreReset(PGSemaphore sema); |
||||
/* Lock a semaphore (decrement count), blocking if count would be < 0 */ |
||||
extern void PGSemaphoreLock(PGSemaphore sema, bool interruptOK); |
||||
/* Unlock a semaphore (increment count) */ |
||||
extern void PGSemaphoreUnlock(PGSemaphore sema); |
||||
/* Lock a semaphore only if able to do so without blocking */ |
||||
extern bool PGSemaphoreTryLock(PGSemaphore sema); |
||||
|
||||
#endif /* PG_SEMA_H */ |
||||
@ -0,0 +1,44 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* pg_shmem.h |
||||
* Platform-independent API for shared memory support. |
||||
* |
||||
* Every port is expected to support shared memory with approximately |
||||
* SysV-ish semantics; in particular, a memory block is not anonymous |
||||
* but has an ID, and we must be able to tell whether there are any |
||||
* remaining processes attached to a block of a specified ID. |
||||
* |
||||
* To simplify life for the SysV implementation, the ID is assumed to |
||||
* consist of two unsigned long values (these are key and ID in SysV |
||||
* terms). Other platforms may ignore the second value if they need |
||||
* only one ID number. |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* $Id: pg_shmem.h,v 1.1 2002/05/05 00:03:29 tgl Exp $ |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#ifndef PG_SHMEM_H |
||||
#define PG_SHMEM_H |
||||
|
||||
#include <sys/types.h> |
||||
|
||||
|
||||
typedef struct PGShmemHeader /* standard header for all Postgres shmem */ |
||||
{ |
||||
int32 magic; /* magic # to identify Postgres segments */ |
||||
#define PGShmemMagic 679834892 |
||||
pid_t creatorPID; /* PID of creating process */ |
||||
uint32 totalsize; /* total size of segment */ |
||||
uint32 freeoffset; /* offset to first free space */ |
||||
} PGShmemHeader; |
||||
|
||||
|
||||
extern PGShmemHeader *PGSharedMemoryCreate(uint32 size, bool makePrivate, |
||||
int port); |
||||
extern bool PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2); |
||||
|
||||
#endif /* PG_SHMEM_H */ |
||||
@ -1,3 +1,6 @@ |
||||
# -traditional-cpp means "don't use apple's cpp-precomp" on darwin |
||||
# this should change to -no-cpp-precomp when that flag is implemented |
||||
CC="$CC -traditional-cpp" |
||||
|
||||
# Select appropriate semaphore support |
||||
USE_NAMED_POSIX_SEMAPHORES=1 |
||||
|
||||
Loading…
Reference in new issue