PostgreSQL Source Code git master
Functions
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/aio_subsys.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/procnumber.h"
#include "storage/procsignal.h"
#include "storage/sinvaladt.h"
#include "storage/smgr.h"
#include "storage/sync.h"
#include "tcop/backend_startup.h"
#include "tcop/tcopprot.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/guc_hooks.h"
#include "utils/injection_point.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)
 
void  InitializeFastPathLocks (void)
 
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 611 of file postinit.c.

612{
613 Assert(MyProc != NULL);
614
615 /*
616 * Initialize our input/output/debugging file descriptors.
617 */
619
620 /*
621 * Initialize file access. Done early so other subsystems can access
622 * files.
623 */
625
626 /*
627 * Initialize statistics reporting. This needs to happen early to ensure
628 * that pgstat's shutdown callback runs after the shutdown callbacks of
629 * all subsystems that can produce stats (like e.g. transaction commits
630 * can).
631 */
633
634 /*
635 * Initialize AIO before infrastructure that might need to actually
636 * execute AIO.
637 */
639
640 /* Do local initialization of storage and buffer managers */
641 InitSync();
642 smgrinit();
644
645 /*
646 * Initialize temporary file access after pgstat, so that the temporary
647 * file shutdown hook can report temporary file statistics.
648 */
650
651 /*
652 * Initialize local buffers for WAL record construction, in case we ever
653 * try to insert XLOG.
654 */
656
657 /* Initialize lock manager's local structs */
659
660 /*
661 * Initialize replication slots after pgstat. The exit hook might need to
662 * drop ephemeral slots, which in turn triggers stats reporting.
663 */
665}
void pgaio_init_backend(void)
Definition: aio_init.c:218
void InitBufferManagerAccess(void)
Definition: bufmgr.c:3982
void DebugFileOpen(void)
Definition: elog.c:2119
void InitFileAccess(void)
Definition: fd.c:900
void InitTemporaryFileAccess(void)
Definition: fd.c:930
Assert(PointerIsAligned(start, uint64))
void InitLockManagerAccess(void)
Definition: lock.c:505
void pgstat_initialize(void)
Definition: pgstat.c:639
void ReplicationSlotInitialize(void)
Definition: slot.c:241
void smgrinit(void)
Definition: smgr.c:188
PGPROC * MyProc
Definition: proc.c:66
void InitSync(void)
Definition: sync.c:124
void InitXLogInsert(void)
Definition: xloginsert.c:1360

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

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

◆ CheckMyDatabase()

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

Definition at line 323 of file postinit.c.

324{
325 HeapTuple tup;
326 Form_pg_database dbform;
327 Datum datum;
328 bool isnull;
329 char *collate;
330 char *ctype;
331
332 /* Fetch our pg_database row normally, via syscache */
333 tup = SearchSysCache1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));
334 if (!HeapTupleIsValid(tup))
335 elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);
336 dbform = (Form_pg_database) GETSTRUCT(tup);
337
338 /* This recheck is strictly paranoia */
339 if (strcmp(name, NameStr(dbform->datname)) != 0)
341 (errcode(ERRCODE_UNDEFINED_DATABASE),
342 errmsg("database \"%s\" has disappeared from pg_database",
343 name),
344 errdetail("Database OID %u now seems to belong to \"%s\".",
345 MyDatabaseId, NameStr(dbform->datname))));
346
347 /*
348 * Check permissions to connect to the database.
349 *
350 * These checks are not enforced when in standalone mode, so that there is
351 * a way to recover from disabling all access to all databases, for
352 * example "UPDATE pg_database SET datallowconn = false;".
353 */
355 {
356 /*
357 * Check that the database is currently allowing connections.
358 * (Background processes can override this test and the next one by
359 * setting override_allow_connections.)
360 */
361 if (!dbform->datallowconn && !override_allow_connections)
363 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
364 errmsg("database \"%s\" is not currently accepting connections",
365 name)));
366
367 /*
368 * Check privilege to connect to the database. (The am_superuser test
369 * is redundant, but since we have the flag, might as well check it
370 * and save a few cycles.)
371 */
372 if (!am_superuser && !override_allow_connections &&
373 object_aclcheck(DatabaseRelationId, MyDatabaseId, GetUserId(),
376 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
377 errmsg("permission denied for database \"%s\"", name),
378 errdetail("User does not have CONNECT privilege.")));
379
380 /*
381 * Check connection limit for this database. We enforce the limit
382 * only for regular backends, since other process types have their own
383 * PGPROC pools.
384 *
385 * There is a race condition here --- we create our PGPROC before
386 * checking for other PGPROCs. If two backends did this at about the
387 * same time, they might both think they were over the limit, while
388 * ideally one should succeed and one fail. Getting that to work
389 * exactly seems more trouble than it is worth, however; instead we
390 * just document that the connection limit is approximate.
391 */
392 if (dbform->datconnlimit >= 0 &&
394 !am_superuser &&
395 CountDBConnections(MyDatabaseId) > dbform->datconnlimit)
397 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
398 errmsg("too many connections for database \"%s\"",
399 name)));
400 }
401
402 /*
403 * OK, we're golden. Next to-do item is to save the encoding info out of
404 * the pg_database tuple.
405 */
406 SetDatabaseEncoding(dbform->encoding);
407 /* Record it as a GUC internal option, too */
408 SetConfigOption("server_encoding", GetDatabaseEncodingName(),
410 /* If we have no other source of client_encoding, use server encoding */
411 SetConfigOption("client_encoding", GetDatabaseEncodingName(),
413
414 /* assign locale variables */
415 datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datcollate);
416 collate = TextDatumGetCString(datum);
417 datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datctype);
418 ctype = TextDatumGetCString(datum);
419
420 /*
421 * Historcally, we set LC_COLLATE from datcollate, as well. That's no
422 * longer necessary because all collation behavior is handled through
423 * pg_locale_t.
424 */
425
426 if (pg_perm_setlocale(LC_CTYPE, ctype) == NULL)
428 (errmsg("database locale is incompatible with operating system"),
429 errdetail("The database was initialized with LC_CTYPE \"%s\", "
430 " which is not recognized by setlocale().", ctype),
431 errhint("Recreate the database with another locale or install the missing locale.")));
432
433 if (strcmp(ctype, "C") == 0 ||
434 strcmp(ctype, "POSIX") == 0)
435 database_ctype_is_c = true;
436
438
439 /*
440 * Check collation version. See similar code in
441 * pg_newlocale_from_collation(). Note that here we warn instead of error
442 * in any case, so that we don't prevent connecting.
443 */
444 datum = SysCacheGetAttr(DATABASEOID, tup, Anum_pg_database_datcollversion,
445 &isnull);
446 if (!isnull)
447 {
448 char *actual_versionstr;
449 char *collversionstr;
450 char *locale;
451
452 collversionstr = TextDatumGetCString(datum);
453
454 if (dbform->datlocprovider == COLLPROVIDER_LIBC)
455 locale = collate;
456 else
457 {
458 datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datlocale);
460 }
461
462 actual_versionstr = get_collation_actual_version(dbform->datlocprovider, locale);
463 if (!actual_versionstr)
464 /* should not happen */
466 "database \"%s\" has no actual collation version, but a version was recorded",
467 name);
468 else if (strcmp(actual_versionstr, collversionstr) != 0)
470 (errmsg("database \"%s\" has a collation version mismatch",
471 name),
472 errdetail("The database was created using collation version %s, "
473 "but the operating system provides version %s.",
474 collversionstr, actual_versionstr),
475 errhint("Rebuild all objects in this database that use the default collation and run "
476 "ALTER DATABASE %s REFRESH COLLATION VERSION, "
477 "or build PostgreSQL with the right library version.",
479 }
480
481 ReleaseSysCache(tup);
482}
@ ACLCHECK_OK
Definition: acl.h:183
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3834
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define NameStr(name)
Definition: c.h:751
int errdetail(const char *fmt,...)
Definition: elog.c:1207
int errhint(const char *fmt,...)
Definition: elog.c:1321
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define FATAL
Definition: elog.h:41
#define WARNING
Definition: elog.h:36
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define ereport(elevel,...)
Definition: elog.h:150
bool IsUnderPostmaster
Definition: globals.c:120
Oid MyDatabaseId
Definition: globals.c:94
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4337
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:114
@ PGC_INTERNAL
Definition: guc.h:73
@ PGC_BACKEND
Definition: guc.h:77
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
static char * locale
Definition: initdb.c:140
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1268
void SetDatabaseEncoding(int encoding)
Definition: mbutils.c:1162
#define AmRegularBackendProcess()
Definition: miscadmin.h:380
Oid GetUserId(void)
Definition: miscinit.c:469
#define ACL_CONNECT
Definition: parsenodes.h:87
FormData_pg_database * Form_pg_database
Definition: pg_database.h:96
char * get_collation_actual_version(char collprovider, const char *collcollate)
Definition: pg_locale.c:1217
bool database_ctype_is_c
Definition: pg_locale.c:103
char * pg_perm_setlocale(int category, const char *locale)
Definition: pg_locale.c:165
void init_database_collation(void)
Definition: pg_locale.c:1124
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
uint64_t Datum
Definition: postgres.h:70
int CountDBConnections(Oid databaseid)
Definition: procarray.c:3590
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:13035
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:264
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:220
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:595
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:625
const char * name

References ACL_CONNECT, ACLCHECK_OK, AmRegularBackendProcess, CountDBConnections(), database_ctype_is_c, elog, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, FATAL, get_collation_actual_version(), GetDatabaseEncodingName(), GETSTRUCT(), GetUserId(), HeapTupleIsValid, init_database_collation(), IsUnderPostmaster, locale, MyDatabaseId, name, NameStr, object_aclcheck(), ObjectIdGetDatum(), pg_perm_setlocale(), PGC_BACKEND, PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT, quote_identifier(), ReleaseSysCache(), SearchSysCache1(), SetConfigOption(), SetDatabaseEncoding(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), TextDatumGetCString, and WARNING.

Referenced by InitPostgres().

◆ ClientCheckTimeoutHandler()

static void ClientCheckTimeoutHandler ( void  )
static

Definition at line 1423 of file postinit.c.

1424{
1426 InterruptPending = true;
1428}
volatile sig_atomic_t InterruptPending
Definition: globals.c:32
struct Latch * MyLatch
Definition: globals.c:63
volatile sig_atomic_t CheckClientConnectionPending
Definition: globals.c:35
void SetLatch(Latch *latch)
Definition: latch.c:290

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

Referenced by InitPostgres().

◆ GetDatabaseTuple()

static HeapTuple GetDatabaseTuple ( const char *  dbname )
static

Definition at line 105 of file postinit.c.

106{
107 HeapTuple tuple;
108 Relation relation;
109 SysScanDesc scan;
110 ScanKeyData key[1];
111
112 /*
113 * form a scan key
114 */
115 ScanKeyInit(&key[0],
116 Anum_pg_database_datname,
117 BTEqualStrategyNumber, F_NAMEEQ,
119
120 /*
121 * Open pg_database and fetch a tuple. Force heap scan if we haven't yet
122 * built the critical shared relcache entries (i.e., we're starting up
123 * without a shared relcache cache file).
124 */
125 relation = table_open(DatabaseRelationId, AccessShareLock);
126 scan = systable_beginscan(relation, DatabaseNameIndexId,
128 NULL,
129 1, key);
130
131 tuple = systable_getnext(scan);
132
133 /* Must copy tuple before releasing buffer */
134 if (HeapTupleIsValid(tuple))
135 tuple = heap_copytuple(tuple);
136
137 /* all done */
138 systable_endscan(scan);
139 table_close(relation, AccessShareLock);
140
141 return tuple;
142}
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:603
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:514
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:388
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:778
#define AccessShareLock
Definition: lockdefs.h:36
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:360
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:49
Definition: rel.h:56
Definition: skey.h:65
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 148 of file postinit.c.

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

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 1399 of file postinit.c.

1400{
1402 InterruptPending = true;
1404}
volatile sig_atomic_t IdleInTransactionSessionTimeoutPending
Definition: globals.c:37

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

Referenced by InitPostgres().

◆ IdleSessionTimeoutHandler()

static void IdleSessionTimeoutHandler ( void  )
static

Definition at line 1407 of file postinit.c.

1408{
1410 InterruptPending = true;
1412}
volatile sig_atomic_t IdleSessionTimeoutPending
Definition: globals.c:39

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

Referenced by InitPostgres().

◆ IdleStatsUpdateTimeoutHandler()

static void IdleStatsUpdateTimeoutHandler ( void  )
static

Definition at line 1415 of file postinit.c.

1416{
1418 InterruptPending = true;
1420}
volatile sig_atomic_t IdleStatsUpdateTimeoutPending
Definition: globals.c:42

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

Referenced by InitPostgres().

◆ InitializeFastPathLocks()

void InitializeFastPathLocks ( void  )

Definition at line 579 of file postinit.c.

580{
581 /* Should be initialized only once. */
583
584 /*
585 * Based on the max_locks_per_transaction GUC, as that's a good indicator
586 * of the expected number of locks, figure out the value for
587 * FastPathLockGroupsPerBackend. This must be a power-of-two. We cap the
588 * value at FP_LOCK_GROUPS_PER_BACKEND_MAX and insist the value is at
589 * least 1.
590 *
591 * The default max_locks_per_transaction = 64 means 4 groups by default.
592 */
596
597 /* Validate we did get a power-of-two */
600}
#define Min(x, y)
Definition: c.h:1003
#define Max(x, y)
Definition: c.h:997
int max_locks_per_xact
Definition: lock.c:53
int FastPathLockGroupsPerBackend
Definition: lock.c:202
static uint32 pg_nextpower2_32(uint32 num)
Definition: pg_bitutils.h:189
#define FP_LOCK_GROUPS_PER_BACKEND_MAX
Definition: proc.h:91
#define FP_LOCK_SLOTS_PER_GROUP
Definition: proc.h:92

References Assert(), FastPathLockGroupsPerBackend, FP_LOCK_GROUPS_PER_BACKEND_MAX, FP_LOCK_SLOTS_PER_GROUP, Max, max_locks_per_xact, Min, and pg_nextpower2_32().

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

◆ InitializeMaxBackends()

void InitializeMaxBackends ( void  )

Definition at line 554 of file postinit.c.

555{
556 Assert(MaxBackends == 0);
557
558 /* Note that this does not include "auxiliary" processes */
561
564 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
565 errmsg("too many server processes configured"),
566 errdetail("\"max_connections\" (%d) plus \"autovacuum_worker_slots\" (%d) plus \"max_worker_processes\" (%d) plus \"max_wal_senders\" (%d) must be less than %d.",
570}
int autovacuum_worker_slots
Definition: autovacuum.c:118
int MaxConnections
Definition: globals.c:143
int MaxBackends
Definition: globals.c:146
int max_worker_processes
Definition: globals.c:144
#define NUM_SPECIAL_WORKER_PROCS
Definition: proc.h:450
#define MAX_BACKENDS
Definition: procnumber.h:39
int max_wal_senders
Definition: walsender.c:129

References Assert(), autovacuum_worker_slots, ereport, errcode(), errdetail(), errmsg(), ERROR, MAX_BACKENDS, max_wal_senders, max_worker_processes, MaxBackends, MaxConnections, and NUM_SPECIAL_WORKER_PROCS.

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 711 of file postinit.c.

715{
716 bool bootstrap = IsBootstrapProcessingMode();
717 bool am_superuser;
718 char *fullpath;
719 char dbname[NAMEDATALEN];
720 int nfree = 0;
721
722 elog(DEBUG3, "InitPostgres");
723
724 /*
725 * Add my PGPROC struct to the ProcArray.
726 *
727 * Once I have done this, I am visible to other backends!
728 */
730
731 /* Initialize status reporting */
733
734 /*
735 * And initialize an entry in the PgBackendStatus array. That way, if
736 * LWLocks or third-party authentication should happen to hang, it is
737 * possible to retrieve some information about what is going on.
738 */
739 if (!bootstrap)
740 {
742 INJECTION_POINT("init-pre-auth", NULL);
743 }
744
745 /*
746 * Initialize my entry in the shared-invalidation manager's array of
747 * per-backend data.
748 */
750
752
753 /*
754 * Also set up timeout handlers needed for backend operation. We need
755 * these in every case except bootstrap.
756 */
757 if (!bootstrap)
758 {
769 }
770
771 /*
772 * If this is either a bootstrap process or a standalone backend, start up
773 * the XLOG machinery, and register to have it closed down at exit. In
774 * other cases, the startup process is responsible for starting up the
775 * XLOG machinery, and the checkpointer for closing it down.
776 */
778 {
779 /*
780 * We don't yet have an aux-process resource owner, but StartupXLOG
781 * and ShutdownXLOG will need one. Hence, create said resource owner
782 * (and register a callback to clean it up after ShutdownXLOG runs).
783 */
785
786 StartupXLOG();
787 /* Release (and warn about) any buffer pins leaked in StartupXLOG */
789 /* Reset CurrentResourceOwner to nothing for the moment */
791
792 /*
793 * Use before_shmem_exit() so that ShutdownXLOG() can rely on DSM
794 * segments etc to work (which in turn is required for pgstats).
795 */
798 }
799
800 /*
801 * Initialize the relation cache and the system catalog caches. Note that
802 * no catalog access happens here; we only set up the hashtable structure.
803 * We must do this before starting a transaction because transaction abort
804 * would try to touch these hashtables.
805 */
809
810 /* Initialize portal manager */
812
813 /*
814 * Load relcache entries for the shared system catalogs. This must create
815 * at least entries for pg_database and catalogs used for authentication.
816 */
818
819 /*
820 * Set up process-exit callback to do pre-shutdown cleanup. This is the
821 * one of the first before_shmem_exit callbacks we register; thus, this
822 * will be one the last things we do before low-level modules like the
823 * buffer manager begin to close down. We need to have this in place
824 * before we begin our first transaction --- if we fail during the
825 * initialization transaction, as is entirely possible, we need the
826 * AbortTransaction call to clean up.
827 */
829
830 /* The autovacuum launcher is done here */
832 {
833 /* fill in the remainder of this entry in the PgBackendStatus array */
835
836 return;
837 }
838
839 /*
840 * Start a new transaction here before first access to db.
841 */
842 if (!bootstrap)
843 {
844 /* statement_timestamp must be set for timeouts to work correctly */
847
848 /*
849 * transaction_isolation will have been set to the default by the
850 * above. If the default is "serializable", and we are in hot
851 * standby, we will fail if we don't change it to something lower.
852 * Fortunately, "read committed" is plenty good enough.
853 */
855 }
856
857 /*
858 * Perform client authentication if necessary, then figure out our
859 * postgres user ID, and see if we are a superuser.
860 *
861 * In standalone mode, autovacuum worker processes and slot sync worker
862 * process, we use a fixed ID, otherwise we figure it out from the
863 * authenticated user name.
864 */
866 {
868 am_superuser = true;
869 }
870 else if (!IsUnderPostmaster)
871 {
873 am_superuser = true;
876 (errcode(ERRCODE_UNDEFINED_OBJECT),
877 errmsg("no roles are defined in this database system"),
878 errhint("You should immediately run CREATE USER \"%s\" SUPERUSER;.",
879 username != NULL ? username : "postgres")));
880 }
881 else if (AmBackgroundWorkerProcess())
882 {
883 if (username == NULL && !OidIsValid(useroid))
884 {
886 am_superuser = true;
887 }
888 else
889 {
891 (flags & INIT_PG_OVERRIDE_ROLE_LOGIN) != 0);
892 am_superuser = superuser();
893 }
894 }
895 else
896 {
897 /* normal multiuser case */
898 Assert(MyProcPort != NULL);
900 InitializeSessionUserId(username, useroid, false);
901 /* ensure that auth_method is actually valid, aka authn_id is not NULL */
905 am_superuser = superuser();
906 }
907
908 /* Report any SSL/GSS details for the session. */
909 if (MyProcPort != NULL)
910 {
911 Assert(!bootstrap);
912
914 }
915
916 /*
917 * Binary upgrades only allowed super-user connections
918 */
919 if (IsBinaryUpgrade && !am_superuser)
920 {
922 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
923 errmsg("must be superuser to connect in binary upgrade mode")));
924 }
925
926 /*
927 * The last few regular connection slots are reserved for superusers and
928 * roles with privileges of pg_use_reserved_connections. We do not apply
929 * these limits to background processes, since they all have their own
930 * pools of PGPROC slots.
931 *
932 * Note: At this point, the new backend has already claimed a proc struct,
933 * so we must check whether the number of free slots is strictly less than
934 * the reserved connection limits.
935 */
936 if (AmRegularBackendProcess() && !am_superuser &&
939 {
942 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
943 errmsg("remaining connection slots are reserved for roles with the %s attribute",
944 "SUPERUSER")));
945
946 if (!has_privs_of_role(GetUserId(), ROLE_PG_USE_RESERVED_CONNECTIONS))
948 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
949 errmsg("remaining connection slots are reserved for roles with privileges of the \"%s\" role",
950 "pg_use_reserved_connections")));
951 }
952
953 /* Check replication permissions needed for walsender processes. */
954 if (am_walsender)
955 {
956 Assert(!bootstrap);
957
960 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
961 errmsg("permission denied to start WAL sender"),
962 errdetail("Only roles with the %s attribute may start a WAL sender process.",
963 "REPLICATION")));
964 }
965
966 /*
967 * If this is a plain walsender only supporting physical replication, we
968 * don't want to connect to any particular database. Just finish the
969 * backend startup by processing any options from the startup packet, and
970 * we're done.
971 */
973 {
974 /* process any options passed in the startup packet */
975 if (MyProcPort != NULL)
976 process_startup_options(MyProcPort, am_superuser);
977
978 /* Apply PostAuthDelay as soon as we've read all options */
979 if (PostAuthDelay > 0)
980 pg_usleep(PostAuthDelay * 1000000L);
981
982 /* initialize client encoding */
984
985 /* fill in the remainder of this entry in the PgBackendStatus array */
987
988 /* close the transaction we started above */
990
991 return;
992 }
993
994 /*
995 * Set up the global variables holding database id and default tablespace.
996 * But note we won't actually try to touch the database just yet.
997 *
998 * We take a shortcut in the bootstrap case, otherwise we have to look up
999 * the db's entry in pg_database.
1000 */
1001 if (bootstrap)
1002 {
1003 dboid = Template1DbOid;
1004 MyDatabaseTableSpace = DEFAULTTABLESPACE_OID;
1005 }
1006 else if (in_dbname != NULL)
1007 {
1008 HeapTuple tuple;
1009 Form_pg_database dbform;
1010
1011 tuple = GetDatabaseTuple(in_dbname);
1012 if (!HeapTupleIsValid(tuple))
1013 ereport(FATAL,
1014 (errcode(ERRCODE_UNDEFINED_DATABASE),
1015 errmsg("database \"%s\" does not exist", in_dbname)));
1016 dbform = (Form_pg_database) GETSTRUCT(tuple);
1017 dboid = dbform->oid;
1018 }
1019 else if (!OidIsValid(dboid))
1020 {
1021 /*
1022 * If this is a background worker not bound to any particular
1023 * database, we're done now. Everything that follows only makes sense
1024 * if we are bound to a specific database. We do need to close the
1025 * transaction we started before returning.
1026 */
1027 if (!bootstrap)
1028 {
1031 }
1032 return;
1033 }
1034
1035 /*
1036 * Now, take a writer's lock on the database we are trying to connect to.
1037 * If there is a concurrently running DROP DATABASE on that database, this
1038 * will block us until it finishes (and has committed its update of
1039 * pg_database).
1040 *
1041 * Note that the lock is not held long, only until the end of this startup
1042 * transaction. This is OK since we will advertise our use of the
1043 * database in the ProcArray before dropping the lock (in fact, that's the
1044 * next thing to do). Anyone trying a DROP DATABASE after this point will
1045 * see us in the array once they have the lock. Ordering is important for
1046 * this because we don't want to advertise ourselves as being in this
1047 * database until we have the lock; otherwise we create what amounts to a
1048 * deadlock with CountOtherDBBackends().
1049 *
1050 * Note: use of RowExclusiveLock here is reasonable because we envision
1051 * our session as being a concurrent writer of the database. If we had a
1052 * way of declaring a session as being guaranteed-read-only, we could use
1053 * AccessShareLock for such sessions and thereby not conflict against
1054 * CREATE DATABASE.
1055 */
1056 if (!bootstrap)
1057 LockSharedObject(DatabaseRelationId, dboid, 0, RowExclusiveLock);
1058
1059 /*
1060 * Recheck pg_database to make sure the target database hasn't gone away.
1061 * If there was a concurrent DROP DATABASE, this ensures we will die
1062 * cleanly without creating a mess.
1063 */
1064 if (!bootstrap)
1065 {
1066 HeapTuple tuple;
1067 Form_pg_database datform;
1068
1069 tuple = GetDatabaseTupleByOid(dboid);
1070 if (HeapTupleIsValid(tuple))
1071 datform = (Form_pg_database) GETSTRUCT(tuple);
1072
1073 if (!HeapTupleIsValid(tuple) ||
1074 (in_dbname && namestrcmp(&datform->datname, in_dbname)))
1075 {
1076 if (in_dbname)
1077 ereport(FATAL,
1078 (errcode(ERRCODE_UNDEFINED_DATABASE),
1079 errmsg("database \"%s\" does not exist", in_dbname),
1080 errdetail("It seems to have just been dropped or renamed.")));
1081 else
1082 ereport(FATAL,
1083 (errcode(ERRCODE_UNDEFINED_DATABASE),
1084 errmsg("database %u does not exist", dboid)));
1085 }
1086
1087 strlcpy(dbname, NameStr(datform->datname), sizeof(dbname));
1088
1089 if (database_is_invalid_form(datform))
1090 {
1091 ereport(FATAL,
1092 errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1093 errmsg("cannot connect to invalid database \"%s\"", dbname),
1094 errhint("Use DROP DATABASE to drop invalid databases."));
1095 }
1096
1097 MyDatabaseTableSpace = datform->dattablespace;
1098 MyDatabaseHasLoginEventTriggers = datform->dathasloginevt;
1099 /* pass the database name back to the caller */
1100 if (out_dbname)
1101 strcpy(out_dbname, dbname);
1102 }
1103
1104 /*
1105 * Now that we rechecked, we are certain to be connected to a database and
1106 * thus can set MyDatabaseId.
1107 *
1108 * It is important that MyDatabaseId only be set once we are sure that the
1109 * target database can no longer be concurrently dropped or renamed. For
1110 * example, without this guarantee, pgstat_update_dbstats() could create
1111 * entries for databases that were just dropped in the pgstat shutdown
1112 * callback, which could confuse other code paths like the autovacuum
1113 * scheduler.
1114 */
1115 MyDatabaseId = dboid;
1116
1117 /*
1118 * Now we can mark our PGPROC entry with the database ID.
1119 *
1120 * We assume this is an atomic store so no lock is needed; though actually
1121 * things would work fine even if it weren't atomic. Anyone searching the
1122 * ProcArray for this database's ID should hold the database lock, so they
1123 * would not be executing concurrently with this store. A process looking
1124 * for another database's ID could in theory see a chance match if it read
1125 * a partially-updated databaseId value; but as long as all such searches
1126 * wait and retry, as in CountOtherDBBackends(), they will certainly see
1127 * the correct value on their next try.
1128 */
1130
1131 /*
1132 * We established a catalog snapshot while reading pg_authid and/or
1133 * pg_database; but until we have set up MyDatabaseId, we won't react to
1134 * incoming sinval messages for unshared catalogs, so we won't realize it
1135 * if the snapshot has been invalidated. Assume it's no good anymore.
1136 */
1138
1139 /*
1140 * Now we should be able to access the database directory safely. Verify
1141 * it's there and looks reasonable.
1142 */
1144
1145 if (!bootstrap)
1146 {
1147 if (access(fullpath, F_OK) == -1)
1148 {
1149 if (errno == ENOENT)
1150 ereport(FATAL,
1151 (errcode(ERRCODE_UNDEFINED_DATABASE),
1152 errmsg("database \"%s\" does not exist",
1153 dbname),
1154 errdetail("The database subdirectory \"%s\" is missing.",
1155 fullpath)));
1156 else
1157 ereport(FATAL,
1159 errmsg("could not access directory \"%s\": %m",
1160 fullpath)));
1161 }
1162
1163 ValidatePgVersion(fullpath);
1164 }
1165
1166 SetDatabasePath(fullpath);
1167 pfree(fullpath);
1168
1169 /*
1170 * It's now possible to do real access to the system catalogs.
1171 *
1172 * Load relcache entries for the system catalogs. This must create at
1173 * least the minimum set of "nailed-in" cache entries.
1174 */
1176
1177 /* set up ACL framework (so CheckMyDatabase can check permissions) */
1179
1180 /*
1181 * Re-read the pg_database row for our database, check permissions and set
1182 * up database-specific GUC settings. We can't do this until all the
1183 * database-access infrastructure is up. (Also, it wants to know if the
1184 * user is a superuser, so the above stuff has to happen first.)
1185 */
1186 if (!bootstrap)
1187 CheckMyDatabase(dbname, am_superuser,
1188 (flags & INIT_PG_OVERRIDE_ALLOW_CONNS) != 0);
1189
1190 /*
1191 * Now process any command-line switches and any additional GUC variable
1192 * settings passed in the startup packet. We couldn't do this before
1193 * because we didn't know if client is a superuser.
1194 */
1195 if (MyProcPort != NULL)
1196 process_startup_options(MyProcPort, am_superuser);
1197
1198 /* Process pg_db_role_setting options */
1200
1201 /* Apply PostAuthDelay as soon as we've read all options */
1202 if (PostAuthDelay > 0)
1203 pg_usleep(PostAuthDelay * 1000000L);
1204
1205 /*
1206 * Initialize various default states that can't be set up until we've
1207 * selected the active user and gotten the right GUC settings.
1208 */
1209
1210 /* set default namespace search path */
1212
1213 /* initialize client encoding */
1215
1216 /* Initialize this backend's session state. */
1218
1219 /*
1220 * If this is an interactive session, load any libraries that should be
1221 * preloaded at backend start. Since those are determined by GUCs, this
1222 * can't happen until GUC settings are complete, but we want it to happen
1223 * during the initial transaction in case anything that requires database
1224 * access needs to be done.
1225 */
1226 if ((flags & INIT_PG_LOAD_SESSION_LIBS) != 0)
1228
1229 /* fill in the remainder of this entry in the PgBackendStatus array */
1230 if (!bootstrap)
1232
1233 /* close the transaction we started above */
1234 if (!bootstrap)
1236}
void initialize_acl(void)
Definition: acl.c:5040
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:5284
void pgstat_bestart_security(void)
void pgstat_bestart_initial(void)
void pgstat_beinit(void)
void pgstat_bestart_final(void)
#define OidIsValid(objectId)
Definition: c.h:774
bool database_is_invalid_form(Form_pg_database datform)
Definition: dbcommands.c:3214
int errcode_for_file_access(void)
Definition: elog.c:877
#define DEBUG3
Definition: elog.h:28
bool MyDatabaseHasLoginEventTriggers
Definition: globals.c:98
int MyCancelKeyLength
Definition: globals.c:53
bool IsBinaryUpgrade
Definition: globals.c:121
Oid MyDatabaseTableSpace
Definition: globals.c:96
uint8 MyCancelKey[MAX_CANCEL_KEY_LENGTH]
Definition: globals.c:52
struct Port * MyProcPort
Definition: globals.c:51
const char * hba_authname(UserAuth auth_method)
Definition: hba.c:3141
static char * username
Definition: initdb.c:153
#define INJECTION_POINT(name, arg)
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:1088
#define RowExclusiveLock
Definition: lockdefs.h:38
void InitializeClientEncoding(void)
Definition: mbutils.c:282
void pfree(void *pointer)
Definition: mcxt.c:1594
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:476
#define INIT_PG_LOAD_SESSION_LIBS
Definition: miscadmin.h:498
#define AmAutoVacuumWorkerProcess()
Definition: miscadmin.h:382
#define AmBackgroundWorkerProcess()
Definition: miscadmin.h:383
#define AmLogicalSlotSyncWorkerProcess()
Definition: miscadmin.h:385
#define AmAutoVacuumLauncherProcess()
Definition: miscadmin.h:381
#define INIT_PG_OVERRIDE_ROLE_LOGIN
Definition: miscadmin.h:500
#define INIT_PG_OVERRIDE_ALLOW_CONNS
Definition: miscadmin.h:499
void InitializeSessionUserId(const char *rolename, Oid roleid, bool bypass_login_check)
Definition: miscinit.c:710
void InitializeSystemUser(const char *authn_id, const char *auth_method)
Definition: miscinit.c:874
void InitializeSessionUserIdStandalone(void)
Definition: miscinit.c:840
void process_session_preload_libraries(void)
Definition: miscinit.c:1865
Oid GetSessionUserId(void)
Definition: miscinit.c:508
void SetDatabasePath(const char *path)
Definition: miscinit.c:283
ClientConnectionInfo MyClientConnectionInfo
Definition: miscinit.c:1018
bool has_rolreplication(Oid roleid)
Definition: miscinit.c:688
void ValidatePgVersion(const char *path)
Definition: miscinit.c:1718
int namestrcmp(Name name, const char *str)
Definition: name.c:247
void InitializeSearchPath(void)
Definition: namespace.c:4806
#define NAMEDATALEN
void pgstat_before_server_shutdown(int code, Datum arg)
Definition: pgstat.c:560
void InitPlanCache(void)
Definition: plancache.c:146
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:99
static void ShutdownPostgres(int code, Datum arg)
Definition: postinit.c:1342
static void IdleInTransactionSessionTimeoutHandler(void)
Definition: postinit.c:1399
static void LockTimeoutHandler(void)
Definition: postinit.c:1381
static void IdleStatsUpdateTimeoutHandler(void)
Definition: postinit.c:1415
static void process_settings(Oid databaseid, Oid roleid)
Definition: postinit.c:1308
static void IdleSessionTimeoutHandler(void)
Definition: postinit.c:1407
static void process_startup_options(Port *port, bool am_superuser)
Definition: postinit.c:1243
static void StatementTimeoutHandler(void)
Definition: postinit.c:1359
static void CheckMyDatabase(const char *name, bool am_superuser, bool override_allow_connections)
Definition: postinit.c:323
static bool ThereIsAtLeastOneRole(void)
Definition: postinit.c:1434
static void PerformAuthentication(Port *port)
Definition: postinit.c:194
static void ClientCheckTimeoutHandler(void)
Definition: postinit.c:1423
static HeapTuple GetDatabaseTuple(const char *dbname)
Definition: postinit.c:105
static HeapTuple GetDatabaseTupleByOid(Oid dboid)
Definition: postinit.c:148
static void TransactionTimeoutHandler(void)
Definition: postinit.c:1391
int ReservedConnections
Definition: postmaster.c:230
int SuperuserReservedConnections
Definition: postmaster.c:229
short access
Definition: preproc-type.c:36
void ProcSignalInit(const uint8 *cancel_key, int cancel_key_len)
Definition: procsignal.c:166
void RelationCacheInitializePhase3(void)
Definition: relcache.c:4107
void RelationCacheInitialize(void)
Definition: relcache.c:4002
void RelationCacheInitializePhase2(void)
Definition: relcache.c:4048
char * GetDatabasePath(Oid dbOid, Oid spcOid)
Definition: relpath.c:110
void ReleaseAuxProcessResources(bool isCommit)
Definition: resowner.c:1016
ResourceOwner CurrentResourceOwner
Definition: resowner.c:173
void CreateAuxProcessResourceOwner(void)
Definition: resowner.c:996
void InitializeSession(void)
Definition: session.c:54
void pg_usleep(long microsec)
Definition: signal.c:53
void SharedInvalBackendInit(bool sendOnly)
Definition: sinvaladt.c:272
void InvalidateCatalogSnapshot(void)
Definition: snapmgr.c:454
bool HaveNFreeProcs(int n, int *nfree)
Definition: proc.c:782
void CheckDeadLockAlert(void)
Definition: proc.c:1873
void InitProcessPhase2(void)
Definition: proc.c:580
const char * authn_id
Definition: libpq-be.h:99
UserAuth auth_method
Definition: libpq-be.h:105
Oid databaseId
Definition: proc.h:224
bool superuser(void)
Definition: superuser.c:46
void InitCatalogCache(void)
Definition: syscache.c:110
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:123
bool am_db_walsender
Definition: walsender.c:126
void StartTransactionCommand(void)
Definition: xact.c:3071
int XactIsoLevel
Definition: xact.c:79
void SetCurrentStatementStartTimestamp(void)
Definition: xact.c:914
void CommitTransactionCommand(void)
Definition: xact.c:3169
#define XACT_READ_COMMITTED
Definition: xact.h:37
void StartupXLOG(void)
Definition: xlog.c:5469
void ShutdownXLOG(int code, Datum arg)
Definition: xlog.c:6654

References am_db_walsender, am_walsender, AmAutoVacuumLauncherProcess, AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, AmLogicalSlotSyncWorkerProcess, AmRegularBackendProcess, 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(), 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(), INJECTION_POINT, InvalidateCatalogSnapshot(), IsBinaryUpgrade, IsBootstrapProcessingMode, IsUnderPostmaster, LOCK_TIMEOUT, LockSharedObject(), LockTimeoutHandler(), MyCancelKey, MyCancelKeyLength, MyClientConnectionInfo, MyDatabaseHasLoginEventTriggers, MyDatabaseId, MyDatabaseTableSpace, MyProc, MyProcPort, NAMEDATALEN, NameStr, namestrcmp(), OidIsValid, PerformAuthentication(), pfree(), pg_usleep(), pgstat_before_server_shutdown(), pgstat_beinit(), pgstat_bestart_final(), pgstat_bestart_initial(), pgstat_bestart_security(), 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 AutoVacLauncherMain(), AutoVacWorkerMain(), BackgroundWorkerInitializeConnection(), BackgroundWorkerInitializeConnectionByOid(), BootstrapModeMain(), PostgresMain(), and ReplSlotSyncWorkerMain().

◆ LockTimeoutHandler()

static void LockTimeoutHandler ( void  )
static

Definition at line 1381 of file postinit.c.

1382{
1383#ifdef HAVE_SETSID
1384 /* try to signal whole process group */
1385 kill(-MyProcPid, SIGINT);
1386#endif
1387 kill(MyProcPid, SIGINT);
1388}
int MyProcPid
Definition: globals.c:47
#define kill(pid, sig)
Definition: win32_port.h:493

References kill, and MyProcPid.

Referenced by InitPostgres().

◆ PerformAuthentication()

static void PerformAuthentication ( Port *  port )
static

Definition at line 194 of file postinit.c.

195{
196 /* This should be set already, but let's make sure */
197 ClientAuthInProgress = true; /* limit visibility of log messages */
198
199 /*
200 * In EXEC_BACKEND case, we didn't inherit the contents of pg_hba.conf
201 * etcetera from the postmaster, and have to load them ourselves.
202 *
203 * FIXME: [fork/exec] Ugh. Is there a way around this overhead?
204 */
205#ifdef EXEC_BACKEND
206
207 /*
208 * load_hba() and load_ident() want to work within the PostmasterContext,
209 * so create that if it doesn't exist (which it won't). We'll delete it
210 * again later, in PostgresMain.
211 */
212 if (PostmasterContext == NULL)
214 "Postmaster",
216
217 if (!load_hba())
218 {
219 /*
220 * It makes no sense to continue if we fail to load the HBA file,
221 * since there is no way to connect to the database in this case.
222 */
224 /* translator: %s is a configuration file */
225 (errmsg("could not load %s", HbaFileName)));
226 }
227
228 if (!load_ident())
229 {
230 /*
231 * It is ok to continue if we fail to load the IDENT file, although it
232 * means that you cannot log in using any of the authentication
233 * methods that need a user name mapping. load_ident() already logged
234 * the details of error to the log.
235 */
236 }
237#endif
238
239 /* Capture authentication start time for logging */
241
242 /*
243 * Set up a timeout in case a buggy or malicious client fails to respond
244 * during authentication. Since we're inside a transaction and might do
245 * database access, we have to use the statement_timeout infrastructure.
246 */
248
249 /*
250 * Now perform authentication exchange.
251 */
252 set_ps_display("authentication");
253 ClientAuthentication(port); /* might not return, if failure */
254
255 /*
256 * Done with authentication. Disable the timeout, and log if needed.
257 */
259
260 /* Capture authentication end time for logging */
262
264 {
265 StringInfoData logmsg;
266
267 initStringInfo(&logmsg);
268 if (am_walsender)
269 appendStringInfo(&logmsg, _("replication connection authorized: user=%s"),
270 port->user_name);
271 else
272 appendStringInfo(&logmsg, _("connection authorized: user=%s"),
273 port->user_name);
274 if (!am_walsender)
275 appendStringInfo(&logmsg, _(" database=%s"), port->database_name);
276
277 if (port->application_name != NULL)
278 appendStringInfo(&logmsg, _(" application_name=%s"),
279 port->application_name);
280
281#ifdef USE_SSL
282 if (port->ssl_in_use)
283 appendStringInfo(&logmsg, _(" SSL enabled (protocol=%s, cipher=%s, bits=%d)"),
287#endif
288#ifdef ENABLE_GSS
289 if (port->gss)
290 {
291 const char *princ = be_gssapi_get_princ(port);
292
293 if (princ)
294 appendStringInfo(&logmsg,
295 _(" GSS (authenticated=%s, encrypted=%s, delegated_credentials=%s, principal=%s)"),
296 be_gssapi_get_auth(port) ? _("yes") : _("no"),
297 be_gssapi_get_enc(port) ? _("yes") : _("no"),
298 be_gssapi_get_delegation(port) ? _("yes") : _("no"),
299 princ);
300 else
301 appendStringInfo(&logmsg,
302 _(" GSS (authenticated=%s, encrypted=%s, delegated_credentials=%s)"),
303 be_gssapi_get_auth(port) ? _("yes") : _("no"),
304 be_gssapi_get_enc(port) ? _("yes") : _("no"),
305 be_gssapi_get_delegation(port) ? _("yes") : _("no"));
306 }
307#endif
308
309 ereport(LOG, errmsg_internal("%s", logmsg.data));
310 pfree(logmsg.data);
311 }
312
313 set_ps_display("startup");
314
315 ClientAuthInProgress = false; /* client_min_messages is active now */
316}
void ClientAuthentication(Port *port)
Definition: auth.c:379
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1645
uint32 log_connections
ConnectionTiming conn_timing
@ LOG_CONNECTION_AUTHORIZATION
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:1161
_
#define _(x)
Definition: elog.c:91
#define LOG
Definition: elog.h:31
char * HbaFileName
Definition: guc_tables.c:557
bool load_ident(void)
Definition: hba.c:3039
bool load_hba(void)
Definition: hba.c:2645
MemoryContext TopMemoryContext
Definition: mcxt.c:166
MemoryContext PostmasterContext
Definition: mcxt.c:168
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
static int port
Definition: pg_regress.c:115
bool ClientAuthInProgress
Definition: postmaster.c:372
int AuthenticationTimeout
Definition: postmaster.c:241
static void set_ps_display(const char *activity)
Definition: ps_status.h:40
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:145
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
TimestampTz auth_start
TimestampTz auth_end
char * data
Definition: stringinfo.h:48
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(), ConnectionTiming::auth_end, ConnectionTiming::auth_start, 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, conn_timing, StringInfoData::data, disable_timeout(), enable_timeout_after(), ereport, errmsg(), errmsg_internal(), FATAL, GetCurrentTimestamp(), HbaFileName, initStringInfo(), load_hba(), load_ident(), LOG, LOG_CONNECTION_AUTHORIZATION, 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 496 of file postinit.c.

497{
499
500 initStringInfo(&s);
501
502 while (*optstr)
503 {
504 bool last_was_escape = false;
505
506 resetStringInfo(&s);
507
508 /* skip over leading space */
509 while (isspace((unsigned char) *optstr))
510 optstr++;
511
512 if (*optstr == '0円')
513 break;
514
515 /*
516 * Parse a single option, stopping at the first space, unless it's
517 * escaped.
518 */
519 while (*optstr)
520 {
521 if (isspace((unsigned char) *optstr) && !last_was_escape)
522 break;
523
524 if (!last_was_escape && *optstr == '\\')
525 last_was_escape = true;
526 else
527 {
528 last_was_escape = false;
529 appendStringInfoChar(&s, *optstr);
530 }
531
532 optstr++;
533 }
534
535 /* now store the option in the next argv[] position */
536 argv[(*argcp)++] = pstrdup(s.data);
537 }
538
539 pfree(s.data);
540}
char * pstrdup(const char *in)
Definition: mcxt.c:1759
void resetStringInfo(StringInfo str)
Definition: stringinfo.c:126
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:242

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 1308 of file postinit.c.

1309{
1310 Relation relsetting;
1311 Snapshot snapshot;
1312
1313 if (!IsUnderPostmaster)
1314 return;
1315
1316 relsetting = table_open(DbRoleSettingRelationId, AccessShareLock);
1317
1318 /* read all the settings under the same snapshot for efficiency */
1319 snapshot = RegisterSnapshot(GetCatalogSnapshot(DbRoleSettingRelationId));
1320
1321 /* Later settings are ignored if set earlier. */
1322 ApplySetting(snapshot, databaseid, roleid, relsetting, PGC_S_DATABASE_USER);
1323 ApplySetting(snapshot, InvalidOid, roleid, relsetting, PGC_S_USER);
1324 ApplySetting(snapshot, databaseid, InvalidOid, relsetting, PGC_S_DATABASE);
1325 ApplySetting(snapshot, InvalidOid, InvalidOid, relsetting, PGC_S_GLOBAL);
1326
1327 UnregisterSnapshot(snapshot);
1328 table_close(relsetting, AccessShareLock);
1329}
@ PGC_S_GLOBAL
Definition: guc.h:118
@ PGC_S_DATABASE
Definition: guc.h:119
@ PGC_S_DATABASE_USER
Definition: guc.h:121
@ PGC_S_USER
Definition: guc.h:120
void ApplySetting(Snapshot snapshot, Oid databaseid, Oid roleid, Relation relsetting, GucSource source)
#define InvalidOid
Definition: postgres_ext.h:37
Snapshot GetCatalogSnapshot(Oid relid)
Definition: snapmgr.c:384
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:864
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:822

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 1243 of file postinit.c.

1244{
1245 GucContext gucctx;
1246 ListCell *gucopts;
1247
1248 gucctx = am_superuser ? PGC_SU_BACKEND : PGC_BACKEND;
1249
1250 /*
1251 * First process any command-line switches that were included in the
1252 * startup packet, if we are in a regular backend.
1253 */
1254 if (port->cmdline_options != NULL)
1255 {
1256 /*
1257 * The maximum possible number of commandline arguments that could
1258 * come from port->cmdline_options is (strlen + 1) / 2; see
1259 * pg_split_opts().
1260 */
1261 char **av;
1262 int maxac;
1263 int ac;
1264
1265 maxac = 2 + (strlen(port->cmdline_options) + 1) / 2;
1266
1267 av = (char **) palloc(maxac * sizeof(char *));
1268 ac = 0;
1269
1270 av[ac++] = "postgres";
1271
1272 pg_split_opts(av, &ac, port->cmdline_options);
1273
1274 av[ac] = NULL;
1275
1276 Assert(ac < maxac);
1277
1278 (void) process_postgres_switches(ac, av, gucctx, NULL);
1279 }
1280
1281 /*
1282 * Process any additional GUC variable settings passed in startup packet.
1283 * These are handled exactly like command-line variables.
1284 */
1285 gucopts = list_head(port->guc_options);
1286 while (gucopts)
1287 {
1288 char *name;
1289 char *value;
1290
1291 name = lfirst(gucopts);
1292 gucopts = lnext(port->guc_options, gucopts);
1293
1294 value = lfirst(gucopts);
1295 gucopts = lnext(port->guc_options, gucopts);
1296
1298 }
1299}
@ PGC_S_CLIENT
Definition: guc.h:122
GucContext
Definition: guc.h:72
@ PGC_SU_BACKEND
Definition: guc.h:76
static struct @169 value
void * palloc(Size size)
Definition: mcxt.c:1365
#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:3798
void pg_split_opts(char **argv, int *argcp, const char *optstr)
Definition: postinit.c:496
struct @10::@11 av[32]
Definition: pg_list.h:46

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 1342 of file postinit.c.

1343{
1344 /* Make sure we've killed any active transaction */
1346
1347 /*
1348 * User locks are not released by transaction end, so be sure to release
1349 * them explicitly.
1350 */
1352}
void LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
Definition: lock.c:2307
#define USER_LOCKMETHOD
Definition: lock.h:128
void AbortOutOfAnyTransaction(void)
Definition: xact.c:4874

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

Referenced by InitPostgres().

◆ StatementTimeoutHandler()

static void StatementTimeoutHandler ( void  )
static

Definition at line 1359 of file postinit.c.

1360{
1361 int sig = SIGINT;
1362
1363 /*
1364 * During authentication the timeout is used to deal with
1365 * authentication_timeout - we want to quit in response to such timeouts.
1366 */
1368 sig = SIGTERM;
1369
1370#ifdef HAVE_SETSID
1371 /* try to signal whole process group */
1372 kill(-MyProcPid, sig);
1373#endif
1374 kill(MyProcPid, sig);
1375}
static int sig
Definition: pg_ctl.c:80

References ClientAuthInProgress, kill, MyProcPid, and sig.

Referenced by InitPostgres().

◆ ThereIsAtLeastOneRole()

static bool ThereIsAtLeastOneRole ( void  )
static

Definition at line 1434 of file postinit.c.

1435{
1436 Relation pg_authid_rel;
1437 TableScanDesc scan;
1438 bool result;
1439
1440 pg_authid_rel = table_open(AuthIdRelationId, AccessShareLock);
1441
1442 scan = table_beginscan_catalog(pg_authid_rel, 0, NULL);
1443 result = (heap_getnext(scan, ForwardScanDirection) != NULL);
1444
1445 table_endscan(scan);
1446 table_close(pg_authid_rel, AccessShareLock);
1447
1448 return result;
1449}
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1346
@ ForwardScanDirection
Definition: sdir.h:28
TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, ScanKeyData *key)
Definition: tableam.c:113
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:985

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 1391 of file postinit.c.

1392{
1394 InterruptPending = true;
1396}
volatile sig_atomic_t TransactionTimeoutPending
Definition: globals.c:38

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

Referenced by InitPostgres().

AltStyle によって変換されたページ (->オリジナル) /