Index: src/backend/access/transam/xlog.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/access/transam/xlog.c,v retrieving revision 1.126 diff -w -r1.126 xlog.c 169c169 < static XLogRecPtr RedoRecPtr; --- > XLogRecPtr RedoRecPtr; 234,238c234 < typedef struct XLogwrtResult < { < XLogRecPtr Write; /* last byte + 1 written out */ < XLogRecPtr Flush; /* last byte + 1 flushed */ < } XLogwrtResult; --- > /* FIXME: [fork/exec] XLogwrtResult struct moved to xlogdefs.h */ 407c403 < static XLogwrtResult LogwrtResult = {{0, 0}, {0, 0}}; --- > XLogwrtResult LogwrtResult = {{0, 0}, {0, 0}}; 2400c2396 < bool found; --- > bool foundXLog, foundCFile; 2411,2412c2407 < &found); < Assert(!found); --- > &foundXLog); 2414,2415c2409,2417 < ShmemInitStruct("Control File", sizeof(ControlFileData), &found); < Assert(!found); --- > ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile); > > if (foundXLog || foundCFile) > { > /* both should be present or neither */ > Assert(foundXLog && foundCFile); > return; > } > Index: src/backend/postmaster/pgstat.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/postmaster/pgstat.c,v retrieving revision 1.48 diff -w -r1.48 pgstat.c 74c74 < static int pgStatSock = -1; --- > int pgStatSock = -1; Index: src/backend/postmaster/postmaster.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/postmaster/postmaster.c,v retrieving revision 1.351 diff -w -r1.351 postmaster.c 129a130 > 305a307,308 > static enum CAC_state PMcanAcceptConnections = CAC_STARTUP; > 1246a1250,1252 > #ifdef EXEC_BACKEND > abort(); /* Whoops. Not handled... yet FIXME */ > #else 1247a1254 > #endif 1290d1296 < 1432d1437 < 1438,1439c1443 < cac = canAcceptConnections(); < --- > cac = PMcanAcceptConnections; 2343a2348 > 2345,2349c2350,2352 < * BackendFork -- perform authentication, and if successful, set up the < * backend's argument list and invoke backend main(). < * < * This used to perform an execv() but we no longer exec the backend; < * it's the same executable as the postmaster. --- > * BackendInit/Fork -- perform authentication [BackendInit], and if successful, > * set up the backend's argument list [BackendFork] and invoke > * backend main() [or exec in EXEC_BACKEND case] 2355,2356c2358 < static int < BackendFork(Port *port) --- > bool BackendInit(Port *port) 2358,2367d2359 < char **av; < int maxac; < int ac; < char debugbuf[32]; < char protobuf[32]; < < #ifdef EXEC_BACKEND < char pbuf[NAMEDATALEN + 256]; < #endif < int i; 2374,2377d2365 < /* < * Let's clean up ourselves as the postmaster child < */ < 2389,2391d2376 < /* Close the postmaster's other sockets */ < ClosePostmasterPorts(true); < 2447,2455c2432 < /* < * PreAuthDelay is a debugging aid for investigating problems in the < * authentication cycle: it can be set in postgresql.conf to allow < * time to attach to the newly-forked backend with a debugger. (See < * also the -W backend switch, which we allow clients to pass through < * PGOPTIONS, but it is not honored until after authentication.) < */ < if (PreAuthDelay > 0) < sleep(PreAuthDelay); --- > /* FIXME: [fork/exec] previously had PreAuthDelay here */ 2472c2449 < return 0; /* cancel request processed, or error */ --- > return false; /* cancel request processed, or error */ 2508a2486,2530 > #ifdef EXEC_BACKEND > ClientAuthInProgress = false; /* client_min_messages is active > * now */ > #endif > return true; > } > > > static int > BackendFork(Port *port) > { > char **av; > int maxac; > int ac; > char debugbuf[32]; > #ifndef BACKEND > char protobuf[32]; > #endif > int i; > char tmpExtraOptions[MAXPGPATH]; > > /* > * Let's clean up ourselves as the postmaster child > */ > /* Close the postmaster's other sockets */ > ClosePostmasterPorts(true); > > /* > * PreAuthDelay is a debugging aid for investigating problems in the > * authentication cycle: it can be set in postgresql.conf to allow > * time to attach to the newly-forked backend with a debugger. (See > * also the -W backend switch, which we allow clients to pass through > * PGOPTIONS, but it is not honored until after authentication.) > */ > if (PreAuthDelay > 0) > sleep(PreAuthDelay); > > /* FIXME: [fork/exec] Might be nice to put this in the port struct? */ > PMcanAcceptConnections = canAcceptConnections(); > > #ifndef EXEC_BACKEND > if (!BackendInit(port)) > return -1; > #endif > 2543,2545c2565,2566 < * command line. We assume these are secure. (It's OK to mangle < * ExtraOptions since we are now in the child process; this won't < * change the postmaster's copy.) --- > * command line. We assume these are secure. > * [FIXME: [fork/exec] changed to make a copy, to protect against future fork/exec changes] 2547c2568,2569 < split_opts(av, &ac, ExtraOptions); --- > strcpy(tmpExtraOptions,ExtraOptions); > split_opts(av, &ac, tmpExtraOptions); 2548a2571 > #ifndef EXEC_BACKEND 2551a2575 > #endif 2557d2580 < av[ac++] = "-p"; 2559,2565c2582,2588 < Assert(UsedShmemSegID != 0 && UsedShmemSegAddr != NULL); < /* database name at the end because it might contain commas */ < snprintf(pbuf, sizeof(pbuf), "%d,%d,%lu,%p,%s", < port->sock, canAcceptConnections(), < UsedShmemSegID, UsedShmemSegAddr, < port->database_name); < av[ac++] = pbuf; --- > write_backend_variables(getpid(),port); > > /* pass data dir before end of secure switches (-p) */ > av[ac++] = "-D"; > av[ac++] = DataDir; > av[ac++] = "-p"; > av[ac++] = "FORK_EXEC"; /* FIXME: [fork/exec] This is totally bogus. We need to pass an arg to -p, but we'll get the db name out by ProcessStartupPacket in the exec'd process */ 2566a2590 > av[ac++] = "-p"; 2573a2598,2601 > /* FIXME: [fork/exec] Hmmm.. we won't see these until after we BackendInit. > * Should we add code to BackendInit to add these (somehow!) into > * the PostgresMain argument list in the EXEC_BACKEND case? > */ 2597c2625 < progname, MyProcPid))); --- > progname, getpid()))); 2603a2632,2634 > #ifdef EXEC_BACKEND > return execv(pg_pathname,av); > #else 2607a2639 > #endif 3053a3086,3204 > > > #if EXEC_BACKEND > > /* FIXME: [fork/exec] The following need to be available to the read/write_backend_variables functions... */ > typedef struct LWLock LWLock; > extern LWLock *LWLockArray; > extern slock_t *ProcStructLock; > extern XLogRecPtr RedoRecPtr; > extern XLogwrtResult LogwrtResult; > extern int pgStatSock; > > #define write_var(var,fp) fwrite((void*)&(var),sizeof(var),1,fp) > #define read_var(var,fp) fread((void*)&(var),sizeof(var),1,fp); > > /* FIXME: [fork/exec] Where's a good place for these functions? */ > /* FIXME: [fork/exec] Refactor these two functions into one? */ > > void > write_backend_variables(pid_t pid, Port *port) > { > char filename[MAXPGPATH]; > FILE *fp; > > Assert(DataDir); > sprintf(filename, "%s/backend_vars.%d", DataDir, pid); /* FIXME: [fork/exec] Is this really an appropriate directory? */ > > /* Open file */ > fp = AllocateFile(filename, "wb"); > if (!fp) > { > ereport(ERROR, > (errcode_for_file_access(), > errmsg("could not write to file \"%s\": %m", filename))); > return; > } > > /* Write vars */ > write_var(port->sock,fp); > write_var(port->proto,fp); > write_var(port->laddr,fp); > write_var(port->raddr,fp); > > write_var(PMcanAcceptConnections,fp); > > write_var(UsedShmemSegID,fp); > write_var(UsedShmemSegAddr,fp); > > write_var(ShmemSegHdr,fp); > write_var(ShmemLock,fp); > write_var(ShmemIndexLock,fp); > write_var(ShmemVariableCache,fp); > write_var(ShmemIndexAlloc,fp); > > write_var(LWLockArray,fp); > > write_var(ProcStructLock,fp); > > write_var(RedoRecPtr,fp); > write_var(LogwrtResult,fp); > > write_var(pgStatSock,fp); > > /* Release file */ > FreeFile(fp); > } > > void > read_backend_variables(pid_t pid, Port *port) > { > char filename[MAXPGPATH]; > FILE *fp; > > Assert(DataDir); > Assert(pid == getpid()); > sprintf(filename, "%s/backend_vars.%d", DataDir, pid); > > /* Open file */ > fp = AllocateFile(filename, "rb"); > if (!fp) > { > ereport(ERROR, > (errcode_for_file_access(), > errmsg("could not write to file \"%s\": %m", filename))); > return; > } > > /* Read vars */ > read_var(port->sock,fp); > read_var(port->proto,fp); > read_var(port->laddr,fp); > read_var(port->raddr,fp); > > read_var(PMcanAcceptConnections,fp); > > read_var(UsedShmemSegID,fp); > read_var(UsedShmemSegAddr,fp); > > read_var(ShmemSegHdr,fp); > read_var(ShmemLock,fp); > read_var(ShmemIndexLock,fp); > read_var(ShmemVariableCache,fp); > read_var(ShmemIndexAlloc,fp); > > read_var(LWLockArray,fp); > > read_var(ProcStructLock,fp); > > read_var(RedoRecPtr,fp); > read_var(LogwrtResult,fp); > > read_var(pgStatSock,fp); > > /* Release file */ > FreeFile(fp); > unlink(filename); > } > > #endif Index: src/backend/storage/buffer/buf_init.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/buffer/buf_init.c,v retrieving revision 1.58 diff -w -r1.58 buf_init.c 139c139,140 < LWLockAcquire(BufMgrLock, LW_EXCLUSIVE); --- > /* FIXME: [fork/exec] Can we remove this? */ > /* LWLockAcquire(BufMgrLock, LW_EXCLUSIVE); */ 201c202,203 < LWLockRelease(BufMgrLock); --- > /* FIXME: [fork/exec] Can we remove this? */ > /* LWLockRelease(BufMgrLock); */ Index: src/backend/storage/freespace/freespace.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/freespace/freespace.c,v retrieving revision 1.26 diff -w -r1.26 freespace.c 183c183,184 < HTAB *relHash; /* hashtable of FSMRelation entries */ --- > /* FIXME: [fork/exec] Pointer to invalid memory location for backends in fork/exec case */ > /* HTAB *relHash; */ /* hashtable of FSMRelation entries */ 220a222 > static HTAB *FreeSpaceMapRelHash; /* points to FSMHeader->relHash in shared memory */ 267a270 > bool found; 270c273 < FreeSpaceMap = (FSMHeader *) ShmemAlloc(sizeof(FSMHeader)); --- > FreeSpaceMap = (FSMHeader *) ShmemInitStruct("Free Space Map Header",sizeof(FSMHeader),&found); 274a278 > if (!found) 282c286 < FreeSpaceMap->relHash = ShmemInitHash("Free Space Map Hash", --- > FreeSpaceMapRelHash = ShmemInitHash("Free Space Map Hash", 288c292 < if (!FreeSpaceMap->relHash) --- > if (!FreeSpaceMapRelHash) 292a297,300 > if (found) > return; > > 977c985 < fsmrel = (FSMRelation *) hash_search(FreeSpaceMap->relHash, --- > fsmrel = (FSMRelation *) hash_search(FreeSpaceMapRelHash, 998c1006 < fsmrel = (FSMRelation *) hash_search(FreeSpaceMap->relHash, --- > fsmrel = (FSMRelation *) hash_search(FreeSpaceMapRelHash, 1053c1061 < result = (FSMRelation *) hash_search(FreeSpaceMap->relHash, --- > result = (FSMRelation *) hash_search(FreeSpaceMapRelHash, Index: src/backend/storage/ipc/ipci.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/ipc/ipci.c,v retrieving revision 1.59 diff -w -r1.59 ipci.c 90c90 < InitShmemAllocation(seghdr); --- > InitShmemAllocation(seghdr, true); 141a142,144 > > /* FIXME: [fork/exec] This function is starting to look pretty much like > CreateSharedMemoryAndSemaphores... refactor? */ 144a148,153 > InitShmemAllocation(ShmemSegHdr, false); > > > InitShmemIndex(); > > XLOGShmemInit(); 145a155,166 > InitBufferPool(); > > InitLocks(); > InitLockTable(MaxBackends); > > InitProcGlobal(MaxBackends); > > CreateSharedInvalidationState(MaxBackends); > > InitFreeSpaceMap(); > > PMSignalInit(); Index: src/backend/storage/ipc/pmsignal.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/ipc/pmsignal.c,v retrieving revision 1.6 diff -w -r1.6 pmsignal.c 46a47 > bool found; 48c49,52 < ShmemAlloc(NUM_PMSIGNALS * sizeof(sig_atomic_t)); --- > ShmemInitStruct("PMSignalFlags",NUM_PMSIGNALS * sizeof(sig_atomic_t),&found); > > if (found) > return; Index: src/backend/storage/ipc/shmem.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/ipc/shmem.c,v retrieving revision 1.74 diff -w -r1.74 shmem.c 71c71 < static PGShmemHeader *ShmemSegHdr; /* shared mem segment header */ --- > PGShmemHeader *ShmemSegHdr; /* shared mem segment header */ 77c77,81 < static slock_t *ShmemLock; /* spinlock for shared memory allocation */ --- > slock_t *ShmemLock; /* spinlock for shared memory allocation */ > > slock_t *ShmemIndexLock; /* spinlock for ShmemIndex */ > > void *ShmemIndexAlloc = NULL; /* Memory actually allocated for ShmemIndex */ 91c95 < InitShmemAllocation(void *seghdr) --- > InitShmemAllocation(void *seghdr, bool init) 99a104,105 > if (init) > { 101,103c107,109 < * Initialize the spinlock used by ShmemAlloc. We have to do the < * space allocation the hard way, since ShmemAlloc can't be called < * yet. --- > * Initialize the spinlocks used by ShmemAlloc/ShmemInitStruct. We > * have to do the space allocation the hard way, since ShmemAlloc > * can't be called yet. 108a115,118 > ShmemIndexLock = (slock_t *) (((char *) shmhdr) + shmhdr->freeoffset); > shmhdr->freeoffset += MAXALIGN(sizeof(slock_t)); > Assert(shmhdr->freeoffset <= shmhdr->totalsize); > 109a120,121 > SpinLockInit(ShmemIndexLock); > 113a126 > 120a134 > } 220a235,236 > if (!IsUnderPostmaster) > { 236a253 > } 239c256 < LWLockRelease(ShmemIndexLock); --- > SpinLockRelease(ShmemIndexLock); 323c340 < LWLockAcquire(ShmemIndexLock, LW_EXCLUSIVE); --- > SpinLockAcquire(ShmemIndexLock); 326a344,353 > if (IsUnderPostmaster) > { > /* Must be initializing a (non-standalone) backend */ > Assert(strcmp(name, "ShmemIndex") == 0); > Assert(ShmemBootstrap); > Assert(ShmemIndexAlloc); > *foundPtr = TRUE; > } > else > { 331c358 < * Notice that the ShmemIndexLock is held until the shmem index has --- > * Notice that the ShmemLock is held until the shmem index has 337c364,366 < return ShmemAlloc(size); --- > ShmemIndexAlloc = ShmemAlloc(size); > } > return ShmemIndexAlloc; 346c375 < LWLockRelease(ShmemIndexLock); --- > SpinLockRelease(ShmemIndexLock); 362c391 < LWLockRelease(ShmemIndexLock); --- > SpinLockRelease(ShmemIndexLock); 379c408 < LWLockRelease(ShmemIndexLock); --- > SpinLockRelease(ShmemIndexLock); 392c421 < LWLockRelease(ShmemIndexLock); --- > SpinLockRelease(ShmemIndexLock); Index: src/backend/storage/ipc/sinvaladt.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/ipc/sinvaladt.c,v retrieving revision 1.53 diff -w -r1.53 sinvaladt.c 52a53 > bool found; 56c57,59 < shmInvalBuffer = segP = (SISeg *) ShmemAlloc(segSize); --- > shmInvalBuffer = segP = (SISeg *) ShmemInitStruct("shmInvalBuffer",segSize,&found); > if (found) > return; Index: src/backend/storage/lmgr/lock.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/lmgr/lock.c,v retrieving revision 1.130 diff -w -r1.130 lock.c 156d155 < 158a158,163 > /* FIXME: [fork/exec] Create a struct with two HTAB pointers? Other ideas? */ > static HTAB* LockMethodLockHash[MAX_LOCK_METHODS]; > static HTAB* LockMethodProcLockHash[MAX_LOCK_METHODS]; > > > 248c253,254 < LWLockAcquire(LockMgrLock, LW_EXCLUSIVE); --- > /* FIXME: [fork/exec] Can we remove this? */ > /* LWLockAcquire(LockMgrLock, LW_EXCLUSIVE); */ 282c288 < newLockMethod->lockHash = ShmemInitHash(shmemName, --- > LockMethodLockHash[NumLockMethods-1] = ShmemInitHash(shmemName, 288c294 < if (!newLockMethod->lockHash) --- > if (!LockMethodLockHash[NumLockMethods-1]) 290c296 < Assert(newLockMethod->lockHash->hash == tag_hash); --- > Assert(LockMethodLockHash[NumLockMethods-1]->hash == tag_hash); 302c308 < newLockMethod->proclockHash = ShmemInitHash(shmemName, --- > LockMethodProcLockHash[NumLockMethods-1] = ShmemInitHash(shmemName, 308c314 < if (!newLockMethod->proclockHash) --- > if (!LockMethodProcLockHash[NumLockMethods-1]) 314c320,321 < LWLockRelease(LockMgrLock); --- > /* FIXME: [fork/exec] Can we remove this? */ > /* LWLockRelease(LockMgrLock); */ 452,453c459,460 < Assert(lockMethodTable->lockHash->hash == tag_hash); < lock = (LOCK *) hash_search(lockMethodTable->lockHash, --- > Assert(LockMethodLockHash[lockmethodid]->hash == tag_hash); > lock = (LOCK *) hash_search(LockMethodLockHash[lockmethodid], 500c507 < proclockTable = lockMethodTable->proclockHash; --- > proclockTable = LockMethodProcLockHash[lockmethodid]; 991,992c998,999 < Assert(lockMethodTable->lockHash->hash == tag_hash); < lock = (LOCK *) hash_search(lockMethodTable->lockHash, --- > Assert(LockMethodLockHash[lockmethodid]->hash == tag_hash); > lock = (LOCK *) hash_search(LockMethodLockHash[lockmethodid], 1017c1024 < proclockTable = lockMethodTable->proclockHash; --- > proclockTable = LockMethodProcLockHash[lockmethodid]; 1089,1090c1096,1097 < Assert(lockMethodTable->lockHash->hash == tag_hash); < lock = (LOCK *) hash_search(lockMethodTable->lockHash, --- > Assert(LockMethodLockHash[lockmethodid]->hash == tag_hash); > lock = (LOCK *) hash_search(LockMethodLockHash[lockmethodid], 1272c1279 < proclock = (PROCLOCK *) hash_search(lockMethodTable->proclockHash, --- > proclock = (PROCLOCK *) hash_search(LockMethodProcLockHash[lockmethodid], 1290,1291c1297,1298 < Assert(lockMethodTable->lockHash->hash == tag_hash); < lock = (LOCK *) hash_search(lockMethodTable->lockHash, --- > Assert(LockMethodLockHash[lockmethodid]->hash == tag_hash); > lock = (LOCK *) hash_search(LockMethodLockHash[lockmethodid], 1370c1377 < proclockTable = LockMethods[DEFAULT_LOCKMETHOD]->proclockHash; --- > proclockTable = LockMethodProcLockHash[DEFAULT_LOCKMETHOD]; 1483c1490 < proclockTable = lockMethodTable->proclockHash; --- > proclockTable = LockMethodProcLockHash[lockmethodid]; Index: src/backend/storage/lmgr/lwlock.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/lmgr/lwlock.c,v retrieving revision 1.18 diff -w -r1.18 lwlock.c 46c46 < static LWLock *LWLockArray = NULL; --- > LWLock *LWLockArray = NULL; Index: src/backend/storage/lmgr/proc.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/storage/lmgr/proc.c,v retrieving revision 1.139 diff -w -r1.139 proc.c 69c69 < static slock_t *ProcStructLock = NULL; --- > slock_t *ProcStructLock = NULL; 249a250 > Index: src/backend/tcop/postgres.c =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/backend/tcop/postgres.c,v retrieving revision 1.379 diff -w -r1.379 postgres.c 70a71,74 > /* FIXME: [fork/exec] */ > extern int BackendInit(Port*); > extern void read_backend_variables(pid_t pid, Port *port); > 2055d2058 < 2063c2066 < if (!IsUnderPostmaster) --- > if (!IsUnderPostmaster /* when exec || ExecBackend */) 2136d2138 < break; 2271d2272 < 2278,2293c2279 < #ifdef EXEC_BACKEND < char *p; < int i; < int PMcanAcceptConnections; /* will eventually be < * global or static, < * when fork */ < < sscanf(optarg, "%d,%d,%lu,%p,", < &MyProcPort->sock, &PMcanAcceptConnections, < &UsedShmemSegID, &UsedShmemSegAddr); < /* Grab dbname as last param */ < for (i = 0, p = optarg - 1; i < 4 && p; i++) < p = strchr(p + 1, ','); < if (i == 4 && p) < dbname = strdup(p + 1); < #else --- > #ifndef EXEC_BACKEND 2294a2281,2305 > > #else > Port *port =(Port*)malloc(sizeof(Port)); > if (port == NULL) > ereport(ERROR, > (errcode(ERRCODE_OUT_OF_MEMORY), > errmsg("insufficient memory to allocate port"))); > > Assert(potential_DataDir); > SetDataDir(potential_DataDir); > > read_nondefault_variables(); > read_backend_variables(getpid(),port); > > /* FIXME: [fork/exec] Ugh */ > load_hba(); > load_ident(); > load_user(); > load_group(); > > > if (!BackendInit(port)) > return -1; > > dbname = port->database_name; 2295a2307 > 2497,2503c2509 < if (IsUnderPostmaster) < { < #ifdef EXEC_BACKEND < read_nondefault_variables(); < #endif < } < else --- > if (!IsUnderPostmaster) 2520d2525 < 2568,2569c2573,2575 < BaseInit(); < #ifdef EXECBACKEND --- > #ifdef EXEC_BACKEND > PGSharedMemoryCreate(-1,false,-1); > 2571a2578,2580 > XLOGPathInit(); > > BaseInit(); 2689d2697 < 2764d2771 < 2847a2855,2857 > #ifdef EXEC_BACKEND > read_nondefault_variables(); > #else 2848a2859 > #endif 2863d2873 < 2866d2875 < 2868d2876 < 3202d3209 < Index: src/include/access/xlogdefs.h =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/include/access/xlogdefs.h,v retrieving revision 1.10 diff -w -r1.10 xlogdefs.h 35a36,44 > > /* FIXME: [fork/exec] following struct moved from xlog.c */ > typedef struct XLogwrtResult > { > XLogRecPtr Write; /* last byte + 1 written out */ > XLogRecPtr Flush; /* last byte + 1 flushed */ > } XLogwrtResult; > > Index: src/include/storage/lock.h =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/include/storage/lock.h,v retrieving revision 1.75 diff -w -r1.75 lock.h 89,90c89,91 < HTAB *lockHash; < HTAB *proclockHash; --- > /* FIXME: [fork/exec] Pointers to invalid memory location for backends in fork/exec case */ > /* HTAB *lockHash; */ > /*HTAB *proclockHash; */ Index: src/include/storage/lwlock.h =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/include/storage/lwlock.h,v retrieving revision 1.9 diff -w -r1.9 lwlock.h 32d31 < ShmemIndexLock, Index: src/include/storage/shmem.h =================================================================== RCS file: /projects/cvsroot/pgsql-server/src/include/storage/shmem.h,v retrieving revision 1.40 diff -w -r1.40 shmem.h 32a33,40 > /* FIXME: [fork/exec] Other externs */ > #include "pg_shmem.h" > extern PGShmemHeader *ShmemSegHdr; > extern slock_t *ShmemLock; > extern slock_t *ShmemIndexLock; > extern HTAB *ShmemIndex; > extern void *ShmemIndexAlloc; > 40d47 < 64c71 < extern void InitShmemAllocation(void *seghdr); --- > extern void InitShmemAllocation(void *seghdr, bool init);