PostgreSQL Source Code  git master
postinit.c File Reference
#include "postgres.h"
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
#include "access/genam.h"
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/session.h"
#include "access/tableam.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "catalog/namespace.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_database.h"
#include "catalog/pg_db_role_setting.h"
#include "catalog/pg_tablespace.h"
#include "libpq/auth.h"
#include "libpq/libpq-be.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/postmaster.h"
#include "replication/slot.h"
#include "replication/slotsync.h"
#include "replication/walsender.h"
#include "storage/bufmgr.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/lmgr.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/procsignal.h"
#include "storage/sinvaladt.h"
#include "storage/smgr.h"
#include "storage/sync.h"
#include "tcop/tcopprot.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/guc_hooks.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/portal.h"
#include "utils/ps_status.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/timeout.h"
Include dependency graph for postinit.c:

Go to the source code of this file.

Functions

static HeapTuple GetDatabaseTuple (const char *dbname)
 
static HeapTuple GetDatabaseTupleByOid (Oid dboid)
 
static void PerformAuthentication (Port *port)
 
static void CheckMyDatabase (const char *name, bool am_superuser, bool override_allow_connections)
 
static void ShutdownPostgres (int code, Datum arg)
 
static void StatementTimeoutHandler (void)
 
static void LockTimeoutHandler (void)
 
static void IdleInTransactionSessionTimeoutHandler (void)
 
static void TransactionTimeoutHandler (void)
 
static void IdleSessionTimeoutHandler (void)
 
static void IdleStatsUpdateTimeoutHandler (void)
 
static void ClientCheckTimeoutHandler (void)
 
static bool ThereIsAtLeastOneRole (void)
 
static void process_startup_options (Port *port, bool am_superuser)
 
static void process_settings (Oid databaseid, Oid roleid)
 
void pg_split_opts (char **argv, int *argcp, const char *optstr)
 
void InitializeMaxBackends (void)
 
bool check_max_connections (int *newval, void **extra, GucSource source)
 
bool check_autovacuum_max_workers (int *newval, void **extra, GucSource source)
 
bool check_max_worker_processes (int *newval, void **extra, GucSource source)
 
bool check_max_wal_senders (int *newval, void **extra, GucSource source)
 
void BaseInit (void)
 
void InitPostgres (const char *in_dbname, Oid dboid, const char *username, Oid useroid, bits32 flags, char *out_dbname)
 

Function Documentation

◆ BaseInit()

void BaseInit ( void  )

Definition at line 645 of file postinit.c.

646 {
647  Assert(MyProc != NULL);
648 
649  /*
650  * Initialize our input/output/debugging file descriptors.
651  */
652  DebugFileOpen();
653 
654  /*
655  * Initialize file access. Done early so other subsystems can access
656  * files.
657  */
658  InitFileAccess();
659 
660  /*
661  * Initialize statistics reporting. This needs to happen early to ensure
662  * that pgstat's shutdown callback runs after the shutdown callbacks of
663  * all subsystems that can produce stats (like e.g. transaction commits
664  * can).
665  */
667 
668  /* Do local initialization of storage and buffer managers */
669  InitSync();
670  smgrinit();
672 
673  /*
674  * Initialize temporary file access after pgstat, so that the temporary
675  * file shutdown hook can report temporary file statistics.
676  */
678 
679  /*
680  * Initialize local buffers for WAL record construction, in case we ever
681  * try to insert XLOG.
682  */
683  InitXLogInsert();
684 
685  /*
686  * Initialize replication slots after pgstat. The exit hook might need to
687  * drop ephemeral slots, which in turn triggers stats reporting.
688  */
690 }
void InitBufferPoolAccess(void)
Definition: bufmgr.c:3519
#define Assert(condition)
Definition: c.h:858
void DebugFileOpen(void)
Definition: elog.c:2075
void InitFileAccess(void)
Definition: fd.c:903
void InitTemporaryFileAccess(void)
Definition: fd.c:933
void pgstat_initialize(void)
Definition: pgstat.c:537
void ReplicationSlotInitialize(void)
Definition: slot.c:224
void smgrinit(void)
Definition: smgr.c:154
PGPROC * MyProc
Definition: proc.c:66
void InitSync(void)
Definition: sync.c:124
void InitXLogInsert(void)
Definition: xloginsert.c:1348

References Assert, DebugFileOpen(), InitBufferPoolAccess(), InitFileAccess(), InitSync(), InitTemporaryFileAccess(), InitXLogInsert(), MyProc, pgstat_initialize(), ReplicationSlotInitialize(), and smgrinit().

Referenced by AutoVacWorkerMain(), AuxiliaryProcessMainCommon(), BackgroundWorkerMain(), BootstrapModeMain(), PostgresMain(), and ReplSlotSyncWorkerMain().

◆ check_autovacuum_max_workers()

bool check_autovacuum_max_workers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 604 of file postinit.c.

605 {
606  if (MaxConnections + *newval + 1 +
608  return false;
609  return true;
610 }
int MaxConnections
Definition: globals.c:140
int max_worker_processes
Definition: globals.c:141
#define newval
#define MAX_BACKENDS
Definition: postmaster.h:95
int max_wal_senders
Definition: walsender.c:121

References MAX_BACKENDS, max_wal_senders, max_worker_processes, MaxConnections, and newval.

◆ check_max_connections()

bool check_max_connections ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 592 of file postinit.c.

593 {
594  if (*newval + autovacuum_max_workers + 1 +
596  return false;
597  return true;
598 }
int autovacuum_max_workers
Definition: autovacuum.c:117

References autovacuum_max_workers, MAX_BACKENDS, max_wal_senders, max_worker_processes, and newval.

◆ check_max_wal_senders()

bool check_max_wal_senders ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 628 of file postinit.c.

629 {
632  return false;
633  return true;
634 }

References autovacuum_max_workers, MAX_BACKENDS, max_worker_processes, MaxConnections, and newval.

◆ check_max_worker_processes()

bool check_max_worker_processes ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 616 of file postinit.c.

617 {
620  return false;
621  return true;
622 }

References autovacuum_max_workers, MAX_BACKENDS, max_wal_senders, MaxConnections, and newval.

◆ CheckMyDatabase()

static void CheckMyDatabase ( const char *  name,
bool  am_superuser,
bool  override_allow_connections 
)
static

Definition at line 313 of file postinit.c.

314 {
315  HeapTuple tup;
316  Form_pg_database dbform;
317  Datum datum;
318  bool isnull;
319  char *collate;
320  char *ctype;
321  char *datlocale;
322 
323  /* Fetch our pg_database row normally, via syscache */
324  tup = SearchSysCache1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));
325  if (!HeapTupleIsValid(tup))
326  elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);
327  dbform = (Form_pg_database) GETSTRUCT(tup);
328 
329  /* This recheck is strictly paranoia */
330  if (strcmp(name, NameStr(dbform->datname)) != 0)
331  ereport(FATAL,
332  (errcode(ERRCODE_UNDEFINED_DATABASE),
333  errmsg("database \"%s\" has disappeared from pg_database",
334  name),
335  errdetail("Database OID %u now seems to belong to \"%s\".",
336  MyDatabaseId, NameStr(dbform->datname))));
337 
338  /*
339  * Check permissions to connect to the database.
340  *
341  * These checks are not enforced when in standalone mode, so that there is
342  * a way to recover from disabling all access to all databases, for
343  * example "UPDATE pg_database SET datallowconn = false;".
344  *
345  * We do not enforce them for autovacuum worker processes either.
346  */
348  {
349  /*
350  * Check that the database is currently allowing connections.
351  */
352  if (!dbform->datallowconn && !override_allow_connections)
353  ereport(FATAL,
354  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
355  errmsg("database \"%s\" is not currently accepting connections",
356  name)));
357 
358  /*
359  * Check privilege to connect to the database. (The am_superuser test
360  * is redundant, but since we have the flag, might as well check it
361  * and save a few cycles.)
362  */
363  if (!am_superuser &&
364  object_aclcheck(DatabaseRelationId, MyDatabaseId, GetUserId(),
366  ereport(FATAL,
367  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
368  errmsg("permission denied for database \"%s\"", name),
369  errdetail("User does not have CONNECT privilege.")));
370 
371  /*
372  * Check connection limit for this database.
373  *
374  * There is a race condition here --- we create our PGPROC before
375  * checking for other PGPROCs. If two backends did this at about the
376  * same time, they might both think they were over the limit, while
377  * ideally one should succeed and one fail. Getting that to work
378  * exactly seems more trouble than it is worth, however; instead we
379  * just document that the connection limit is approximate.
380  */
381  if (dbform->datconnlimit >= 0 &&
382  !am_superuser &&
383  CountDBConnections(MyDatabaseId) > dbform->datconnlimit)
384  ereport(FATAL,
385  (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
386  errmsg("too many connections for database \"%s\"",
387  name)));
388  }
389 
390  /*
391  * OK, we're golden. Next to-do item is to save the encoding info out of
392  * the pg_database tuple.
393  */
394  SetDatabaseEncoding(dbform->encoding);
395  /* Record it as a GUC internal option, too */
396  SetConfigOption("server_encoding", GetDatabaseEncodingName(),
398  /* If we have no other source of client_encoding, use server encoding */
399  SetConfigOption("client_encoding", GetDatabaseEncodingName(),
401 
402  /* assign locale variables */
403  datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datcollate);
404  collate = TextDatumGetCString(datum);
405  datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datctype);
406  ctype = TextDatumGetCString(datum);
407 
408  if (pg_perm_setlocale(LC_COLLATE, collate) == NULL)
409  ereport(FATAL,
410  (errmsg("database locale is incompatible with operating system"),
411  errdetail("The database was initialized with LC_COLLATE \"%s\", "
412  " which is not recognized by setlocale().", collate),
413  errhint("Recreate the database with another locale or install the missing locale.")));
414 
415  if (pg_perm_setlocale(LC_CTYPE, ctype) == NULL)
416  ereport(FATAL,
417  (errmsg("database locale is incompatible with operating system"),
418  errdetail("The database was initialized with LC_CTYPE \"%s\", "
419  " which is not recognized by setlocale().", ctype),
420  errhint("Recreate the database with another locale or install the missing locale.")));
421 
422  if (strcmp(ctype, "C") == 0 ||
423  strcmp(ctype, "POSIX") == 0)
424  database_ctype_is_c = true;
425 
426  if (dbform->datlocprovider == COLLPROVIDER_BUILTIN)
427  {
428  datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datlocale);
430 
431  builtin_validate_locale(dbform->encoding, datlocale);
432 
435  }
436  else if (dbform->datlocprovider == COLLPROVIDER_ICU)
437  {
438  char *icurules;
439 
440  datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datlocale);
442 
443  datum = SysCacheGetAttr(DATABASEOID, tup, Anum_pg_database_daticurules, &isnull);
444  if (!isnull)
445  icurules = TextDatumGetCString(datum);
446  else
447  icurules = NULL;
448 
450  }
451  else
452  datlocale = NULL;
453 
454  default_locale.provider = dbform->datlocprovider;
455 
456  /*
457  * Default locale is currently always deterministic. Nondeterministic
458  * locales currently don't support pattern matching, which would break a
459  * lot of things if applied globally.
460  */
462 
463  /*
464  * Check collation version. See similar code in
465  * pg_newlocale_from_collation(). Note that here we warn instead of error
466  * in any case, so that we don't prevent connecting.
467  */
468  datum = SysCacheGetAttr(DATABASEOID, tup, Anum_pg_database_datcollversion,
469  &isnull);
470  if (!isnull)
471  {
472  char *actual_versionstr;
473  char *collversionstr;
474  char *locale;
475 
476  collversionstr = TextDatumGetCString(datum);
477 
478  if (dbform->datlocprovider == COLLPROVIDER_LIBC)
479  locale = collate;
480  else
481  locale = datlocale;
482 
483  actual_versionstr = get_collation_actual_version(dbform->datlocprovider, locale);
484  if (!actual_versionstr)
485  /* should not happen */
486  elog(WARNING,
487  "database \"%s\" has no actual collation version, but a version was recorded",
488  name);
489  else if (strcmp(actual_versionstr, collversionstr) != 0)
491  (errmsg("database \"%s\" has a collation version mismatch",
492  name),
493  errdetail("The database was created using collation version %s, "
494  "but the operating system provides version %s.",
495  collversionstr, actual_versionstr),
496  errhint("Rebuild all objects in this database that use the default collation and run "
497  "ALTER DATABASE %s REFRESH COLLATION VERSION, "
498  "or build PostgreSQL with the right library version.",
500  }
501 
502  ReleaseSysCache(tup);
503 }
@ ACLCHECK_OK
Definition: acl.h:183
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3890
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define NameStr(name)
Definition: c.h:746
int errdetail(const char *fmt,...)
Definition: elog.c:1203
int errhint(const char *fmt,...)
Definition: elog.c:1317
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define FATAL
Definition: elog.h:41
#define WARNING
Definition: elog.h:36
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
bool IsUnderPostmaster
Definition: globals.c:117
Oid MyDatabaseId
Definition: globals.c:91
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4285
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
@ PGC_INTERNAL
Definition: guc.h:69
@ PGC_BACKEND
Definition: guc.h:73
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
static char * datlocale
Definition: initdb.c:149
static char * locale
Definition: initdb.c:140
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1267
void SetDatabaseEncoding(int encoding)
Definition: mbutils.c:1161
MemoryContext TopMemoryContext
Definition: mcxt.c:149
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1682
#define AmAutoVacuumWorkerProcess()
Definition: miscadmin.h:375
Oid GetUserId(void)
Definition: miscinit.c:514
#define ACL_CONNECT
Definition: parsenodes.h:87
FormData_pg_database * Form_pg_database
Definition: pg_database.h:96
void make_icu_collator(const char *iculocstr, const char *icurules, struct pg_locale_struct *resultp)
Definition: pg_locale.c:1449
struct pg_locale_struct default_locale
Definition: pg_locale.c:1446
bool database_ctype_is_c
Definition: pg_locale.c:117
char * get_collation_actual_version(char collprovider, const char *collcollate)
Definition: pg_locale.c:1729
char * pg_perm_setlocale(int category, const char *locale)
Definition: pg_locale.c:212
const char * builtin_validate_locale(int encoding, const char *locale)
Definition: pg_locale.c:2545
uintptr_t Datum
Definition: postgres.h:64
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
int CountDBConnections(Oid databaseid)
Definition: procarray.c:3616
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:12596
struct pg_locale_struct::@151::@152 builtin
union pg_locale_struct::@151 info
bool deterministic
Definition: pg_locale.h:76
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:479
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:510
const char * name

References ACL_CONNECT, ACLCHECK_OK, AmAutoVacuumWorkerProcess, pg_locale_struct::builtin, builtin_validate_locale(), CountDBConnections(), database_ctype_is_c, datlocale, default_locale, pg_locale_struct::deterministic, elog, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, FATAL, get_collation_actual_version(), GetDatabaseEncodingName(), GETSTRUCT, GetUserId(), HeapTupleIsValid, pg_locale_struct::info, IsUnderPostmaster, locale, make_icu_collator(), MemoryContextStrdup(), MyDatabaseId, name, NameStr, object_aclcheck(), ObjectIdGetDatum(), pg_perm_setlocale(), PGC_BACKEND, PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT, pg_locale_struct::provider, quote_identifier(), ReleaseSysCache(), SearchSysCache1(), SetConfigOption(), SetDatabaseEncoding(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), TextDatumGetCString, TopMemoryContext, and WARNING.

Referenced by InitPostgres().

◆ ClientCheckTimeoutHandler()

static void ClientCheckTimeoutHandler ( void  )
static

Definition at line 1441 of file postinit.c.

1442 {
1444  InterruptPending = true;
1445  SetLatch(MyLatch);
1446 }
volatile sig_atomic_t InterruptPending
Definition: globals.c:30
struct Latch * MyLatch
Definition: globals.c:60
volatile sig_atomic_t CheckClientConnectionPending
Definition: globals.c:33
void SetLatch(Latch *latch)
Definition: latch.c:632

References CheckClientConnectionPending, InterruptPending, MyLatch, and SetLatch().

Referenced by InitPostgres().

◆ GetDatabaseTuple()

static HeapTuple GetDatabaseTuple ( const char *  dbname)
static

Definition at line 101 of file postinit.c.

102 {
103  HeapTuple tuple;
104  Relation relation;
105  SysScanDesc scan;
106  ScanKeyData key[1];
107 
108  /*
109  * form a scan key
110  */
111  ScanKeyInit(&key[0],
112  Anum_pg_database_datname,
113  BTEqualStrategyNumber, F_NAMEEQ,
115 
116  /*
117  * Open pg_database and fetch a tuple. Force heap scan if we haven't yet
118  * built the critical shared relcache entries (i.e., we're starting up
119  * without a shared relcache cache file).
120  */
121  relation = table_open(DatabaseRelationId, AccessShareLock);
122  scan = systable_beginscan(relation, DatabaseNameIndexId,
124  NULL,
125  1, key);
126 
127  tuple = systable_getnext(scan);
128 
129  /* Must copy tuple before releasing buffer */
130  if (HeapTupleIsValid(tuple))
131  tuple = heap_copytuple(tuple);
132 
133  /* all done */
134  systable_endscan(scan);
135  table_close(relation, AccessShareLock);
136 
137  return tuple;
138 }
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:596
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:503
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:384
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:776
#define AccessShareLock
Definition: lockdefs.h:36
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
bool criticalSharedRelcachesBuilt
Definition: relcache.c:146
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
#define BTEqualStrategyNumber
Definition: stratnum.h:31
char * dbname
Definition: streamutil.c:52
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40

References AccessShareLock, BTEqualStrategyNumber, criticalSharedRelcachesBuilt, CStringGetDatum(), dbname, heap_copytuple(), HeapTupleIsValid, sort-test::key, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by InitPostgres().

◆ GetDatabaseTupleByOid()

static HeapTuple GetDatabaseTupleByOid ( Oid  dboid)
static

Definition at line 144 of file postinit.c.

145 {
146  HeapTuple tuple;
147  Relation relation;
148  SysScanDesc scan;
149  ScanKeyData key[1];
150 
151  /*
152  * form a scan key
153  */
154  ScanKeyInit(&key[0],
155  Anum_pg_database_oid,
156  BTEqualStrategyNumber, F_OIDEQ,
157  ObjectIdGetDatum(dboid));
158 
159  /*
160  * Open pg_database and fetch a tuple. Force heap scan if we haven't yet
161  * built the critical shared relcache entries (i.e., we're starting up
162  * without a shared relcache cache file).
163  */
164  relation = table_open(DatabaseRelationId, AccessShareLock);
165  scan = systable_beginscan(relation, DatabaseOidIndexId,
167  NULL,
168  1, key);
169 
170  tuple = systable_getnext(scan);
171 
172  /* Must copy tuple before releasing buffer */
173  if (HeapTupleIsValid(tuple))
174  tuple = heap_copytuple(tuple);
175 
176  /* all done */
177  systable_endscan(scan);
178  table_close(relation, AccessShareLock);
179 
180  return tuple;
181 }

References AccessShareLock, BTEqualStrategyNumber, criticalSharedRelcachesBuilt, heap_copytuple(), HeapTupleIsValid, sort-test::key, ObjectIdGetDatum(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by InitPostgres().

◆ IdleInTransactionSessionTimeoutHandler()

static void IdleInTransactionSessionTimeoutHandler ( void  )
static

Definition at line 1417 of file postinit.c.

1418 {
1420  InterruptPending = true;
1421  SetLatch(MyLatch);
1422 }
volatile sig_atomic_t IdleInTransactionSessionTimeoutPending
Definition: globals.c:35

References IdleInTransactionSessionTimeoutPending, InterruptPending, MyLatch, and SetLatch().

Referenced by InitPostgres().

◆ IdleSessionTimeoutHandler()

static void IdleSessionTimeoutHandler ( void  )
static

Definition at line 1425 of file postinit.c.

1426 {
1428  InterruptPending = true;
1429  SetLatch(MyLatch);
1430 }
volatile sig_atomic_t IdleSessionTimeoutPending
Definition: globals.c:37

References IdleSessionTimeoutPending, InterruptPending, MyLatch, and SetLatch().

Referenced by InitPostgres().

◆ IdleStatsUpdateTimeoutHandler()

static void IdleStatsUpdateTimeoutHandler ( void  )
static

Definition at line 1433 of file postinit.c.

1434 {
1436  InterruptPending = true;
1437  SetLatch(MyLatch);
1438 }
volatile sig_atomic_t IdleStatsUpdateTimeoutPending
Definition: globals.c:40

References IdleStatsUpdateTimeoutPending, InterruptPending, MyLatch, and SetLatch().

Referenced by InitPostgres().

◆ InitializeMaxBackends()

void InitializeMaxBackends ( void  )

Definition at line 575 of file postinit.c.

576 {
577  Assert(MaxBackends == 0);
578 
579  /* the extra unit accounts for the autovacuum launcher */
582 
583  /* internal error because the values were all checked previously */
585  elog(ERROR, "too many backends configured");
586 }
int MaxBackends
Definition: globals.c:143

References Assert, autovacuum_max_workers, elog, ERROR, MAX_BACKENDS, max_wal_senders, max_worker_processes, MaxBackends, and MaxConnections.

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ InitPostgres()

void InitPostgres ( const char *  in_dbname,
Oid  dboid,
const char *  username,
Oid  useroid,
bits32  flags,
char *  out_dbname 
)

Definition at line 736 of file postinit.c.

740 {
741  bool bootstrap = IsBootstrapProcessingMode();
742  bool am_superuser;
743  char *fullpath;
744  char dbname[NAMEDATALEN];
745  int nfree = 0;
746 
747  elog(DEBUG3, "InitPostgres");
748 
749  /*
750  * Add my PGPROC struct to the ProcArray.
751  *
752  * Once I have done this, I am visible to other backends!
753  */
755 
756  /*
757  * Initialize my entry in the shared-invalidation manager's array of
758  * per-backend data.
759  */
760  SharedInvalBackendInit(false);
761 
762  ProcSignalInit();
763 
764  /*
765  * Also set up timeout handlers needed for backend operation. We need
766  * these in every case except bootstrap.
767  */
768  if (!bootstrap)
769  {
780  }
781 
782  /*
783  * If this is either a bootstrap process or a standalone backend, start up
784  * the XLOG machinery, and register to have it closed down at exit. In
785  * other cases, the startup process is responsible for starting up the
786  * XLOG machinery, and the checkpointer for closing it down.
787  */
788  if (!IsUnderPostmaster)
789  {
790  /*
791  * We don't yet have an aux-process resource owner, but StartupXLOG
792  * and ShutdownXLOG will need one. Hence, create said resource owner
793  * (and register a callback to clean it up after ShutdownXLOG runs).
794  */
796 
797  StartupXLOG();
798  /* Release (and warn about) any buffer pins leaked in StartupXLOG */
800  /* Reset CurrentResourceOwner to nothing for the moment */
801  CurrentResourceOwner = NULL;
802 
803  /*
804  * Use before_shmem_exit() so that ShutdownXLOG() can rely on DSM
805  * segments etc to work (which in turn is required for pgstats).
806  */
809  }
810 
811  /*
812  * Initialize the relation cache and the system catalog caches. Note that
813  * no catalog access happens here; we only set up the hashtable structure.
814  * We must do this before starting a transaction because transaction abort
815  * would try to touch these hashtables.
816  */
819  InitPlanCache();
820 
821  /* Initialize portal manager */
823 
824  /* Initialize status reporting */
825  pgstat_beinit();
826 
827  /*
828  * Load relcache entries for the shared system catalogs. This must create
829  * at least entries for pg_database and catalogs used for authentication.
830  */
832 
833  /*
834  * Set up process-exit callback to do pre-shutdown cleanup. This is the
835  * one of the first before_shmem_exit callbacks we register; thus, this
836  * will be one the last things we do before low-level modules like the
837  * buffer manager begin to close down. We need to have this in place
838  * before we begin our first transaction --- if we fail during the
839  * initialization transaction, as is entirely possible, we need the
840  * AbortTransaction call to clean up.
841  */
843 
844  /* The autovacuum launcher is done here */
846  {
847  /* report this backend in the PgBackendStatus array */
848  pgstat_bestart();
849 
850  return;
851  }
852 
853  /*
854  * Start a new transaction here before first access to db, and get a
855  * snapshot. We don't have a use for the snapshot itself, but we're
856  * interested in the secondary effect that it sets RecentGlobalXmin. (This
857  * is critical for anything that reads heap pages, because HOT may decide
858  * to prune them even if the process doesn't attempt to modify any
859  * tuples.)
860  *
861  * FIXME: This comment is inaccurate / the code buggy. A snapshot that is
862  * not pushed/active does not reliably prevent HOT pruning (->xmin could
863  * e.g. be cleared when cache invalidations are processed).
864  */
865  if (!bootstrap)
866  {
867  /* statement_timestamp must be set for timeouts to work correctly */
870 
871  /*
872  * transaction_isolation will have been set to the default by the
873  * above. If the default is "serializable", and we are in hot
874  * standby, we will fail if we don't change it to something lower.
875  * Fortunately, "read committed" is plenty good enough.
876  */
878 
879  (void) GetTransactionSnapshot();
880  }
881 
882  /*
883  * Perform client authentication if necessary, then figure out our
884  * postgres user ID, and see if we are a superuser.
885  *
886  * In standalone mode, autovacuum worker processes and slot sync worker
887  * process, we use a fixed ID, otherwise we figure it out from the
888  * authenticated user name.
889  */
891  {
893  am_superuser = true;
894  }
895  else if (!IsUnderPostmaster)
896  {
898  am_superuser = true;
899  if (!ThereIsAtLeastOneRole())
901  (errcode(ERRCODE_UNDEFINED_OBJECT),
902  errmsg("no roles are defined in this database system"),
903  errhint("You should immediately run CREATE USER \"%s\" SUPERUSER;.",
904  username != NULL ? username : "postgres")));
905  }
906  else if (AmBackgroundWorkerProcess())
907  {
908  if (username == NULL && !OidIsValid(useroid))
909  {
911  am_superuser = true;
912  }
913  else
914  {
916  (flags & INIT_PG_OVERRIDE_ROLE_LOGIN) != 0);
917  am_superuser = superuser();
918  }
919  }
920  else
921  {
922  /* normal multiuser case */
923  Assert(MyProcPort != NULL);
925  InitializeSessionUserId(username, useroid, false);
926  /* ensure that auth_method is actually valid, aka authn_id is not NULL */
930  am_superuser = superuser();
931  }
932 
933  /*
934  * Binary upgrades only allowed super-user connections
935  */
936  if (IsBinaryUpgrade && !am_superuser)
937  {
938  ereport(FATAL,
939  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
940  errmsg("must be superuser to connect in binary upgrade mode")));
941  }
942 
943  /*
944  * The last few connection slots are reserved for superusers and roles
945  * with privileges of pg_use_reserved_connections. Replication
946  * connections are drawn from slots reserved with max_wal_senders and are
947  * not limited by max_connections, superuser_reserved_connections, or
948  * reserved_connections.
949  *
950  * Note: At this point, the new backend has already claimed a proc struct,
951  * so we must check whether the number of free slots is strictly less than
952  * the reserved connection limits.
953  */
954  if (!am_superuser && !am_walsender &&
957  {
958  if (nfree < SuperuserReservedConnections)
959  ereport(FATAL,
960  (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
961  errmsg("remaining connection slots are reserved for roles with the %s attribute",
962  "SUPERUSER")));
963 
964  if (!has_privs_of_role(GetUserId(), ROLE_PG_USE_RESERVED_CONNECTIONS))
965  ereport(FATAL,
966  (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
967  errmsg("remaining connection slots are reserved for roles with privileges of the \"%s\" role",
968  "pg_use_reserved_connections")));
969  }
970 
971  /* Check replication permissions needed for walsender processes. */
972  if (am_walsender)
973  {
974  Assert(!bootstrap);
975 
977  ereport(FATAL,
978  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
979  errmsg("permission denied to start WAL sender"),
980  errdetail("Only roles with the %s attribute may start a WAL sender process.",
981  "REPLICATION")));
982  }
983 
984  /*
985  * If this is a plain walsender only supporting physical replication, we
986  * don't want to connect to any particular database. Just finish the
987  * backend startup by processing any options from the startup packet, and
988  * we're done.
989  */
991  {
992  /* process any options passed in the startup packet */
993  if (MyProcPort != NULL)
994  process_startup_options(MyProcPort, am_superuser);
995 
996  /* Apply PostAuthDelay as soon as we've read all options */
997  if (PostAuthDelay > 0)
998  pg_usleep(PostAuthDelay * 1000000L);
999 
1000  /* initialize client encoding */
1002 
1003  /* report this backend in the PgBackendStatus array */
1004  pgstat_bestart();
1005 
1006  /* close the transaction we started above */
1008 
1009  return;
1010  }
1011 
1012  /*
1013  * Set up the global variables holding database id and default tablespace.
1014  * But note we won't actually try to touch the database just yet.
1015  *
1016  * We take a shortcut in the bootstrap case, otherwise we have to look up
1017  * the db's entry in pg_database.
1018  */
1019  if (bootstrap)
1020  {
1021  dboid = Template1DbOid;
1022  MyDatabaseTableSpace = DEFAULTTABLESPACE_OID;
1023  }
1024  else if (in_dbname != NULL)
1025  {
1026  HeapTuple tuple;
1027  Form_pg_database dbform;
1028 
1029  tuple = GetDatabaseTuple(in_dbname);
1030  if (!HeapTupleIsValid(tuple))
1031  ereport(FATAL,
1032  (errcode(ERRCODE_UNDEFINED_DATABASE),
1033  errmsg("database \"%s\" does not exist", in_dbname)));
1034  dbform = (Form_pg_database) GETSTRUCT(tuple);
1035  dboid = dbform->oid;
1036  }
1037  else if (!OidIsValid(dboid))
1038  {
1039  /*
1040  * If this is a background worker not bound to any particular
1041  * database, we're done now. Everything that follows only makes sense
1042  * if we are bound to a specific database. We do need to close the
1043  * transaction we started before returning.
1044  */
1045  if (!bootstrap)
1046  {
1047  pgstat_bestart();
1049  }
1050  return;
1051  }
1052 
1053  /*
1054  * Now, take a writer's lock on the database we are trying to connect to.
1055  * If there is a concurrently running DROP DATABASE on that database, this
1056  * will block us until it finishes (and has committed its update of
1057  * pg_database).
1058  *
1059  * Note that the lock is not held long, only until the end of this startup
1060  * transaction. This is OK since we will advertise our use of the
1061  * database in the ProcArray before dropping the lock (in fact, that's the
1062  * next thing to do). Anyone trying a DROP DATABASE after this point will
1063  * see us in the array once they have the lock. Ordering is important for
1064  * this because we don't want to advertise ourselves as being in this
1065  * database until we have the lock; otherwise we create what amounts to a
1066  * deadlock with CountOtherDBBackends().
1067  *
1068  * Note: use of RowExclusiveLock here is reasonable because we envision
1069  * our session as being a concurrent writer of the database. If we had a
1070  * way of declaring a session as being guaranteed-read-only, we could use
1071  * AccessShareLock for such sessions and thereby not conflict against
1072  * CREATE DATABASE.
1073  */
1074  if (!bootstrap)
1075  LockSharedObject(DatabaseRelationId, dboid, 0, RowExclusiveLock);
1076 
1077  /*
1078  * Recheck pg_database to make sure the target database hasn't gone away.
1079  * If there was a concurrent DROP DATABASE, this ensures we will die
1080  * cleanly without creating a mess.
1081  */
1082  if (!bootstrap)
1083  {
1084  HeapTuple tuple;
1085  Form_pg_database datform;
1086 
1087  tuple = GetDatabaseTupleByOid(dboid);
1088  if (HeapTupleIsValid(tuple))
1089  datform = (Form_pg_database) GETSTRUCT(tuple);
1090 
1091  if (!HeapTupleIsValid(tuple) ||
1092  (in_dbname && namestrcmp(&datform->datname, in_dbname)))
1093  {
1094  if (in_dbname)
1095  ereport(FATAL,
1096  (errcode(ERRCODE_UNDEFINED_DATABASE),
1097  errmsg("database \"%s\" does not exist", in_dbname),
1098  errdetail("It seems to have just been dropped or renamed.")));
1099  else
1100  ereport(FATAL,
1101  (errcode(ERRCODE_UNDEFINED_DATABASE),
1102  errmsg("database %u does not exist", dboid)));
1103  }
1104 
1105  strlcpy(dbname, NameStr(datform->datname), sizeof(dbname));
1106 
1107  if (database_is_invalid_form(datform))
1108  {
1109  ereport(FATAL,
1110  errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1111  errmsg("cannot connect to invalid database \"%s\"", dbname),
1112  errhint("Use DROP DATABASE to drop invalid databases."));
1113  }
1114 
1115  MyDatabaseTableSpace = datform->dattablespace;
1116  MyDatabaseHasLoginEventTriggers = datform->dathasloginevt;
1117  /* pass the database name back to the caller */
1118  if (out_dbname)
1119  strcpy(out_dbname, dbname);
1120  }
1121 
1122  /*
1123  * Now that we rechecked, we are certain to be connected to a database and
1124  * thus can set MyDatabaseId.
1125  *
1126  * It is important that MyDatabaseId only be set once we are sure that the
1127  * target database can no longer be concurrently dropped or renamed. For
1128  * example, without this guarantee, pgstat_update_dbstats() could create
1129  * entries for databases that were just dropped in the pgstat shutdown
1130  * callback, which could confuse other code paths like the autovacuum
1131  * scheduler.
1132  */
1133  MyDatabaseId = dboid;
1134 
1135  /*
1136  * Now we can mark our PGPROC entry with the database ID.
1137  *
1138  * We assume this is an atomic store so no lock is needed; though actually
1139  * things would work fine even if it weren't atomic. Anyone searching the
1140  * ProcArray for this database's ID should hold the database lock, so they
1141  * would not be executing concurrently with this store. A process looking
1142  * for another database's ID could in theory see a chance match if it read
1143  * a partially-updated databaseId value; but as long as all such searches
1144  * wait and retry, as in CountOtherDBBackends(), they will certainly see
1145  * the correct value on their next try.
1146  */
1148 
1149  /*
1150  * We established a catalog snapshot while reading pg_authid and/or
1151  * pg_database; but until we have set up MyDatabaseId, we won't react to
1152  * incoming sinval messages for unshared catalogs, so we won't realize it
1153  * if the snapshot has been invalidated. Assume it's no good anymore.
1154  */
1156 
1157  /*
1158  * Now we should be able to access the database directory safely. Verify
1159  * it's there and looks reasonable.
1160  */
1162 
1163  if (!bootstrap)
1164  {
1165  if (access(fullpath, F_OK) == -1)
1166  {
1167  if (errno == ENOENT)
1168  ereport(FATAL,
1169  (errcode(ERRCODE_UNDEFINED_DATABASE),
1170  errmsg("database \"%s\" does not exist",
1171  dbname),
1172  errdetail("The database subdirectory \"%s\" is missing.",
1173  fullpath)));
1174  else
1175  ereport(FATAL,
1177  errmsg("could not access directory \"%s\": %m",
1178  fullpath)));
1179  }
1180 
1181  ValidatePgVersion(fullpath);
1182  }
1183 
1184  SetDatabasePath(fullpath);
1185  pfree(fullpath);
1186 
1187  /*
1188  * It's now possible to do real access to the system catalogs.
1189  *
1190  * Load relcache entries for the system catalogs. This must create at
1191  * least the minimum set of "nailed-in" cache entries.
1192  */
1194 
1195  /* set up ACL framework (so CheckMyDatabase can check permissions) */
1196  initialize_acl();
1197 
1198  /*
1199  * Re-read the pg_database row for our database, check permissions and set
1200  * up database-specific GUC settings. We can't do this until all the
1201  * database-access infrastructure is up. (Also, it wants to know if the
1202  * user is a superuser, so the above stuff has to happen first.)
1203  */
1204  if (!bootstrap)
1205  CheckMyDatabase(dbname, am_superuser,
1206  (flags & INIT_PG_OVERRIDE_ALLOW_CONNS) != 0);
1207 
1208  /*
1209  * Now process any command-line switches and any additional GUC variable
1210  * settings passed in the startup packet. We couldn't do this before
1211  * because we didn't know if client is a superuser.
1212  */
1213  if (MyProcPort != NULL)
1214  process_startup_options(MyProcPort, am_superuser);
1215 
1216  /* Process pg_db_role_setting options */
1218 
1219  /* Apply PostAuthDelay as soon as we've read all options */
1220  if (PostAuthDelay > 0)
1221  pg_usleep(PostAuthDelay * 1000000L);
1222 
1223  /*
1224  * Initialize various default states that can't be set up until we've
1225  * selected the active user and gotten the right GUC settings.
1226  */
1227 
1228  /* set default namespace search path */
1230 
1231  /* initialize client encoding */
1233 
1234  /* Initialize this backend's session state. */
1236 
1237  /*
1238  * If this is an interactive session, load any libraries that should be
1239  * preloaded at backend start. Since those are determined by GUCs, this
1240  * can't happen until GUC settings are complete, but we want it to happen
1241  * during the initial transaction in case anything that requires database
1242  * access needs to be done.
1243  */
1244  if ((flags & INIT_PG_LOAD_SESSION_LIBS) != 0)
1246 
1247  /* report this backend in the PgBackendStatus array */
1248  if (!bootstrap)
1249  pgstat_bestart();
1250 
1251  /* close the transaction we started above */
1252  if (!bootstrap)
1254 }
void initialize_acl(void)
Definition: acl.c:4884
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:5128
void pgstat_beinit(void)
void pgstat_bestart(void)
#define OidIsValid(objectId)
Definition: c.h:775
bool database_is_invalid_form(Form_pg_database datform)
Definition: dbcommands.c:3178
int errcode_for_file_access(void)
Definition: elog.c:880
#define DEBUG3
Definition: elog.h:28
bool MyDatabaseHasLoginEventTriggers
Definition: globals.c:95
bool IsBinaryUpgrade
Definition: globals.c:118
Oid MyDatabaseTableSpace
Definition: globals.c:93
struct Port * MyProcPort
Definition: globals.c:49
const char * hba_authname(UserAuth auth_method)
Definition: hba.c:3061
void before_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:337
void LockSharedObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
Definition: lmgr.c:1083
#define RowExclusiveLock
Definition: lockdefs.h:38
void InitializeClientEncoding(void)
Definition: mbutils.c:281
void pfree(void *pointer)
Definition: mcxt.c:1520
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:454
#define INIT_PG_LOAD_SESSION_LIBS
Definition: miscadmin.h:476
#define AmBackgroundWorkerProcess()
Definition: miscadmin.h:376
#define AmLogicalSlotSyncWorkerProcess()
Definition: miscadmin.h:378
#define AmAutoVacuumLauncherProcess()
Definition: miscadmin.h:374
#define INIT_PG_OVERRIDE_ROLE_LOGIN
Definition: miscadmin.h:478
#define INIT_PG_OVERRIDE_ALLOW_CONNS
Definition: miscadmin.h:477
void InitializeSessionUserId(const char *rolename, Oid roleid, bool bypass_login_check)
Definition: miscinit.c:733
void InitializeSystemUser(const char *authn_id, const char *auth_method)
Definition: miscinit.c:867
void InitializeSessionUserIdStandalone(void)
Definition: miscinit.c:837
void process_session_preload_libraries(void)
Definition: miscinit.c:1857
Oid GetSessionUserId(void)
Definition: miscinit.c:548
void SetDatabasePath(const char *path)
Definition: miscinit.c:328
ClientConnectionInfo MyClientConnectionInfo
Definition: miscinit.c:1010
bool has_rolreplication(Oid roleid)
Definition: miscinit.c:711
void ValidatePgVersion(const char *path)
Definition: miscinit.c:1710
int namestrcmp(Name name, const char *str)
Definition: name.c:247
void InitializeSearchPath(void)
Definition: namespace.c:4721
#define NAMEDATALEN
const char * username
Definition: pgbench.c:296
void pgstat_before_server_shutdown(int code, Datum arg)
Definition: pgstat.c:462
void InitPlanCache(void)
Definition: plancache.c:155
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
void EnablePortalManager(void)
Definition: portalmem.c:104
int PostAuthDelay
Definition: postgres.c:101
static void ShutdownPostgres(int code, Datum arg)
Definition: postinit.c:1360
static void IdleInTransactionSessionTimeoutHandler(void)
Definition: postinit.c:1417
static void LockTimeoutHandler(void)
Definition: postinit.c:1399
static void IdleStatsUpdateTimeoutHandler(void)
Definition: postinit.c:1433
static void process_settings(Oid databaseid, Oid roleid)
Definition: postinit.c:1326
static void IdleSessionTimeoutHandler(void)
Definition: postinit.c:1425
static void process_startup_options(Port *port, bool am_superuser)
Definition: postinit.c:1261
static void StatementTimeoutHandler(void)
Definition: postinit.c:1377
static void CheckMyDatabase(const char *name, bool am_superuser, bool override_allow_connections)
Definition: postinit.c:313
static bool ThereIsAtLeastOneRole(void)
Definition: postinit.c:1452
static void PerformAuthentication(Port *port)
Definition: postinit.c:190
static void ClientCheckTimeoutHandler(void)
Definition: postinit.c:1441
static HeapTuple GetDatabaseTuple(const char *dbname)
Definition: postinit.c:101
static HeapTuple GetDatabaseTupleByOid(Oid dboid)
Definition: postinit.c:144
static void TransactionTimeoutHandler(void)
Definition: postinit.c:1409
int ReservedConnections
Definition: postmaster.c:217
int SuperuserReservedConnections
Definition: postmaster.c:216
short access
Definition: preproc-type.c:36
void ProcSignalInit(void)
Definition: procsignal.c:158
void RelationCacheInitializePhase3(void)
Definition: relcache.c:4056
void RelationCacheInitialize(void)
Definition: relcache.c:3951
void RelationCacheInitializePhase2(void)
Definition: relcache.c:3997
char * GetDatabasePath(Oid dbOid, Oid spcOid)
Definition: relpath.c:110
void ReleaseAuxProcessResources(bool isCommit)
Definition: resowner.c:1002
ResourceOwner CurrentResourceOwner
Definition: resowner.c:165
void CreateAuxProcessResourceOwner(void)
Definition: resowner.c:982
void InitializeSession(void)
Definition: session.c:54
void pg_usleep(long microsec)
Definition: signal.c:53
void SharedInvalBackendInit(bool sendOnly)
Definition: sinvaladt.c:272
Snapshot GetTransactionSnapshot(void)
Definition: snapmgr.c:216
void InvalidateCatalogSnapshot(void)
Definition: snapmgr.c:422
bool HaveNFreeProcs(int n, int *nfree)
Definition: proc.c:687
void CheckDeadLockAlert(void)
Definition: proc.c:1840
void InitProcessPhase2(void)
Definition: proc.c:488
const char * authn_id
Definition: libpq-be.h:103
UserAuth auth_method
Definition: libpq-be.h:109
Oid databaseId
Definition: proc.h:203
bool superuser(void)
Definition: superuser.c:46
void InitCatalogCache(void)
Definition: syscache.c:107
TimeoutId RegisterTimeout(TimeoutId id, timeout_handler_proc handler)
Definition: timeout.c:505
@ IDLE_SESSION_TIMEOUT
Definition: timeout.h:35
@ IDLE_IN_TRANSACTION_SESSION_TIMEOUT
Definition: timeout.h:33
@ LOCK_TIMEOUT
Definition: timeout.h:28
@ STATEMENT_TIMEOUT
Definition: timeout.h:29
@ DEADLOCK_TIMEOUT
Definition: timeout.h:27
@ TRANSACTION_TIMEOUT
Definition: timeout.h:34
@ IDLE_STATS_UPDATE_TIMEOUT
Definition: timeout.h:36
@ CLIENT_CONNECTION_CHECK_TIMEOUT
Definition: timeout.h:37
bool am_walsender
Definition: walsender.c:115
bool am_db_walsender
Definition: walsender.c:118
void StartTransactionCommand(void)
Definition: xact.c:2995
int XactIsoLevel
Definition: xact.c:77
void SetCurrentStatementStartTimestamp(void)
Definition: xact.c:911
void CommitTransactionCommand(void)
Definition: xact.c:3093
#define XACT_READ_COMMITTED
Definition: xact.h:37
void StartupXLOG(void)
Definition: xlog.c:5388
void ShutdownXLOG(int code, Datum arg)
Definition: xlog.c:6539

References am_db_walsender, am_walsender, AmAutoVacuumLauncherProcess, AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, AmLogicalSlotSyncWorkerProcess, Assert, ClientConnectionInfo::auth_method, ClientConnectionInfo::authn_id, before_shmem_exit(), CheckDeadLockAlert(), CheckMyDatabase(), CLIENT_CONNECTION_CHECK_TIMEOUT, ClientCheckTimeoutHandler(), CommitTransactionCommand(), CreateAuxProcessResourceOwner(), CurrentResourceOwner, database_is_invalid_form(), PGPROC::databaseId, dbname, DEADLOCK_TIMEOUT, DEBUG3, elog, EnablePortalManager(), ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), FATAL, GetDatabasePath(), GetDatabaseTuple(), GetDatabaseTupleByOid(), GetSessionUserId(), GETSTRUCT, GetTransactionSnapshot(), GetUserId(), has_privs_of_role(), has_rolreplication(), HaveNFreeProcs(), hba_authname(), HeapTupleIsValid, IDLE_IN_TRANSACTION_SESSION_TIMEOUT, IDLE_SESSION_TIMEOUT, IDLE_STATS_UPDATE_TIMEOUT, IdleInTransactionSessionTimeoutHandler(), IdleSessionTimeoutHandler(), IdleStatsUpdateTimeoutHandler(), INIT_PG_LOAD_SESSION_LIBS, INIT_PG_OVERRIDE_ALLOW_CONNS, INIT_PG_OVERRIDE_ROLE_LOGIN, InitCatalogCache(), initialize_acl(), InitializeClientEncoding(), InitializeSearchPath(), InitializeSession(), InitializeSessionUserId(), InitializeSessionUserIdStandalone(), InitializeSystemUser(), InitPlanCache(), InitProcessPhase2(), InvalidateCatalogSnapshot(), IsBinaryUpgrade, IsBootstrapProcessingMode, IsUnderPostmaster, LOCK_TIMEOUT, LockSharedObject(), LockTimeoutHandler(), MyClientConnectionInfo, MyDatabaseHasLoginEventTriggers, MyDatabaseId, MyDatabaseTableSpace, MyProc, MyProcPort, NAMEDATALEN, NameStr, namestrcmp(), OidIsValid, PerformAuthentication(), pfree(), pg_usleep(), pgstat_before_server_shutdown(), pgstat_beinit(), pgstat_bestart(), PostAuthDelay, process_session_preload_libraries(), process_settings(), process_startup_options(), ProcSignalInit(), RegisterTimeout(), RelationCacheInitialize(), RelationCacheInitializePhase2(), RelationCacheInitializePhase3(), ReleaseAuxProcessResources(), ReservedConnections, RowExclusiveLock, SetCurrentStatementStartTimestamp(), SetDatabasePath(), SharedInvalBackendInit(), ShutdownPostgres(), ShutdownXLOG(), StartTransactionCommand(), StartupXLOG(), STATEMENT_TIMEOUT, StatementTimeoutHandler(), strlcpy(), superuser(), SuperuserReservedConnections, ThereIsAtLeastOneRole(), TRANSACTION_TIMEOUT, TransactionTimeoutHandler(), username, ValidatePgVersion(), WARNING, XACT_READ_COMMITTED, and XactIsoLevel.

Referenced by AutoVacWorkerMain(), BackgroundWorkerInitializeConnection(), BackgroundWorkerInitializeConnectionByOid(), BootstrapModeMain(), PostgresMain(), and ReplSlotSyncWorkerMain().

◆ LockTimeoutHandler()

static void LockTimeoutHandler ( void  )
static

Definition at line 1399 of file postinit.c.

1400 {
1401 #ifdef HAVE_SETSID
1402  /* try to signal whole process group */
1403  kill(-MyProcPid, SIGINT);
1404 #endif
1405  kill(MyProcPid, SIGINT);
1406 }
int MyProcPid
Definition: globals.c:45
#define kill(pid, sig)
Definition: win32_port.h:485

References kill, and MyProcPid.

Referenced by InitPostgres().

◆ PerformAuthentication()

static void PerformAuthentication ( Port port)
static

Definition at line 190 of file postinit.c.

191 {
192  /* This should be set already, but let's make sure */
193  ClientAuthInProgress = true; /* limit visibility of log messages */
194 
195  /*
196  * In EXEC_BACKEND case, we didn't inherit the contents of pg_hba.conf
197  * etcetera from the postmaster, and have to load them ourselves.
198  *
199  * FIXME: [fork/exec] Ugh. Is there a way around this overhead?
200  */
201 #ifdef EXEC_BACKEND
202 
203  /*
204  * load_hba() and load_ident() want to work within the PostmasterContext,
205  * so create that if it doesn't exist (which it won't). We'll delete it
206  * again later, in PostgresMain.
207  */
208  if (PostmasterContext == NULL)
210  "Postmaster",
212 
213  if (!load_hba())
214  {
215  /*
216  * It makes no sense to continue if we fail to load the HBA file,
217  * since there is no way to connect to the database in this case.
218  */
219  ereport(FATAL,
220  /* translator: %s is a configuration file */
221  (errmsg("could not load %s", HbaFileName)));
222  }
223 
224  if (!load_ident())
225  {
226  /*
227  * It is ok to continue if we fail to load the IDENT file, although it
228  * means that you cannot log in using any of the authentication
229  * methods that need a user name mapping. load_ident() already logged
230  * the details of error to the log.
231  */
232  }
233 #endif
234 
235  /*
236  * Set up a timeout in case a buggy or malicious client fails to respond
237  * during authentication. Since we're inside a transaction and might do
238  * database access, we have to use the statement_timeout infrastructure.
239  */
241 
242  /*
243  * Now perform authentication exchange.
244  */
245  set_ps_display("authentication");
246  ClientAuthentication(port); /* might not return, if failure */
247 
248  /*
249  * Done with authentication. Disable the timeout, and log if needed.
250  */
252 
253  if (Log_connections)
254  {
255  StringInfoData logmsg;
256 
257  initStringInfo(&logmsg);
258  if (am_walsender)
259  appendStringInfo(&logmsg, _("replication connection authorized: user=%s"),
260  port->user_name);
261  else
262  appendStringInfo(&logmsg, _("connection authorized: user=%s"),
263  port->user_name);
264  if (!am_walsender)
265  appendStringInfo(&logmsg, _(" database=%s"), port->database_name);
266 
267  if (port->application_name != NULL)
268  appendStringInfo(&logmsg, _(" application_name=%s"),
269  port->application_name);
270 
271 #ifdef USE_SSL
272  if (port->ssl_in_use)
273  appendStringInfo(&logmsg, _(" SSL enabled (protocol=%s, cipher=%s, bits=%d)"),
277 #endif
278 #ifdef ENABLE_GSS
279  if (port->gss)
280  {
281  const char *princ = be_gssapi_get_princ(port);
282 
283  if (princ)
284  appendStringInfo(&logmsg,
285  _(" GSS (authenticated=%s, encrypted=%s, delegated_credentials=%s, principal=%s)"),
286  be_gssapi_get_auth(port) ? _("yes") : _("no"),
287  be_gssapi_get_enc(port) ? _("yes") : _("no"),
288  be_gssapi_get_delegation(port) ? _("yes") : _("no"),
289  princ);
290  else
291  appendStringInfo(&logmsg,
292  _(" GSS (authenticated=%s, encrypted=%s, delegated_credentials=%s)"),
293  be_gssapi_get_auth(port) ? _("yes") : _("no"),
294  be_gssapi_get_enc(port) ? _("yes") : _("no"),
295  be_gssapi_get_delegation(port) ? _("yes") : _("no"));
296  }
297 #endif
298 
299  ereport(LOG, errmsg_internal("%s", logmsg.data));
300  pfree(logmsg.data);
301  }
302 
303  set_ps_display("startup");
304 
305  ClientAuthInProgress = false; /* client_min_messages is active now */
306 }
void ClientAuthentication(Port *port)
Definition: auth.c:382
bool be_gssapi_get_auth(Port *port)
bool be_gssapi_get_enc(Port *port)
const char * be_gssapi_get_princ(Port *port)
bool be_gssapi_get_delegation(Port *port)
const char * be_tls_get_version(Port *port)
int be_tls_get_cipher_bits(Port *port)
const char * be_tls_get_cipher(Port *port)
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
#define _(x)
Definition: elog.c:90
#define LOG
Definition: elog.h:31
char * HbaFileName
Definition: guc_tables.c:541
bool load_ident(void)
Definition: hba.c:2959
bool load_hba(void)
Definition: hba.c:2583
MemoryContext PostmasterContext
Definition: mcxt.c:151
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
static int port
Definition: pg_regress.c:116
bool Log_connections
Definition: postmaster.c:231
bool ClientAuthInProgress
Definition: postmaster.c:350
int AuthenticationTimeout
Definition: postmaster.c:228
static void set_ps_display(const char *activity)
Definition: ps_status.h:40
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:97
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
void enable_timeout_after(TimeoutId id, int delay_ms)
Definition: timeout.c:560
void disable_timeout(TimeoutId id, bool keep_indicator)
Definition: timeout.c:685

References _, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, am_walsender, appendStringInfo(), AuthenticationTimeout, be_gssapi_get_auth(), be_gssapi_get_delegation(), be_gssapi_get_enc(), be_gssapi_get_princ(), be_tls_get_cipher(), be_tls_get_cipher_bits(), be_tls_get_version(), ClientAuthentication(), ClientAuthInProgress, StringInfoData::data, disable_timeout(), enable_timeout_after(), ereport, errmsg(), errmsg_internal(), FATAL, HbaFileName, initStringInfo(), load_hba(), load_ident(), LOG, Log_connections, pfree(), port, PostmasterContext, set_ps_display(), STATEMENT_TIMEOUT, and TopMemoryContext.

Referenced by InitPostgres().

◆ pg_split_opts()

void pg_split_opts ( char **  argv,
int *  argcp,
const char *  optstr 
)

Definition at line 517 of file postinit.c.

518 {
519  StringInfoData s;
520 
521  initStringInfo(&s);
522 
523  while (*optstr)
524  {
525  bool last_was_escape = false;
526 
527  resetStringInfo(&s);
528 
529  /* skip over leading space */
530  while (isspace((unsigned char) *optstr))
531  optstr++;
532 
533  if (*optstr == '\0')
534  break;
535 
536  /*
537  * Parse a single option, stopping at the first space, unless it's
538  * escaped.
539  */
540  while (*optstr)
541  {
542  if (isspace((unsigned char) *optstr) && !last_was_escape)
543  break;
544 
545  if (!last_was_escape && *optstr == '\\')
546  last_was_escape = true;
547  else
548  {
549  last_was_escape = false;
550  appendStringInfoChar(&s, *optstr);
551  }
552 
553  optstr++;
554  }
555 
556  /* now store the option in the next argv[] position */
557  argv[(*argcp)++] = pstrdup(s.data);
558  }
559 
560  pfree(s.data);
561 }
char * pstrdup(const char *in)
Definition: mcxt.c:1695
void resetStringInfo(StringInfo str)
Definition: stringinfo.c:78
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:194

References appendStringInfoChar(), StringInfoData::data, initStringInfo(), pfree(), pstrdup(), and resetStringInfo().

Referenced by process_startup_options().

◆ process_settings()

static void process_settings ( Oid  databaseid,
Oid  roleid 
)
static

Definition at line 1326 of file postinit.c.

1327 {
1328  Relation relsetting;
1329  Snapshot snapshot;
1330 
1331  if (!IsUnderPostmaster)
1332  return;
1333 
1334  relsetting = table_open(DbRoleSettingRelationId, AccessShareLock);
1335 
1336  /* read all the settings under the same snapshot for efficiency */
1337  snapshot = RegisterSnapshot(GetCatalogSnapshot(DbRoleSettingRelationId));
1338 
1339  /* Later settings are ignored if set earlier. */
1340  ApplySetting(snapshot, databaseid, roleid, relsetting, PGC_S_DATABASE_USER);
1341  ApplySetting(snapshot, InvalidOid, roleid, relsetting, PGC_S_USER);
1342  ApplySetting(snapshot, databaseid, InvalidOid, relsetting, PGC_S_DATABASE);
1343  ApplySetting(snapshot, InvalidOid, InvalidOid, relsetting, PGC_S_GLOBAL);
1344 
1345  UnregisterSnapshot(snapshot);
1346  table_close(relsetting, AccessShareLock);
1347 }
@ PGC_S_GLOBAL
Definition: guc.h:114
@ PGC_S_DATABASE
Definition: guc.h:115
@ PGC_S_DATABASE_USER
Definition: guc.h:117
@ PGC_S_USER
Definition: guc.h:116
void ApplySetting(Snapshot snapshot, Oid databaseid, Oid roleid, Relation relsetting, GucSource source)
#define InvalidOid
Definition: postgres_ext.h:36
Snapshot GetCatalogSnapshot(Oid relid)
Definition: snapmgr.c:352
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:836
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:794

References AccessShareLock, ApplySetting(), GetCatalogSnapshot(), InvalidOid, IsUnderPostmaster, PGC_S_DATABASE, PGC_S_DATABASE_USER, PGC_S_GLOBAL, PGC_S_USER, RegisterSnapshot(), table_close(), table_open(), and UnregisterSnapshot().

Referenced by InitPostgres().

◆ process_startup_options()

static void process_startup_options ( Port port,
bool  am_superuser 
)
static

Definition at line 1261 of file postinit.c.

1262 {
1263  GucContext gucctx;
1264  ListCell *gucopts;
1265 
1266  gucctx = am_superuser ? PGC_SU_BACKEND : PGC_BACKEND;
1267 
1268  /*
1269  * First process any command-line switches that were included in the
1270  * startup packet, if we are in a regular backend.
1271  */
1272  if (port->cmdline_options != NULL)
1273  {
1274  /*
1275  * The maximum possible number of commandline arguments that could
1276  * come from port->cmdline_options is (strlen + 1) / 2; see
1277  * pg_split_opts().
1278  */
1279  char **av;
1280  int maxac;
1281  int ac;
1282 
1283  maxac = 2 + (strlen(port->cmdline_options) + 1) / 2;
1284 
1285  av = (char **) palloc(maxac * sizeof(char *));
1286  ac = 0;
1287 
1288  av[ac++] = "postgres";
1289 
1290  pg_split_opts(av, &ac, port->cmdline_options);
1291 
1292  av[ac] = NULL;
1293 
1294  Assert(ac < maxac);
1295 
1296  (void) process_postgres_switches(ac, av, gucctx, NULL);
1297  }
1298 
1299  /*
1300  * Process any additional GUC variable settings passed in startup packet.
1301  * These are handled exactly like command-line variables.
1302  */
1303  gucopts = list_head(port->guc_options);
1304  while (gucopts)
1305  {
1306  char *name;
1307  char *value;
1308 
1309  name = lfirst(gucopts);
1310  gucopts = lnext(port->guc_options, gucopts);
1311 
1312  value = lfirst(gucopts);
1313  gucopts = lnext(port->guc_options, gucopts);
1314 
1316  }
1317 }
@ PGC_S_CLIENT
Definition: guc.h:118
GucContext
Definition: guc.h:68
@ PGC_SU_BACKEND
Definition: guc.h:72
static struct @155 value
void * palloc(Size size)
Definition: mcxt.c:1316
#define lfirst(lc)
Definition: pg_list.h:172
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
void process_postgres_switches(int argc, char *argv[], GucContext ctx, const char **dbname)
Definition: postgres.c:3790
void pg_split_opts(char **argv, int *argcp, const char *optstr)
Definition: postinit.c:517
struct @10::@11 av[32]

References Assert, av, lfirst, list_head(), lnext(), name, palloc(), pg_split_opts(), PGC_BACKEND, PGC_S_CLIENT, PGC_SU_BACKEND, port, process_postgres_switches(), SetConfigOption(), and value.

Referenced by InitPostgres().

◆ ShutdownPostgres()

static void ShutdownPostgres ( int  code,
Datum  arg 
)
static

Definition at line 1360 of file postinit.c.

1361 {
1362  /* Make sure we've killed any active transaction */
1364 
1365  /*
1366  * User locks are not released by transaction end, so be sure to release
1367  * them explicitly.
1368  */
1370 }
void LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
Definition: lock.c:2147
#define USER_LOCKMETHOD
Definition: lock.h:126
void AbortOutOfAnyTransaction(void)
Definition: xact.c:4811

References AbortOutOfAnyTransaction(), LockReleaseAll(), and USER_LOCKMETHOD.

Referenced by InitPostgres().

◆ StatementTimeoutHandler()

static void StatementTimeoutHandler ( void  )
static

Definition at line 1377 of file postinit.c.

1378 {
1379  int sig = SIGINT;
1380 
1381  /*
1382  * During authentication the timeout is used to deal with
1383  * authentication_timeout - we want to quit in response to such timeouts.
1384  */
1386  sig = SIGTERM;
1387 
1388 #ifdef HAVE_SETSID
1389  /* try to signal whole process group */
1390  kill(-MyProcPid, sig);
1391 #endif
1392  kill(MyProcPid, sig);
1393 }
static int sig
Definition: pg_ctl.c:79

References ClientAuthInProgress, kill, MyProcPid, and sig.

Referenced by InitPostgres().

◆ ThereIsAtLeastOneRole()

static bool ThereIsAtLeastOneRole ( void  )
static

Definition at line 1452 of file postinit.c.

1453 {
1454  Relation pg_authid_rel;
1455  TableScanDesc scan;
1456  bool result;
1457 
1458  pg_authid_rel = table_open(AuthIdRelationId, AccessShareLock);
1459 
1460  scan = table_beginscan_catalog(pg_authid_rel, 0, NULL);
1461  result = (heap_getnext(scan, ForwardScanDirection) != NULL);
1462 
1463  table_endscan(scan);
1464  table_close(pg_authid_rel, AccessShareLock);
1465 
1466  return result;
1467 }
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1251
@ ForwardScanDirection
Definition: sdir.h:28
TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, struct ScanKeyData *key)
Definition: tableam.c:112
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:1029

References AccessShareLock, ForwardScanDirection, heap_getnext(), table_beginscan_catalog(), table_close(), table_endscan(), and table_open().

Referenced by InitPostgres().

◆ TransactionTimeoutHandler()

static void TransactionTimeoutHandler ( void  )
static

Definition at line 1409 of file postinit.c.

1410 {
1412  InterruptPending = true;
1413  SetLatch(MyLatch);
1414 }
volatile sig_atomic_t TransactionTimeoutPending
Definition: globals.c:36

References InterruptPending, MyLatch, SetLatch(), and TransactionTimeoutPending.

Referenced by InitPostgres().