postgresql/src/include/miscadmin.h

321 lines
11 KiB
C
Raw Normal View History

1996-10-31 08:10:14 +01:00
/*-------------------------------------------------------------------------
*
* miscadmin.h
* This file contains general postgres administration and initialization
* stuff that used to be spread out between the following files:
* globals.h global variables
* pdir.h directory path crud
* pinit.h postgres initialization
* pmod.h processing modes
* Over time, this has also become the preferred place for widely known
* resource-limitation stuff, such as work_mem and check_stack_depth().
1996-10-31 08:10:14 +01:00
*
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
1996-10-31 08:10:14 +01:00
*
* $PostgreSQL: pgsql/src/include/miscadmin.h,v 1.175 2005/02/26 18:43:34 tgl Exp $
1996-10-31 08:10:14 +01:00
*
* NOTES
* some of the information in this file should be moved to other files.
1996-10-31 08:10:14 +01:00
*
*-------------------------------------------------------------------------
*/
#ifndef MISCADMIN_H
#define MISCADMIN_H
#define PG_VERSIONSTR "postgres (PostgreSQL) " PG_VERSION "\n"
/*****************************************************************************
2001-03-22 05:01:46 +01:00
* System interrupt and critical section handling
*
* There are two types of interrupts that a running backend needs to accept
* without messing up its state: QueryCancel (SIGINT) and ProcDie (SIGTERM).
* In both cases, we need to be able to clean up the current transaction
* gracefully, so we can't respond to the interrupt instantaneously ---
* there's no guarantee that internal data structures would be self-consistent
2001-03-22 05:01:46 +01:00
* if the code is interrupted at an arbitrary instant. Instead, the signal
* handlers set flags that are checked periodically during execution.
*
* The CHECK_FOR_INTERRUPTS() macro is called at strategically located spots
* where it is normally safe to accept a cancel or die interrupt. In some
* cases, we invoke CHECK_FOR_INTERRUPTS() inside low-level subroutines that
* might sometimes be called in contexts that do *not* want to allow a cancel
* or die interrupt. The HOLD_INTERRUPTS() and RESUME_INTERRUPTS() macros
* allow code to ensure that no cancel or die interrupt will be accepted,
2001-03-22 05:01:46 +01:00
* even if CHECK_FOR_INTERRUPTS() gets called in a subroutine. The interrupt
* will be held off until CHECK_FOR_INTERRUPTS() is done outside any
* HOLD_INTERRUPTS() ... RESUME_INTERRUPTS() section.
*
* Special mechanisms are used to let an interrupt be accepted when we are
* waiting for a lock or when we are waiting for command input (but, of
* course, only if the interrupt holdoff counter is zero). See the
* related code for details.
*
* A related, but conceptually distinct, mechanism is the "critical section"
* mechanism. A critical section not only holds off cancel/die interrupts,
2003-07-27 19:10:07 +02:00
* but causes any ereport(ERROR) or ereport(FATAL) to become ereport(PANIC)
2003-08-04 02:43:34 +02:00
* --- that is, a system-wide reset is forced. Needless to say, only really
* *critical* code should be marked as a critical section! Currently, this
2003-07-27 19:10:07 +02:00
* mechanism is only used for XLOG-related code.
*
*****************************************************************************/
/* in globals.c */
/* these are marked volatile because they are set by signal handlers: */
extern DLLIMPORT volatile bool InterruptPending;
extern volatile bool QueryCancelPending;
extern volatile bool ProcDiePending;
2001-03-22 05:01:46 +01:00
/* these are marked volatile because they are examined by signal handlers: */
extern volatile bool ImmediateInterruptOK;
extern volatile uint32 InterruptHoldoffCount;
extern volatile uint32 CritSectionCount;
/* in tcop/postgres.c */
extern void ProcessInterrupts(void);
#ifndef WIN32
#define CHECK_FOR_INTERRUPTS() \
do { \
if (InterruptPending) \
ProcessInterrupts(); \
} while(0)
2004-08-29 07:07:03 +02:00
#else /* WIN32 */
#define CHECK_FOR_INTERRUPTS() \
do { \
if (WaitForSingleObjectEx(pgwin32_signal_event,0,TRUE) == WAIT_OBJECT_0) \
Here's an attempt at new socket and signal code for win32. It works on the principle of turning sockets into non-blocking, and then emulate blocking behaviour on top of that, while allowing signals to run. Signals are now implemented using an event instead of APCs, thus getting rid of the issue of APCs not being compatible with "old style" sockets functions. It also moves the win32 specific code away from pqsignal.h/c into port/win32, and also removes the "thread style workaround" of the APC issue previously in place. In order to make things work, a few things are also changed in pgstat.c: 1) There is now a separate pipe to the collector and the bufferer. This is required because the pipe will otherwise only be signalled in one of the processes when the postmaster goes down. The MS winsock code for select() must have some kind of workaround for this behaviour, but I have found no stable way of doing that. You really are not supposed to use the same socket from more than one process (unless you use WSADuplicateSocket(), in which case the docs specifically say that only one will be flagged). 2) The check for "postmaster death" is moved into a separate select() call after the main loop. The previous behaviour select():ed on the postmaster pipe, while later explicitly saying "we do NOT check for postmaster exit inside the loop". The issue was that the code relies on the same select() call seeing both the postmaster pipe *and* the pgstat pipe go away. This does not always happen, and it appears that useing WSAEventSelect() makes it even more common that it does not. Since it's only called when the process exits, I don't think using a separate select() call will have any significant impact on how the stats collector works. Magnus Hagander
2004-04-12 18:19:18 +02:00
pgwin32_dispatch_queued_signals(); \
if (InterruptPending) \
ProcessInterrupts(); \
} while(0)
2004-08-29 07:07:03 +02:00
#endif /* WIN32 */
2001-03-22 05:01:46 +01:00
#define HOLD_INTERRUPTS() (InterruptHoldoffCount++)
#define RESUME_INTERRUPTS() \
do { \
Assert(InterruptHoldoffCount > 0); \
InterruptHoldoffCount--; \
} while(0)
2001-03-22 05:01:46 +01:00
#define START_CRIT_SECTION() (CritSectionCount++)
#define END_CRIT_SECTION() \
do { \
Assert(CritSectionCount > 0); \
CritSectionCount--; \
} while(0)
1996-10-31 08:10:14 +01:00
/*****************************************************************************
* globals.h -- *
1996-10-31 08:10:14 +01:00
*****************************************************************************/
/*
* from utils/init/globals.c
*/
extern pid_t PostmasterPid;
extern bool IsPostmasterEnvironment;
extern bool IsUnderPostmaster;
extern bool ExitOnAnyError;
extern char *DataDir;
1996-10-31 08:10:14 +01:00
extern DLLIMPORT int NBuffers;
extern int MaxBackends;
extern DLLIMPORT int MyProcPid;
extern struct Port *MyProcPort;
extern long MyCancelKey;
extern char OutputFileName[];
extern DLLIMPORT char my_exec_path[];
extern char pkglib_path[];
2004-08-29 07:07:03 +02:00
#ifdef EXEC_BACKEND
extern char postgres_exec_path[];
#endif
1996-10-31 08:10:14 +01:00
/*
* done in storage/backendid.h for now.
*
* extern BackendId MyBackendId;
*/
extern DLLIMPORT Oid MyDatabaseId;
1996-10-31 08:10:14 +01:00
extern DLLIMPORT Oid MyDatabaseTableSpace;
/*
* Date/Time Configuration
*
* DateStyle defines the output formatting choice for date/time types:
* USE_POSTGRES_DATES specifies traditional Postgres format
* USE_ISO_DATES specifies ISO-compliant format
* USE_SQL_DATES specifies Oracle/Ingres-compliant format
* USE_GERMAN_DATES specifies German-style dd.mm/yyyy
*
* DateOrder defines the field order to be assumed when reading an
* ambiguous date (anything not in YYYY-MM-DD format, with a four-digit
* year field first, is taken to be ambiguous):
* DATEORDER_YMD specifies field order yy-mm-dd
* DATEORDER_DMY specifies field order dd-mm-yy ("European" convention)
* DATEORDER_MDY specifies field order mm-dd-yy ("US" convention)
*
* In the Postgres and SQL DateStyles, DateOrder also selects output field
* order: day comes before month in DMY style, else month comes before day.
*
* The user-visible "DateStyle" run-time parameter subsumes both of these.
*/
/* valid DateStyle values */
#define USE_POSTGRES_DATES 0
#define USE_ISO_DATES 1
#define USE_SQL_DATES 2
#define USE_GERMAN_DATES 3
/* valid DateOrder values */
#define DATEORDER_YMD 0
#define DATEORDER_DMY 1
#define DATEORDER_MDY 2
extern int DateStyle;
extern int DateOrder;
/*
* HasCTZSet is true if user has set timezone as a numeric offset from UTC.
* If so, CTimeZone is the timezone offset in seconds (using the Unix-ish
* sign convention, ie, positive offset is west of UTC, rather than the
* SQL-ish convention that positive is east of UTC).
*/
extern bool HasCTZSet;
extern int CTimeZone;
#define MAXTZLEN 10 /* max TZ name len, not counting tr. null */
extern bool enableFsync;
1999-05-25 18:15:34 +02:00
extern bool allowSystemTableMods;
extern DLLIMPORT int work_mem;
extern DLLIMPORT int maintenance_work_mem;
2004-02-06 20:36:18 +01:00
extern int VacuumCostPageHit;
extern int VacuumCostPageMiss;
extern int VacuumCostPageDirty;
extern int VacuumCostLimit;
extern int VacuumCostDelay;
extern int VacuumCostBalance;
2004-08-29 07:07:03 +02:00
extern bool VacuumCostActive;
/* in tcop/postgres.c */
extern void check_stack_depth(void);
1996-10-31 08:10:14 +01:00
/*****************************************************************************
* pdir.h -- *
* POSTGRES directory path definitions. *
1996-10-31 08:10:14 +01:00
*****************************************************************************/
extern char *DatabasePath;
1996-10-31 08:10:14 +01:00
/* now in utils/init/miscinit.c */
extern void SetDatabasePath(const char *path);
extern char *GetUserNameFromId(AclId userid);
extern AclId GetUserId(void);
extern void SetUserId(AclId userid);
extern AclId GetSessionUserId(void);
extern void SetSessionUserId(AclId userid);
2001-05-08 23:06:43 +02:00
extern void InitializeSessionUserId(const char *username);
extern void InitializeSessionUserIdStandalone(void);
extern void SetSessionAuthorization(AclId userid, bool is_superuser);
extern void SetDataDir(const char *dir);
extern char *make_absolute_path(const char *path);
/* in utils/misc/superuser.c */
extern bool superuser(void); /* current user is superuser */
2003-08-04 02:43:34 +02:00
extern bool superuser_arg(AclId userid); /* given user is superuser */
1996-10-31 08:10:14 +01:00
/*****************************************************************************
* pmod.h -- *
* POSTGRES processing mode definitions. *
1996-10-31 08:10:14 +01:00
*****************************************************************************/
1996-10-31 08:10:14 +01:00
/*
* Description:
* There are three processing modes in POSTGRES. They are
* BootstrapProcessing or "bootstrap," InitProcessing or
1996-10-31 08:10:14 +01:00
* "initialization," and NormalProcessing or "normal."
*
* The first two processing modes are used during special times. When the
1996-10-31 08:10:14 +01:00
* system state indicates bootstrap processing, transactions are all given
* transaction id "one" and are consequently guaranteed to commit. This mode
1996-10-31 08:10:14 +01:00
* is used during the initial generation of template databases.
*
* Initialization mode: used while starting a backend, until all normal
2001-03-22 05:01:46 +01:00
* initialization is complete. Some code behaves differently when executed
* in this mode to enable system bootstrapping.
*
* If a POSTGRES binary is in normal mode, then all code may be executed
* normally.
1996-10-31 08:10:14 +01:00
*/
typedef enum ProcessingMode
{
BootstrapProcessing, /* bootstrap creation of template database */
InitProcessing, /* initializing system */
NormalProcessing /* normal processing */
} ProcessingMode;
1996-10-31 08:10:14 +01:00
extern ProcessingMode Mode;
#define IsBootstrapProcessingMode() ((bool)(Mode == BootstrapProcessing))
#define IsInitProcessingMode() ((bool)(Mode == InitProcessing))
#define IsNormalProcessingMode() ((bool)(Mode == NormalProcessing))
#define SetProcessingMode(mode) \
do { \
AssertArg((mode) == BootstrapProcessing || \
(mode) == InitProcessing || \
(mode) == NormalProcessing); \
Mode = (mode); \
} while(0)
1996-10-31 08:10:14 +01:00
#define GetProcessingMode() Mode
/*****************************************************************************
* pinit.h -- *
* POSTGRES initialization and cleanup definitions. *
*****************************************************************************/
/* in utils/init/postinit.c */
extern bool InitPostgres(const char *dbname, const char *username);
extern void BaseInit(void);
/* in utils/init/miscinit.c */
extern void IgnoreSystemIndexes(bool mode);
extern bool IsIgnoringSystemIndexes(void);
extern void SetReindexProcessing(Oid heapOid, Oid indexOid);
extern void ResetReindexProcessing(void);
extern bool ReindexIsProcessingHeap(Oid heapOid);
extern bool ReindexIsProcessingIndex(Oid indexOid);
extern void CreateDataDirLockFile(const char *datadir, bool amPostmaster);
extern void CreateSocketLockFile(const char *socketfile, bool amPostmaster);
extern void TouchSocketLockFile(void);
extern void RecordSharedMemoryInLockFile(unsigned long id1,
2002-09-04 22:31:48 +02:00
unsigned long id2);
extern void ValidatePgVersion(const char *path);
extern void process_preload_libraries(char *preload_libraries_string);
#endif /* MISCADMIN_H */