Rename BindingTable to ShmemIndex.
This commit is contained in:
Bruce Momjian
parent
7487a82667
commit
54aabaa800
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.17 1998/01/07 21:04:46 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.18 1998/06/27 15:47:43 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -277,14 +277,14 @@ BufferShmemSize()
|
|||
nbuckets = 1 << (int) my_log2((NBuffers - 1) / DEF_FFACTOR + 1);
|
||||
nsegs = 1 << (int) my_log2((nbuckets - 1) / DEF_SEGSIZE + 1);
|
||||
|
||||
/* size of shmem binding table */
|
||||
size += MAXALIGN(my_log2(BTABLE_SIZE) * sizeof(void *)); /* HTAB->dir */
|
||||
/* size of shmem index table */
|
||||
size += MAXALIGN(my_log2(SHMEM_INDEX_SIZE) * sizeof(void *)); /* HTAB->dir */
|
||||
size += MAXALIGN(sizeof(HHDR)); /* HTAB->hctl */
|
||||
size += MAXALIGN(DEF_SEGSIZE * sizeof(SEGMENT));
|
||||
size += BUCKET_ALLOC_INCR *
|
||||
(MAXALIGN(sizeof(BUCKET_INDEX)) +
|
||||
MAXALIGN(BTABLE_KEYSIZE) +
|
||||
MAXALIGN(BTABLE_DATASIZE));
|
||||
MAXALIGN(SHMEM_INDEX_KEYSIZE) +
|
||||
MAXALIGN(SHMEM_INDEX_DATASIZE));
|
||||
|
||||
/* size of buffer descriptors */
|
||||
size += MAXALIGN((NBuffers + 1) * sizeof(BufferDesc));
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.14 1998/06/27 04:53:35 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.15 1998/06/27 15:47:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -83,7 +83,7 @@ CreateSharedMemoryAndSemaphores(IPCKey key)
|
|||
IPCKeyGetBufferMemoryKey(key), size);
|
||||
}
|
||||
ShmemCreate(IPCKeyGetBufferMemoryKey(key), size);
|
||||
ShmemBindingTableReset();
|
||||
ShmemIndexReset();
|
||||
InitShmem(key, size);
|
||||
InitBufferPool(key);
|
||||
|
||||
|
|
|
|||
|
|
@ -7,14 +7,14 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.24 1998/06/27 14:06:41 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.25 1998/06/27 15:47:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
/*
|
||||
* POSTGRES processes share one or more regions of shared memory.
|
||||
* The shared memory is created by a postmaster and is "attached to"
|
||||
* by each of the backends. The routines in this file are used for
|
||||
* The shared memory is created by a postmaster and is inherited
|
||||
* by each backends via fork(). The routines in this file are used for
|
||||
* allocating and binding to shared memory data structures.
|
||||
*
|
||||
* NOTES:
|
||||
|
|
@ -30,16 +30,16 @@
|
|||
* it (assigned in the module that declares it).
|
||||
*
|
||||
* (b) During initialization, each module looks for its
|
||||
* shared data structures in a hash table called the "Binding Table".
|
||||
* shared data structures in a hash table called the "Shmem Index".
|
||||
* If the data structure is not present, the caller can allocate
|
||||
* a new one and initialize it. If the data structure is present,
|
||||
* the caller "attaches" to the structure by initializing a pointer
|
||||
* in the local address space.
|
||||
* The binding table has two purposes: first, it gives us
|
||||
* The shmem index has two purposes: first, it gives us
|
||||
* a simple model of how the world looks when a backend process
|
||||
* initializes. If something is present in the binding table,
|
||||
* initializes. If something is present in the shmem index,
|
||||
* it is initialized. If it is not, it is uninitialized. Second,
|
||||
* the binding table allows us to allocate shared memory on demand
|
||||
* the shmem index allows us to allocate shared memory on demand
|
||||
* instead of trying to preallocate structures and hard-wire the
|
||||
* sizes and locations in header files. If you are using a lot
|
||||
* of shared memory in a lot of different places (and changing
|
||||
|
|
@ -54,7 +54,7 @@
|
|||
* unnecessary.
|
||||
*
|
||||
* See InitSem() in sem.c for an example of how to use the
|
||||
* binding table.
|
||||
* shmem index.
|
||||
*
|
||||
*/
|
||||
#include <stdio.h>
|
||||
|
|
@ -76,28 +76,28 @@ static unsigned long ShmemSize = 0; /* current size (and default) */
|
|||
|
||||
SPINLOCK ShmemLock; /* lock for shared memory allocation */
|
||||
|
||||
SPINLOCK BindingLock; /* lock for binding table access */
|
||||
SPINLOCK ShmemIndexLock; /* lock for shmem index access */
|
||||
|
||||
static unsigned long *ShmemFreeStart = NULL; /* pointer to the OFFSET
|
||||
* of first free shared
|
||||
* memory */
|
||||
static unsigned long *ShmemBindingTableOffset = NULL; /* start of the binding
|
||||
static unsigned long *ShmemIndexOffset = NULL; /* start of the shmem index
|
||||
* table (for bootstrap) */
|
||||
static int ShmemBootstrap = FALSE; /* flag becomes true when shared
|
||||
* mem is created by POSTMASTER */
|
||||
|
||||
static HTAB *BindingTable = NULL;
|
||||
static HTAB *ShmemIndex = NULL;
|
||||
|
||||
/* ---------------------
|
||||
* ShmemBindingTableReset() - Resets the binding table to NULL....
|
||||
* ShmemIndexReset() - Resets the shmem index to NULL....
|
||||
* useful when the postmaster destroys existing shared memory
|
||||
* and creates all new segments after a backend crash.
|
||||
* ----------------------
|
||||
*/
|
||||
void
|
||||
ShmemBindingTableReset(void)
|
||||
ShmemIndexReset(void)
|
||||
{
|
||||
BindingTable = (HTAB *) NULL;
|
||||
ShmemIndex = (HTAB *) NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -147,7 +147,7 @@ InitShmem(unsigned int key, unsigned int size)
|
|||
|
||||
HASHCTL info;
|
||||
int hash_flags;
|
||||
BindingEnt *result,
|
||||
ShmemIndexEnt *result,
|
||||
item;
|
||||
bool found;
|
||||
IpcMemoryId shmid;
|
||||
|
|
@ -178,15 +178,15 @@ InitShmem(unsigned int key, unsigned int size)
|
|||
|
||||
/* First long in shared memory is the count of available space */
|
||||
ShmemFreeStart = (unsigned long *) ShmemBase;
|
||||
/* next is a shmem pointer to the binding table */
|
||||
ShmemBindingTableOffset = ShmemFreeStart + 1;
|
||||
/* next is a shmem pointer to the shmem index */
|
||||
ShmemIndexOffset = ShmemFreeStart + 1;
|
||||
|
||||
currFreeSpace +=
|
||||
sizeof(ShmemFreeStart) + sizeof(ShmemBindingTableOffset);
|
||||
sizeof(ShmemFreeStart) + sizeof(ShmemIndexOffset);
|
||||
|
||||
/*
|
||||
* bootstrap initialize spin locks so we can start to use the
|
||||
* allocator and binding table.
|
||||
* allocator and shmem index.
|
||||
*/
|
||||
if (!InitSpinLocks(ShmemBootstrap, IPCKeyGetSpinLockSemaphoreKey(key)))
|
||||
return (FALSE);
|
||||
|
|
@ -201,37 +201,37 @@ InitShmem(unsigned int key, unsigned int size)
|
|||
/* if ShmemFreeStart is NULL, then the allocator won't work */
|
||||
Assert(*ShmemFreeStart);
|
||||
|
||||
/* create OR attach to the shared memory binding table */
|
||||
info.keysize = BTABLE_KEYSIZE;
|
||||
info.datasize = BTABLE_DATASIZE;
|
||||
/* create OR attach to the shared memory shmem index */
|
||||
info.keysize = SHMEM_INDEX_KEYSIZE;
|
||||
info.datasize = SHMEM_INDEX_DATASIZE;
|
||||
hash_flags = (HASH_ELEM);
|
||||
|
||||
/* This will acquire the binding table lock, but not release it. */
|
||||
BindingTable = ShmemInitHash("BindingTable",
|
||||
BTABLE_SIZE, BTABLE_SIZE,
|
||||
/* This will acquire the shmem index lock, but not release it. */
|
||||
ShmemIndex = ShmemInitHash("ShmemIndex",
|
||||
SHMEM_INDEX_SIZE, SHMEM_INDEX_SIZE,
|
||||
&info, hash_flags);
|
||||
|
||||
if (!BindingTable)
|
||||
if (!ShmemIndex)
|
||||
{
|
||||
elog(FATAL, "InitShmem: couldn't initialize Binding Table");
|
||||
elog(FATAL, "InitShmem: couldn't initialize Shmem Index");
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Now, check the binding table for an entry to the binding table. If
|
||||
* Now, check the shmem index for an entry to the shmem index. If
|
||||
* there is an entry there, someone else created the table. Otherwise,
|
||||
* we did and we have to initialize it.
|
||||
*/
|
||||
MemSet(item.key, 0, BTABLE_KEYSIZE);
|
||||
strncpy(item.key, "BindingTable", BTABLE_KEYSIZE);
|
||||
MemSet(item.key, 0, SHMEM_INDEX_KEYSIZE);
|
||||
strncpy(item.key, "ShmemIndex", SHMEM_INDEX_KEYSIZE);
|
||||
|
||||
result = (BindingEnt *)
|
||||
hash_search(BindingTable, (char *) &item, HASH_ENTER, &found);
|
||||
result = (ShmemIndexEnt *)
|
||||
hash_search(ShmemIndex, (char *) &item, HASH_ENTER, &found);
|
||||
|
||||
|
||||
if (!result)
|
||||
{
|
||||
elog(FATAL, "InitShmem: corrupted binding table");
|
||||
elog(FATAL, "InitShmem: corrupted shmem index");
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
|
|
@ -239,14 +239,14 @@ InitShmem(unsigned int key, unsigned int size)
|
|||
{
|
||||
|
||||
/*
|
||||
* bootstrapping shmem: we have to initialize the binding table
|
||||
* bootstrapping shmem: we have to initialize the shmem index
|
||||
* now.
|
||||
*/
|
||||
|
||||
Assert(ShmemBootstrap);
|
||||
result->location = MAKE_OFFSET(BindingTable->hctl);
|
||||
*ShmemBindingTableOffset = result->location;
|
||||
result->size = BTABLE_SIZE;
|
||||
result->location = MAKE_OFFSET(ShmemIndex->hctl);
|
||||
*ShmemIndexOffset = result->location;
|
||||
result->size = SHMEM_INDEX_SIZE;
|
||||
|
||||
ShmemBootstrap = FALSE;
|
||||
|
||||
|
|
@ -254,9 +254,9 @@ InitShmem(unsigned int key, unsigned int size)
|
|||
else
|
||||
Assert(!ShmemBootstrap);
|
||||
/* now release the lock acquired in ShmemHashInit */
|
||||
SpinRelease(BindingLock);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
|
||||
Assert(result->location == MAKE_OFFSET(BindingTable->hctl));
|
||||
Assert(result->location == MAKE_OFFSET(ShmemIndex->hctl));
|
||||
|
||||
return (TRUE);
|
||||
}
|
||||
|
|
@ -329,7 +329,7 @@ ShmemIsValid(unsigned long addr)
|
|||
* for the structure before creating the structure itself.
|
||||
*/
|
||||
HTAB *
|
||||
ShmemInitHash(char *name, /* table string name for binding */
|
||||
ShmemInitHash(char *name, /* table string name for shmem index */
|
||||
long init_size, /* initial size */
|
||||
long max_size, /* max size of the table */
|
||||
HASHCTL *infoP, /* info about key and bucket size */
|
||||
|
|
@ -348,12 +348,12 @@ ShmemInitHash(char *name, /* table string name for binding */
|
|||
infoP->max_size = max_size;
|
||||
hash_flags |= HASH_SHARED_MEM;
|
||||
|
||||
/* look it up in the binding table */
|
||||
/* look it up in the shmem index */
|
||||
location =
|
||||
ShmemInitStruct(name, my_log2(max_size) + sizeof(HHDR), &found);
|
||||
|
||||
/*
|
||||
* binding table is corrupted. Let someone else give the error
|
||||
* shmem index is corrupted. Let someone else give the error
|
||||
* message since they have more information
|
||||
*/
|
||||
if (location == NULL)
|
||||
|
|
@ -379,7 +379,7 @@ ShmemInitHash(char *name, /* table string name for binding */
|
|||
* ShmemPIDLookup -- lookup process data structure using process id
|
||||
*
|
||||
* Returns: TRUE if no error. locationPtr is initialized if PID is
|
||||
* found in the binding table.
|
||||
* found in the shmem index.
|
||||
*
|
||||
* NOTES:
|
||||
* only information about success or failure is the value of
|
||||
|
|
@ -388,23 +388,23 @@ ShmemInitHash(char *name, /* table string name for binding */
|
|||
bool
|
||||
ShmemPIDLookup(int pid, SHMEM_OFFSET *locationPtr)
|
||||
{
|
||||
BindingEnt *result,
|
||||
ShmemIndexEnt *result,
|
||||
item;
|
||||
bool found;
|
||||
|
||||
Assert(BindingTable);
|
||||
MemSet(item.key, 0, BTABLE_KEYSIZE);
|
||||
Assert(ShmemIndex);
|
||||
MemSet(item.key, 0, SHMEM_INDEX_KEYSIZE);
|
||||
sprintf(item.key, "PID %d", pid);
|
||||
|
||||
SpinAcquire(BindingLock);
|
||||
result = (BindingEnt *)
|
||||
hash_search(BindingTable, (char *) &item, HASH_ENTER, &found);
|
||||
SpinAcquire(ShmemIndexLock);
|
||||
result = (ShmemIndexEnt *)
|
||||
hash_search(ShmemIndex, (char *) &item, HASH_ENTER, &found);
|
||||
|
||||
if (!result)
|
||||
{
|
||||
|
||||
SpinRelease(BindingLock);
|
||||
elog(ERROR, "ShmemInitPID: BindingTable corrupted");
|
||||
SpinRelease(ShmemIndexLock);
|
||||
elog(ERROR, "ShmemInitPID: ShmemIndex corrupted");
|
||||
return (FALSE);
|
||||
|
||||
}
|
||||
|
|
@ -414,39 +414,39 @@ ShmemPIDLookup(int pid, SHMEM_OFFSET *locationPtr)
|
|||
else
|
||||
result->location = *locationPtr;
|
||||
|
||||
SpinRelease(BindingLock);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
* ShmemPIDDestroy -- destroy binding table entry for process
|
||||
* ShmemPIDDestroy -- destroy shmem index entry for process
|
||||
* using process id
|
||||
*
|
||||
* Returns: offset of the process struct in shared memory or
|
||||
* INVALID_OFFSET if not found.
|
||||
*
|
||||
* Side Effect: removes the entry from the binding table
|
||||
* Side Effect: removes the entry from the shmem index
|
||||
*/
|
||||
SHMEM_OFFSET
|
||||
ShmemPIDDestroy(int pid)
|
||||
{
|
||||
BindingEnt *result,
|
||||
ShmemIndexEnt *result,
|
||||
item;
|
||||
bool found;
|
||||
SHMEM_OFFSET location = 0;
|
||||
|
||||
Assert(BindingTable);
|
||||
Assert(ShmemIndex);
|
||||
|
||||
MemSet(item.key, 0, BTABLE_KEYSIZE);
|
||||
MemSet(item.key, 0, SHMEM_INDEX_KEYSIZE);
|
||||
sprintf(item.key, "PID %d", pid);
|
||||
|
||||
SpinAcquire(BindingLock);
|
||||
result = (BindingEnt *)
|
||||
hash_search(BindingTable, (char *) &item, HASH_REMOVE, &found);
|
||||
SpinAcquire(ShmemIndexLock);
|
||||
result = (ShmemIndexEnt *)
|
||||
hash_search(ShmemIndex, (char *) &item, HASH_REMOVE, &found);
|
||||
|
||||
if (found)
|
||||
location = result->location;
|
||||
SpinRelease(BindingLock);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
|
||||
if (!result)
|
||||
{
|
||||
|
|
@ -473,33 +473,33 @@ ShmemPIDDestroy(int pid)
|
|||
* table is returned.
|
||||
*
|
||||
* Returns: real pointer to the object. FoundPtr is TRUE if
|
||||
* the object is already in the binding table (hence, already
|
||||
* the object is already in the shmem index (hence, already
|
||||
* initialized).
|
||||
*/
|
||||
long *
|
||||
ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
|
||||
{
|
||||
BindingEnt *result,
|
||||
ShmemIndexEnt *result,
|
||||
item;
|
||||
long *structPtr;
|
||||
|
||||
strncpy(item.key, name, BTABLE_KEYSIZE);
|
||||
strncpy(item.key, name, SHMEM_INDEX_KEYSIZE);
|
||||
item.location = BAD_LOCATION;
|
||||
|
||||
SpinAcquire(BindingLock);
|
||||
SpinAcquire(ShmemIndexLock);
|
||||
|
||||
if (!BindingTable)
|
||||
if (!ShmemIndex)
|
||||
{
|
||||
#ifdef USE_ASSERT_CHECKING
|
||||
char *strname = "BindingTable";
|
||||
char *strname = "ShmemIndex";
|
||||
#endif
|
||||
/*
|
||||
* If the binding table doesnt exist, we fake it.
|
||||
* If the shmem index doesnt exist, we fake it.
|
||||
*
|
||||
* If we are creating the first binding table, then let shmemalloc()
|
||||
* If we are creating the first shmem index, then let shmemalloc()
|
||||
* allocate the space for a new HTAB. Otherwise, find the old one
|
||||
* and return that. Notice that the BindingLock is held until the
|
||||
* binding table has been completely initialized.
|
||||
* and return that. Notice that the ShmemIndexLock is held until the
|
||||
* shmem index has been completely initialized.
|
||||
*/
|
||||
Assert(!strcmp(name, strname));
|
||||
if (ShmemBootstrap)
|
||||
|
|
@ -511,41 +511,41 @@ ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
|
|||
}
|
||||
else
|
||||
{
|
||||
Assert(ShmemBindingTableOffset);
|
||||
Assert(ShmemIndexOffset);
|
||||
|
||||
*foundPtr = TRUE;
|
||||
return ((long *) MAKE_PTR(*ShmemBindingTableOffset));
|
||||
return ((long *) MAKE_PTR(*ShmemIndexOffset));
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
/* look it up in the binding table */
|
||||
result = (BindingEnt *)
|
||||
hash_search(BindingTable, (char *) &item, HASH_ENTER, foundPtr);
|
||||
/* look it up in the shmem index */
|
||||
result = (ShmemIndexEnt *)
|
||||
hash_search(ShmemIndex, (char *) &item, HASH_ENTER, foundPtr);
|
||||
}
|
||||
|
||||
if (!result)
|
||||
{
|
||||
SpinRelease(BindingLock);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
|
||||
elog(ERROR, "ShmemInitStruct: Binding Table corrupted");
|
||||
elog(ERROR, "ShmemInitStruct: Shmem Index corrupted");
|
||||
return (NULL);
|
||||
|
||||
}
|
||||
else if (*foundPtr)
|
||||
{
|
||||
/*
|
||||
* Structure is in the binding table so someone else has allocated
|
||||
* Structure is in the shmem index so someone else has allocated
|
||||
* it already. The size better be the same as the size we are
|
||||
* trying to initialize to or there is a name conflict (or worse).
|
||||
*/
|
||||
if (result->size != size)
|
||||
{
|
||||
SpinRelease(BindingLock);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
|
||||
elog(NOTICE, "ShmemInitStruct: BindingTable entry size is wrong");
|
||||
elog(NOTICE, "ShmemInitStruct: ShmemIndex entry size is wrong");
|
||||
/* let caller print its message too */
|
||||
return (NULL);
|
||||
}
|
||||
|
|
@ -558,9 +558,9 @@ ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
|
|||
if (!structPtr)
|
||||
{
|
||||
/* out of memory */
|
||||
Assert(BindingTable);
|
||||
hash_search(BindingTable, (char *) &item, HASH_REMOVE, foundPtr);
|
||||
SpinRelease(BindingLock);
|
||||
Assert(ShmemIndex);
|
||||
hash_search(ShmemIndex, (char *) &item, HASH_REMOVE, foundPtr);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
*foundPtr = FALSE;
|
||||
|
||||
elog(NOTICE, "ShmemInitStruct: cannot allocate '%s'",
|
||||
|
|
@ -572,7 +572,7 @@ ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
|
|||
}
|
||||
Assert(ShmemIsValid((unsigned long) structPtr));
|
||||
|
||||
SpinRelease(BindingLock);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
return (structPtr);
|
||||
}
|
||||
|
||||
|
|
@ -586,19 +586,19 @@ ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
|
|||
bool
|
||||
TransactionIdIsInProgress(TransactionId xid)
|
||||
{
|
||||
BindingEnt *result;
|
||||
ShmemIndexEnt *result;
|
||||
PROC *proc;
|
||||
|
||||
Assert(BindingTable);
|
||||
Assert(ShmemIndex);
|
||||
|
||||
SpinAcquire(BindingLock);
|
||||
SpinAcquire(ShmemIndexLock);
|
||||
|
||||
hash_seq((HTAB *) NULL);
|
||||
while ((result = (BindingEnt *) hash_seq(BindingTable)) != NULL)
|
||||
while ((result = (ShmemIndexEnt *) hash_seq(ShmemIndex)) != NULL)
|
||||
{
|
||||
if (result == (BindingEnt *) TRUE)
|
||||
if (result == (ShmemIndexEnt *) TRUE)
|
||||
{
|
||||
SpinRelease(BindingLock);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
return (false);
|
||||
}
|
||||
if (result->location == INVALID_OFFSET ||
|
||||
|
|
@ -607,12 +607,12 @@ TransactionIdIsInProgress(TransactionId xid)
|
|||
proc = (PROC *) MAKE_PTR(result->location);
|
||||
if (proc->xid == xid)
|
||||
{
|
||||
SpinRelease(BindingLock);
|
||||
SpinRelease(ShmemIndexLock);
|
||||
return (true);
|
||||
}
|
||||
}
|
||||
|
||||
SpinRelease(BindingLock);
|
||||
elog(ERROR, "TransactionIdIsInProgress: BindingTable corrupted");
|
||||
SpinRelease(ShmemIndexLock);
|
||||
elog(ERROR, "TransactionIdIsInProgress: ShmemIndex corrupted");
|
||||
return (false);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/spin.c,v 1.13 1998/06/23 16:04:46 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/spin.c,v 1.14 1998/06/27 15:47:45 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -53,7 +53,7 @@ bool
|
|||
InitSpinLocks(int init, IPCKey key)
|
||||
{
|
||||
extern SPINLOCK ShmemLock;
|
||||
extern SPINLOCK BindingLock;
|
||||
extern SPINLOCK ShmemIndexLock;
|
||||
extern SPINLOCK BufMgrLock;
|
||||
extern SPINLOCK LockMgrLock;
|
||||
extern SPINLOCK ProcStructLock;
|
||||
|
|
@ -66,7 +66,7 @@ InitSpinLocks(int init, IPCKey key)
|
|||
|
||||
/* These six spinlocks have fixed location is shmem */
|
||||
ShmemLock = (SPINLOCK) SHMEMLOCKID;
|
||||
BindingLock = (SPINLOCK) BINDINGLOCKID;
|
||||
ShmemIndexLock = (SPINLOCK) SHMEMINDEXLOCKID;
|
||||
BufMgrLock = (SPINLOCK) BUFMGRLOCKID;
|
||||
LockMgrLock = (SPINLOCK) LOCKMGRLOCKID;
|
||||
ProcStructLock = (SPINLOCK) PROCSTRUCTLOCKID;
|
||||
|
|
@ -265,7 +265,7 @@ AttachSpinLocks(IPCKey key)
|
|||
* InitSpinLocks -- Spinlock bootstrapping
|
||||
*
|
||||
* We need several spinlocks for bootstrapping:
|
||||
* BindingLock (for the shmem binding table) and
|
||||
* ShmemIndexLock (for the shmem index table) and
|
||||
* ShmemLock (for the shmem allocator), BufMgrLock (for buffer
|
||||
* pool exclusive access), LockMgrLock (for the lock table), and
|
||||
* ProcStructLock (a spin lock for the shared process structure).
|
||||
|
|
@ -277,7 +277,7 @@ bool
|
|||
InitSpinLocks(int init, IPCKey key)
|
||||
{
|
||||
extern SPINLOCK ShmemLock;
|
||||
extern SPINLOCK BindingLock;
|
||||
extern SPINLOCK ShmemIndexLock;
|
||||
extern SPINLOCK BufMgrLock;
|
||||
extern SPINLOCK LockMgrLock;
|
||||
extern SPINLOCK ProcStructLock;
|
||||
|
|
@ -305,7 +305,7 @@ InitSpinLocks(int init, IPCKey key)
|
|||
|
||||
/* These five (or six) spinlocks have fixed location is shmem */
|
||||
ShmemLock = (SPINLOCK) SHMEMLOCKID;
|
||||
BindingLock = (SPINLOCK) BINDINGLOCKID;
|
||||
ShmemIndexLock = (SPINLOCK) SHMEMINDEXLOCKID;
|
||||
BufMgrLock = (SPINLOCK) BUFMGRLOCKID;
|
||||
LockMgrLock = (SPINLOCK) LOCKMGRLOCKID;
|
||||
ProcStructLock = (SPINLOCK) PROCSTRUCTLOCKID;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.29 1998/06/27 04:53:37 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.30 1998/06/27 15:47:46 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Outside modules can create a lock table and acquire/release
|
||||
|
|
@ -216,9 +216,9 @@ LockTypeInit(LOCKTAB *ltable,
|
|||
* LockTableInit -- initialize a lock table structure
|
||||
*
|
||||
* Notes:
|
||||
* (a) a lock table has four separate entries in the binding
|
||||
* (a) a lock table has four separate entries in the shmem index
|
||||
* table. This is because every shared hash table and spinlock
|
||||
* has its name stored in the binding table at its creation. It
|
||||
* has its name stored in the shmem index at its creation. It
|
||||
* is wasteful, in this case, but not much space is involved.
|
||||
*
|
||||
*/
|
||||
|
|
@ -242,7 +242,7 @@ LockTableInit(char *tabName,
|
|||
return (INVALID_TABLEID);
|
||||
}
|
||||
|
||||
/* allocate a string for the binding table lookup */
|
||||
/* allocate a string for the shmem index table lookup */
|
||||
shmemName = (char *) palloc((unsigned) (strlen(tabName) + 32));
|
||||
if (!shmemName)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.37 1998/06/27 04:53:39 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.38 1998/06/27 15:47:46 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -46,7 +46,7 @@
|
|||
* This is so that we can support more backends. (system-wide semaphore
|
||||
* sets run out pretty fast.) -ay 4/95
|
||||
*
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.37 1998/06/27 04:53:39 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.38 1998/06/27 15:47:46 momjian Exp $
|
||||
*/
|
||||
#include <sys/time.h>
|
||||
#include <unistd.h>
|
||||
|
|
@ -184,7 +184,7 @@ InitProcess(IPCKey key)
|
|||
{
|
||||
|
||||
/*
|
||||
* have to allocate one. We can't use the normal binding table
|
||||
* have to allocate one. We can't use the normal shmem index table
|
||||
* mechanism because the proc structure is stored by PID instead
|
||||
* of by a global name (need to look it up by PID when we cleanup
|
||||
* dead processes).
|
||||
|
|
@ -261,7 +261,7 @@ InitProcess(IPCKey key)
|
|||
MemSet(MyProc->sLocks, 0, MAX_SPINS * sizeof(*MyProc->sLocks));
|
||||
|
||||
/* -------------------------
|
||||
* Install ourselves in the binding table. The name to
|
||||
* Install ourselves in the shmem index table. The name to
|
||||
* use is determined by the OS-assigned process id. That
|
||||
* allows the cleanup process to find us after any untimely
|
||||
* exit.
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: ipc.h,v 1.28 1998/06/27 13:24:21 momjian Exp $
|
||||
* $Id: ipc.h,v 1.29 1998/06/27 15:47:47 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file is very architecture-specific. This stuff should actually
|
||||
|
|
@ -109,7 +109,7 @@ typedef enum _LockId_
|
|||
LOCKLOCKID,
|
||||
OIDGENLOCKID,
|
||||
SHMEMLOCKID,
|
||||
BINDINGLOCKID,
|
||||
SHMEMINDEXLOCKID,
|
||||
LOCKMGRLOCKID,
|
||||
SINVALLOCKID,
|
||||
|
||||
|
|
@ -139,7 +139,7 @@ typedef struct slock
|
|||
typedef enum _LockId_
|
||||
{
|
||||
SHMEMLOCKID,
|
||||
BINDINGLOCKID,
|
||||
SHMEMINDEXLOCKID,
|
||||
BUFMGRLOCKID,
|
||||
LOCKMGRLOCKID,
|
||||
SINVALLOCKID,
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: shmem.h,v 1.12 1998/06/25 14:24:35 momjian Exp $
|
||||
* $Id: shmem.h,v 1.13 1998/06/27 15:47:48 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -49,7 +49,7 @@ extern SHMEM_OFFSET ShmemBase;
|
|||
|
||||
|
||||
extern SPINLOCK ShmemLock;
|
||||
extern SPINLOCK BindingLock;
|
||||
extern SPINLOCK ShmemIndexLock;
|
||||
|
||||
/* shmemqueue.c */
|
||||
typedef struct SHM_QUEUE
|
||||
|
|
@ -59,7 +59,7 @@ typedef struct SHM_QUEUE
|
|||
} SHM_QUEUE;
|
||||
|
||||
/* shmem.c */
|
||||
extern void ShmemBindingTableReset(void);
|
||||
extern void ShmemIndexReset(void);
|
||||
extern void ShmemCreate(unsigned int key, unsigned int size);
|
||||
extern int InitShmem(unsigned int key, unsigned int size);
|
||||
extern long *ShmemAlloc(unsigned long size);
|
||||
|
|
@ -77,21 +77,21 @@ extern bool TransactionIdIsInProgress(TransactionId xid);
|
|||
|
||||
typedef int TableID;
|
||||
|
||||
/* size constants for the binding table */
|
||||
/* size constants for the shmem index table */
|
||||
/* max size of data structure string name */
|
||||
#define BTABLE_KEYSIZE (50)
|
||||
/* data in binding table hash bucket */
|
||||
#define BTABLE_DATASIZE (sizeof(BindingEnt) - BTABLE_KEYSIZE)
|
||||
/* maximum size of the binding table */
|
||||
#define BTABLE_SIZE (100)
|
||||
#define SHMEM_INDEX_KEYSIZE (50)
|
||||
/* data in shmem index table hash bucket */
|
||||
#define SHMEM_INDEX_DATASIZE (sizeof(ShmemIndexEnt) - SHMEM_INDEX_KEYSIZE)
|
||||
/* maximum size of the shmem index table */
|
||||
#define SHMEM_INDEX_SIZE (100)
|
||||
|
||||
/* this is a hash bucket in the binding table */
|
||||
/* this is a hash bucket in the shmem index table */
|
||||
typedef struct
|
||||
{
|
||||
char key[BTABLE_KEYSIZE]; /* string name */
|
||||
char key[SHMEM_INDEX_KEYSIZE]; /* string name */
|
||||
unsigned long location; /* location in shared mem */
|
||||
unsigned long size; /* numbytes allocated for the structure */
|
||||
} BindingEnt;
|
||||
} ShmemIndexEnt;
|
||||
|
||||
/*
|
||||
* prototypes for functions in shmqueue.c
|
||||
|
|
|
|||
Loading…
Reference in New Issue