/*------------------------------------------------------------------------- * * shmem.c-- * create shared memory and initialize shared memory data structures. * * Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.3 1996/11/03 05:06:57 scrappy 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 * allocating and binding to shared memory data structures. * * NOTES: * (a) There are three kinds of shared memory data structures * available to POSTGRES: fixed-size structures, queues and hash * tables. Fixed-size structures contain things like global variables * for a module and should never be allocated after the process * initialization phase. Hash tables have a fixed maximum size, but * their actual size can vary dynamically. When entries are added * to the table, more space is allocated. Queues link data structures * that have been allocated either as fixed size structures or as hash * buckets. Each shared data structure has a string name to identify * 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". * 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 * a simple model of how the world looks when a backend process * initializes. If something is present in the binding table, * it is initialized. If it is not, it is uninitialized. Second, * the binding table 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 * things during development), this is important. * * (c) memory allocation model: shared memory can never be * freed, once allocated. Each hash table has its own free list, * so hash buckets can be reused when an item is deleted. However, * if one hash table grows very large and then shrinks, its space * cannot be redistributed to other tables. We could build a simple * hash bucket garbage collector if need be. Right now, it seems * unnecessary. * * See InitSem() in sem.c for an example of how to use the * binding table. * */ #include #include #include #include "postgres.h" #include "storage/ipc.h" #include "storage/shmem.h" #include "storage/spin.h" #include "utils/hsearch.h" /* shared memory global variables */ unsigned long ShmemBase = 0; /* start and end address of * shared memory */ static unsigned long ShmemEnd = 0; static unsigned long ShmemSize = 0; /* current size (and default) */ SPINLOCK ShmemLock; /* lock for shared memory allocation */ SPINLOCK BindingLock; /* lock for binding table access */ static unsigned long *ShmemFreeStart = NULL; /* pointer to the OFFSET of * first free shared memory */ static unsigned long *ShmemBindingTabOffset = NULL; /* start of the binding * table (for bootstrap) */ static int ShmemBootstrap = FALSE; /* flag becomes true when shared mem * is created by POSTMASTER */ static HTAB *BindingTable = NULL; /* --------------------- * ShmemBindingTabReset() - Resets the binding table to NULL.... * useful when the postmaster destroys existing shared memory * and creates all new segments after a backend crash. * ---------------------- */ void ShmemBindingTabReset() { BindingTable = (HTAB *)NULL; } /* * CreateSharedRegion() -- * * This routine is called once by the postmaster to * initialize the shared buffer pool. Assume there is * only one postmaster so no synchronization is necessary * until after this routine completes successfully. * * key is a unique identifier for the shmem region. * size is the size of the region. */ static IpcMemoryId ShmemId; void ShmemCreate(unsigned int key, unsigned int size) { if (size) ShmemSize = size; /* create shared mem region */ if ((ShmemId=IpcMemoryCreate(key,ShmemSize,IPCProtection)) ==IpcMemCreationFailed) { elog(FATAL,"ShmemCreate: cannot create region"); exit(1); } /* ShmemBootstrap is true if shared memory has been * created, but not yet initialized. Only the * postmaster/creator-of-all-things should have * this flag set. */ ShmemBootstrap = TRUE; } /* * InitShmem() -- map region into process address space * and initialize shared data structures. * */ int InitShmem(unsigned int key, unsigned int size) { Pointer sharedRegion; unsigned long currFreeSpace; HASHCTL info; int hash_flags; BindingEnt * result,item; bool found; IpcMemoryId shmid; /* if zero key, use default memory size */ if (size) ShmemSize = size; /* default key is 0 */ /* attach to shared memory region (SysV or BSD OS specific) */ if (ShmemBootstrap && key == PrivateIPCKey) /* if we are running backend alone */ shmid = ShmemId; else shmid = IpcMemoryIdGet(IPCKeyGetBufferMemoryKey(key), ShmemSize); sharedRegion = IpcMemoryAttach(shmid); if (sharedRegion == NULL) { elog(FATAL,"AttachSharedRegion: couldn't attach to shmem\n"); return(FALSE); } /* get pointers to the dimensions of shared memory */ ShmemBase = (unsigned long) sharedRegion; ShmemEnd = (unsigned long) sharedRegion + ShmemSize; currFreeSpace = 0; /* First long in shared memory is the count of available space */ ShmemFreeStart = (unsigned long *) ShmemBase; /* next is a shmem pointer to the binding table */ ShmemBindingTabOffset = ShmemFreeStart + 1; currFreeSpace += sizeof(ShmemFreeStart) + sizeof(ShmemBindingTabOffset); /* bootstrap initialize spin locks so we can start to use the * allocator and binding table. */ if (! InitSpinLocks(ShmemBootstrap, IPCKeyGetSpinLockSemaphoreKey(key))) { return(FALSE); } /* We have just allocated additional space for two spinlocks. * Now setup the global free space count */ if (ShmemBootstrap) { *ShmemFreeStart = currFreeSpace; } /* 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; hash_flags = (HASH_ELEM); /* This will acquire the binding table lock, but not release it. */ BindingTable = ShmemInitHash("BindingTable", BTABLE_SIZE,BTABLE_SIZE, &info,hash_flags); if (! BindingTable) { elog(FATAL,"InitShmem: couldn't initialize Binding Table"); return(FALSE); } /* Now, check the binding table for an entry to the binding * table. 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); result = (BindingEnt *) hash_search(BindingTable,(char *) &item,HASH_ENTER, &found); if (! result ) { elog(FATAL,"InitShmem: corrupted binding table"); return(FALSE); } if (! found) { /* bootstrapping shmem: we have to initialize the * binding table now. */ Assert(ShmemBootstrap); result->location = MAKE_OFFSET(BindingTable->hctl); *ShmemBindingTabOffset = result->location; result->size = BTABLE_SIZE; ShmemBootstrap = FALSE; } else { Assert(! ShmemBootstrap); } /* now release the lock acquired in ShmemHashInit */ SpinRelease (BindingLock); Assert (result->location == MAKE_OFFSET(BindingTable->hctl)); return(TRUE); } /* * ShmemAlloc -- allocate word-aligned byte string from * shared memory * * Assumes ShmemLock and ShmemFreeStart are initialized. * Returns: real pointer to memory or NULL if we are out * of space. Has to return a real pointer in order * to be compatable with malloc(). */ long * ShmemAlloc(unsigned long size) { unsigned long tmpFree; long *newSpace; /* * ensure space is word aligned. * * Word-alignment is not good enough. We have to be more * conservative: doubles need 8-byte alignment. (We probably only need * this on RISC platforms but this is not a big waste of space.) * - ay 12/94 */ if (size % sizeof(double)) size += sizeof(double) - (size % sizeof(double)); Assert(*ShmemFreeStart); SpinAcquire(ShmemLock); tmpFree = *ShmemFreeStart + size; if (tmpFree <= ShmemSize) { newSpace = (long *)MAKE_PTR(*ShmemFreeStart); *ShmemFreeStart += size; } else { newSpace = NULL; } SpinRelease(ShmemLock); if (! newSpace) { elog(NOTICE,"ShmemAlloc: out of memory "); } return(newSpace); } /* * ShmemIsValid -- test if an offset refers to valid shared memory * * Returns TRUE if the pointer is valid. */ int ShmemIsValid(unsigned long addr) { return ((addr=ShmemBase)); } /* * ShmemInitHash -- Create/Attach to and initialize * shared memory hash table. * * Notes: * * assume caller is doing some kind of synchronization * so that two people dont try to create/initialize the * table at once. Use SpinAlloc() to create a spinlock * for the structure before creating the structure itself. */ HTAB * ShmemInitHash(char *name, /* table string name for binding */ long init_size, /* initial size */ long max_size, /* max size of the table */ HASHCTL *infoP, /* info about key and bucket size */ int hash_flags) /* info about infoP */ { bool found; long * location; /* shared memory hash tables have a fixed max size so that the * control structures don't try to grow. The segbase is for * calculating pointer values. The shared memory allocator * must be specified. */ infoP->segbase = (long *) ShmemBase; infoP->alloc = ShmemAlloc; infoP->max_size = max_size; hash_flags |= HASH_SHARED_MEM; /* look it up in the binding table */ location = ShmemInitStruct(name,my_log2(max_size) + sizeof(HHDR),&found); /* binding table is corrupted. Let someone else give the * error message since they have more information */ if (location == NULL) { return(0); } /* it already exists, attach to it rather than allocate and * initialize new space */ if (found) { hash_flags |= HASH_ATTACH; } /* these structures were allocated or bound in ShmemInitStruct */ /* control information and parameters */ infoP->hctl = (long *) location; /* directory for hash lookup */ infoP->dir = (long *) (location + sizeof(HHDR)); return(hash_create(init_size, infoP, hash_flags));; } /* * ShmemPIDLookup -- lookup process data structure using process id * * Returns: TRUE if no error. locationPtr is initialized if PID is * found in the binding table. * * NOTES: * only information about success or failure is the value of * locationPtr. */ bool ShmemPIDLookup(int pid, SHMEM_OFFSET* locationPtr) { BindingEnt * result,item; bool found; Assert (BindingTable); memset(item.key, 0, BTABLE_KEYSIZE); sprintf(item.key,"PID %d",pid); SpinAcquire(BindingLock); result = (BindingEnt *) hash_search(BindingTable,(char *) &item, HASH_ENTER, &found); if (! result) { SpinRelease(BindingLock); elog(WARN,"ShmemInitPID: BindingTable corrupted"); return(FALSE); } if (found) { *locationPtr = result->location; } else { result->location = *locationPtr; } SpinRelease(BindingLock); return (TRUE); } /* * ShmemPIDDestroy -- destroy binding table 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 */ SHMEM_OFFSET ShmemPIDDestroy(int pid) { BindingEnt * result,item; bool found; SHMEM_OFFSET location; Assert(BindingTable); memset(item.key, 0, BTABLE_KEYSIZE); sprintf(item.key,"PID %d",pid); SpinAcquire(BindingLock); result = (BindingEnt *) hash_search(BindingTable,(char *) &item, HASH_REMOVE, &found); if (found) location = result->location; SpinRelease(BindingLock); if (! result) { elog(WARN,"ShmemPIDDestroy: PID table corrupted"); return(INVALID_OFFSET); } if (found) return (location); else { return(INVALID_OFFSET); } } /* * ShmemInitStruct -- Create/attach to a structure in shared * memory. * * This is called during initialization to find or allocate * a data structure in shared memory. If no other processes * have created the structure, this routine allocates space * for it. If it exists already, a pointer to the existing * table is returned. * * Returns: real pointer to the object. FoundPtr is TRUE if * the object is already in the binding table (hence, already * initialized). */ long * ShmemInitStruct(char *name, unsigned long size, bool *foundPtr) { BindingEnt * result,item; long * structPtr; strncpy(item.key,name,BTABLE_KEYSIZE); item.location = BAD_LOCATION; SpinAcquire(BindingLock); if (! BindingTable) { /* Assert() is a macro now. substitutes inside quotes. */ char *strname = "BindingTable"; /* If the binding table doesnt exist, we fake it. * * If we are creating the first binding table, 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. */ Assert (! strcmp(name,strname)) ; if (ShmemBootstrap) { /* in POSTMASTER/Single process */ *foundPtr = FALSE; return((long *)ShmemAlloc(size)); } else { Assert (ShmemBindingTabOffset); *foundPtr = TRUE; return((long *)MAKE_PTR(*ShmemBindingTabOffset)); } } else { /* look it up in the bindint table */ result = (BindingEnt *) hash_search(BindingTable,(char *) &item,HASH_ENTER, foundPtr); } if (! result) { SpinRelease(BindingLock); elog(WARN,"ShmemInitStruct: Binding Table corrupted"); return(NULL); } else if (*foundPtr) { /* * Structure is in the binding table 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); elog(NOTICE,"ShmemInitStruct: BindingTable entry size is wrong"); /* let caller print its message too */ return(NULL); } structPtr = (long *)MAKE_PTR(result->location); } else { /* It isn't in the table yet. allocate and initialize it */ structPtr = ShmemAlloc((long)size); if (! structPtr) { /* out of memory */ Assert (BindingTable); (void) hash_search(BindingTable,(char *) &item,HASH_REMOVE, foundPtr); SpinRelease(BindingLock); *foundPtr = FALSE; elog(NOTICE,"ShmemInitStruct: cannot allocate '%s'", name); return(NULL); } result->size = size; result->location = MAKE_OFFSET(structPtr); } Assert (ShmemIsValid((unsigned long)structPtr)); SpinRelease(BindingLock); return(structPtr); }