1 /*-------------------------------------------------------------------------
4 * per-process shared memory data structures
7 * Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
10 * $PostgreSQL: pgsql/src/include/storage/proc.h,v 1.91 2006/10/04 00:30:10 momjian Exp $
12 *-------------------------------------------------------------------------
17 #include "storage/lock.h"
18 #include "storage/pg_sema.h"
22 * Each backend advertises up to PGPROC_MAX_CACHED_SUBXIDS TransactionIds
23 * for non-aborted subtransactions of its current top transaction. These
24 * have to be treated as running XIDs by other backends.
26 * We also keep track of whether the cache overflowed (ie, the transaction has
27 * generated at least one subtransaction that didn't fit in the cache).
28 * If none of the caches have overflowed, we can assume that an XID that's not
29 * listed anywhere in the PGPROC array is not a running transaction. Else we
30 * have to look at pg_subtrans.
32 #define PGPROC_MAX_CACHED_SUBXIDS 64 /* XXX guessed-at value */
38 TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS];
42 * Each backend has a PGPROC struct in shared memory. There is also a list of
43 * currently-unused PGPROC structs that will be reallocated to new backends.
45 * links: list link for any list the PGPROC is in. When waiting for a lock,
46 * the PGPROC is linked into that lock's waitProcs queue. A recycled PGPROC
47 * is linked into ProcGlobal's freeProcs list.
49 * Note: twophase.c also sets up a dummy PGPROC struct for each currently
50 * prepared transaction. These PGPROCs appear in the ProcArray data structure
51 * so that the prepared transactions appear to be still running and are
52 * correctly shown as holding locks. A prepared transaction PGPROC can be
53 * distinguished from a real one at need by the fact that it has pid == 0.
54 * The semaphore and lock-activity fields in a prepared-xact PGPROC are unused,
55 * but its myProcLocks[] lists are valid.
59 /* proc->links MUST BE FIRST IN STRUCT (see ProcSleep,ProcWakeup,etc) */
60 SHM_QUEUE links; /* list link if process is in a list */
62 PGSemaphoreData sem; /* ONE semaphore to sleep on */
63 int waitStatus; /* STATUS_WAITING, STATUS_OK or STATUS_ERROR */
65 TransactionId xid; /* transaction currently being executed by
68 TransactionId xmin; /* minimal running XID as it was when we were
69 * starting our xact, excluding LAZY VACUUM:
70 * vacuum must not remove tuples deleted by
73 int pid; /* This backend's process id, or 0 */
74 Oid databaseId; /* OID of database this backend is using */
75 Oid roleId; /* OID of role using this backend */
77 bool inVacuum; /* true if current xact is a LAZY VACUUM */
79 /* Info about LWLock the process is currently waiting for, if any. */
80 bool lwWaiting; /* true if waiting for an LW lock */
81 bool lwExclusive; /* true if waiting for exclusive access */
82 struct PGPROC *lwWaitLink; /* next waiter for same LW lock */
84 /* Info about lock the process is currently waiting for, if any. */
85 /* waitLock and waitProcLock are NULL if not currently waiting. */
86 LOCK *waitLock; /* Lock object we're sleeping on ... */
87 PROCLOCK *waitProcLock; /* Per-holder info for awaited lock */
88 LOCKMODE waitLockMode; /* type of lock we're waiting for */
89 LOCKMASK heldLocks; /* bitmask for lock types already held on this
90 * lock object by this backend */
93 * All PROCLOCK objects for locks held or awaited by this backend are
94 * linked into one of these lists, according to the partition number of
97 SHM_QUEUE myProcLocks[NUM_LOCK_PARTITIONS];
99 struct XidCache subxids; /* cache for subtransaction XIDs */
102 /* NOTE: "typedef struct PGPROC PGPROC" appears in storage/lock.h. */
105 extern DLLIMPORT PGPROC *MyProc;
109 * There is one ProcGlobal struct for the whole database cluster.
111 typedef struct PROC_HDR
113 /* Head of list of free PGPROC structures */
114 SHMEM_OFFSET freeProcs;
115 /* Current shared estimate of appropriate spins_per_delay value */
120 * We set aside some extra PGPROC structures for "dummy" processes,
121 * ie things that aren't full-fledged backends but need shmem access.
123 #define NUM_DUMMY_PROCS 2
126 /* configurable options */
127 extern int DeadlockTimeout;
128 extern int StatementTimeout;
130 extern volatile bool cancel_from_timeout;
134 * Function Prototypes
136 extern int ProcGlobalSemas(void);
137 extern Size ProcGlobalShmemSize(void);
138 extern void InitProcGlobal(void);
139 extern void InitProcess(void);
140 extern void InitProcessPhase2(void);
141 extern void InitDummyProcess(void);
142 extern bool HaveNFreeProcs(int n);
143 extern void ProcReleaseLocks(bool isCommit);
145 extern void ProcQueueInit(PROC_QUEUE *queue);
146 extern int ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable);
147 extern PGPROC *ProcWakeup(PGPROC *proc, int waitStatus);
148 extern void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock);
149 extern bool LockWaitCancel(void);
151 extern void ProcWaitForSignal(void);
152 extern void ProcSendSignal(int pid);
154 extern bool enable_sig_alarm(int delayms, bool is_statement_timeout);
155 extern bool disable_sig_alarm(bool is_statement_timeout);
156 extern void handle_sig_alarm(SIGNAL_ARGS);