miscadmin.h 10 KB
Newer Older
1 2
/*-------------------------------------------------------------------------
 *
3
 * miscadmin.h
4 5 6 7 8 9
 *	  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
10 11
 *
 *
12
 * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
Bruce Momjian's avatar
Add:  
Bruce Momjian committed
13
 * Portions Copyright (c) 1994, Regents of the University of California
14
 *
15
 * $Id: miscadmin.h,v 1.89 2001/08/15 18:42:15 momjian Exp $
16 17
 *
 * NOTES
18
 *	  some of the information in this file should be moved to
19
 *	  other files.
20 21 22 23 24 25
 *
 *-------------------------------------------------------------------------
 */
#ifndef MISCADMIN_H
#define MISCADMIN_H

Bruce Momjian's avatar
Bruce Momjian committed
26
#include "storage/ipc.h"
27

28
/*****************************************************************************
29
 *	  System interrupt and critical section handling
30 31 32 33 34 35
 *
 * 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
36
 * if the code is interrupted at an arbitrary instant.	Instead, the signal
37 38 39 40 41 42
 * 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
43 44
 * or die interrupt.  The HOLD_INTERRUPTS() and RESUME_INTERRUPTS() macros
 * allow code to ensure that no cancel or die interrupt will be accepted,
45
 * even if CHECK_FOR_INTERRUPTS() gets called in a subroutine.	The interrupt
46
 * will be held off until the last matching RESUME_INTERRUPTS() occurs.
47 48 49
 *
 * Special mechanisms are used to let an interrupt be accepted when we are
 * waiting for a lock or spinlock, and when we are waiting for command input
50
 * (but, of course, only if the interrupt holdoff counter is zero).  See the
51 52
 * related code for details.
 *
53 54 55 56 57 58 59
 * A related, but conceptually distinct, mechanism is the "critical section"
 * mechanism.  A critical section not only holds off cancel/die interrupts,
 * but causes any elog(ERROR) or elog(FATAL) to become elog(STOP) --- that is,
 * a system-wide reset is forced.  Needless to say, only really *critical*
 * code should be marked as a critical section!  Currently, this mechanism
 * is only used for XLOG-related code.
 *
60 61 62 63 64 65 66
 *****************************************************************************/

/* in globals.c */
/* these are marked volatile because they are set by signal handlers: */
extern volatile bool InterruptPending;
extern volatile bool QueryCancelPending;
extern volatile bool ProcDiePending;
67

68 69
/* these are marked volatile because they are examined by signal handlers: */
extern volatile bool ImmediateInterruptOK;
70
extern volatile uint32 InterruptHoldoffCount;
71 72 73 74 75 76 77 78 79 80 81
extern volatile uint32 CritSectionCount;

/* in postgres.c */
extern void ProcessInterrupts(void);

#define CHECK_FOR_INTERRUPTS() \
	do { \
		if (InterruptPending) \
			ProcessInterrupts(); \
	} while(0)

82
#define HOLD_INTERRUPTS()  (InterruptHoldoffCount++)
83 84 85 86 87 88 89 90 91

#define RESUME_INTERRUPTS() \
	do { \
		Assert(InterruptHoldoffCount > 0); \
		InterruptHoldoffCount--; \
		if (InterruptPending) \
			ProcessInterrupts(); \
	} while(0)

92
#define START_CRIT_SECTION()  (CritSectionCount++)
93 94 95 96 97

#define END_CRIT_SECTION() \
	do { \
		Assert(CritSectionCount > 0); \
		CritSectionCount--; \
98
		if (InterruptPending) \
99 100 101 102
			ProcessInterrupts(); \
	} while(0)


103
/*****************************************************************************
104
 *	  globals.h --															 *
105 106 107 108 109
 *****************************************************************************/

/*
 * from postmaster/postmaster.c
 */
110
extern int	PostmasterMain(int argc, char *argv[]);
111
extern void ClosePostmasterPorts(bool pgstat_too);
112 113 114 115

/*
 * from utils/init/globals.c
 */
116
extern bool Noversion;
117
extern char *DataDir;
118

119
extern DLLIMPORT int	MyProcPid;
120 121
extern struct Port *MyProcPort;
extern long MyCancelKey;
122

123
extern char OutputFileName[];
124 125 126 127 128 129

/*
 * done in storage/backendid.h for now.
 *
 * extern BackendId    MyBackendId;
 */
130
extern DLLIMPORT Oid	MyDatabaseId;
131

132
extern bool IsUnderPostmaster;
133

134
extern int	DebugLvl;
135

136
/* Date/Time Configuration
137 138
 *
 * Constants to pass info from runtime environment:
139 140 141
 *	USE_POSTGRES_DATES specifies traditional postgres format for output.
 *	USE_ISO_DATES specifies ISO-compliant format for output.
 *	USE_SQL_DATES specified Oracle/Ingres-compliant format for output.
142
 *	USE_GERMAN_DATES specifies German-style dd.mm/yyyy date format.
143 144
 *
 * DateStyle specifies preference for date formatting for output.
145
 * EuroDates if client prefers dates interpreted and written w/European conventions.
146 147 148
 *
 * HasCTZSet if client timezone is specified by client.
 * CDayLight is the apparent daylight savings time status.
149 150 151 152
 * CTimeZone is the timezone offset in seconds.
 * CTZName is the timezone label.
 */

153
#define MAXTZLEN		10		/* max TZ name len, not counting tr. null */
154

155 156 157
#define USE_POSTGRES_DATES		0
#define USE_ISO_DATES			1
#define USE_SQL_DATES			2
158
#define USE_GERMAN_DATES		3
159

160 161 162 163 164 165
extern int	DateStyle;
extern bool EuroDates;
extern bool HasCTZSet;
extern bool CDayLight;
extern int	CTimeZone;
extern char CTZName[];
166

167 168
extern char FloatFormat[];
extern char DateFormat[];
169

170
extern bool enableFsync;
Bruce Momjian's avatar
Bruce Momjian committed
171
extern bool allowSystemTableMods;
172
extern int	SortMem;
173

174 175 176 177
/*
 *	A few postmaster startup options are exported here so the
 *  configuration file processor can access them.
 */
178 179

extern bool NetServer;
180
extern bool EnableSSL;
181
extern bool SilentMode;
182 183 184 185
extern int	MaxBackends;
extern int	NBuffers;
extern int	PostPortNumber;
extern int	Unix_socket_permissions;
186 187
extern char *Unix_socket_group;
extern char *UnixSocketDir;
188
extern char *VirtualHost;
189

190

191
/*****************************************************************************
192 193
 *	  pdir.h --																 *
 *			POSTGRES directory path definitions.							 *
194 195
 *****************************************************************************/

196 197 198
extern char *DatabaseName;
extern char *DatabasePath;

199
/* in utils/misc/database.c */
200 201
extern void GetRawDatabaseInfo(const char *name, Oid *db_id, char *path);
extern char *ExpandDatabasePath(const char *path);
202

203
/* now in utils/init/miscinit.c */
204 205
extern void SetDatabaseName(const char *name);
extern void SetDatabasePath(const char *path);
206

207 208
extern char *GetUserName(Oid userid);

209
extern Oid	GetUserId(void);
210
extern void SetUserId(Oid userid);
211
extern Oid	GetSessionUserId(void);
212
extern void SetSessionUserId(Oid userid);
213 214
extern void InitializeSessionUserId(const char *username);
extern void SetSessionAuthorization(const char *username);
215

216 217
extern void SetDataDir(const char *dir);

218 219
extern int FindExec(char *full_path, const char *argv0,
		 const char *binary_name);
220
extern int	CheckPathAccess(char *path, char *name, int open_mode);
221

222
#ifdef CYR_RECODE
223 224
extern void GetCharSetByHost(char *TableName, int host, const char *DataDir);
extern void SetCharSet(void);
225
extern char *convertstr(unsigned char *buff, int len, int dest);
226 227
#endif

228 229 230 231 232
/* in utils/misc/superuser.c */
extern bool superuser(void);	/* current user is superuser */
extern bool is_dbadmin(Oid dbid); /* current user is owner of database */


233
/*****************************************************************************
234 235
 *	  pmod.h --																 *
 *			POSTGRES processing mode definitions.							 *
236 237 238
 *****************************************************************************/
/*
 * Description:
239
 *		There are three processing modes in POSTGRES.  They are
240
 * BootstrapProcessing or "bootstrap," InitProcessing or
241 242
 * "initialization," and NormalProcessing or "normal."
 *
243
 * The first two processing modes are used during special times. When the
244
 * system state indicates bootstrap processing, transactions are all given
245
 * transaction id "one" and are consequently guaranteed to commit. This mode
246 247
 * is used during the initial generation of template databases.
 *
248
 * Initialization mode: used while starting a backend, until all normal
249
 * initialization is complete.	Some code behaves differently when executed
250
 * in this mode to enable system bootstrapping.
251 252
 *
 * If a POSTGRES binary is in normal mode, then all code may be executed
253
 * normally.
254 255
 */

256 257 258 259 260
typedef enum ProcessingMode
{
	BootstrapProcessing,		/* bootstrap creation of template database */
	InitProcessing,				/* initializing system */
	NormalProcessing			/* normal processing */
261
} ProcessingMode;
262 263 264


/*****************************************************************************
265 266
 *	  pinit.h --															 *
 *			POSTGRES initialization and cleanup definitions.				 *
267 268 269
 *****************************************************************************/

/* in utils/init/postinit.c */
270
extern int	lockingOff;
271

272
extern void InitPostgres(const char *dbname, const char *username);
273
extern void BaseInit(void);
274 275 276 277 278 279 280 281 282

/* processing mode support stuff */
extern ProcessingMode Mode;

#define IsBootstrapProcessingMode() ((bool)(Mode == BootstrapProcessing))
#define IsInitProcessingMode() ((bool)(Mode == InitProcessing))
#define IsNormalProcessingMode() ((bool)(Mode == NormalProcessing))

#define SetProcessingMode(mode) \
283
	do { \
284 285 286 287
		AssertArg((mode) == BootstrapProcessing || \
				  (mode) == InitProcessing || \
				  (mode) == NormalProcessing); \
		Mode = (mode); \
288
	} while(0)
289

290
#define GetProcessingMode() Mode
291

292 293
extern bool CreateDataDirLockFile(const char *datadir, bool amPostmaster);
extern bool CreateSocketLockFile(const char *socketfile, bool amPostmaster);
294
extern void TouchSocketLockFile(void);
Tom Lane's avatar
Tom Lane committed
295
extern void RecordSharedMemoryInLockFile(IpcMemoryKey shmKey,
296
							 IpcMemoryId shmId);
297 298 299

extern void ValidatePgVersion(const char *path);

300 301 302 303 304
/* these externs do not belong here... */
extern void IgnoreSystemIndexes(bool mode);
extern bool IsIgnoringSystemIndexes(void);
extern bool IsCacheInitialized(void);

305
#endif	 /* MISCADMIN_H */