PostgreSQL Source Code  git master
postinit.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * postinit.c
4  * postgres initialization utilities
5  *
6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/utils/init/postinit.c
12  *
13  *
14  *-------------------------------------------------------------------------
15  */
16 #include "postgres.h"
17 
18 #include <ctype.h>
19 #include <fcntl.h>
20 #include <unistd.h>
21 
22 #include "access/genam.h"
23 #include "access/heapam.h"
24 #include "access/htup_details.h"
25 #include "access/session.h"
26 #include "access/tableam.h"
27 #include "access/xact.h"
28 #include "access/xlog.h"
29 #include "access/xloginsert.h"
30 #include "catalog/namespace.h"
31 #include "catalog/pg_authid.h"
32 #include "catalog/pg_collation.h"
33 #include "catalog/pg_database.h"
35 #include "catalog/pg_tablespace.h"
36 #include "libpq/auth.h"
37 #include "libpq/libpq-be.h"
38 #include "mb/pg_wchar.h"
39 #include "miscadmin.h"
40 #include "pgstat.h"
41 #include "postmaster/autovacuum.h"
42 #include "postmaster/postmaster.h"
43 #include "replication/slot.h"
44 #include "replication/slotsync.h"
45 #include "replication/walsender.h"
46 #include "storage/bufmgr.h"
47 #include "storage/fd.h"
48 #include "storage/ipc.h"
49 #include "storage/lmgr.h"
50 #include "storage/proc.h"
51 #include "storage/procarray.h"
52 #include "storage/procsignal.h"
53 #include "storage/sinvaladt.h"
54 #include "storage/smgr.h"
55 #include "storage/sync.h"
56 #include "tcop/tcopprot.h"
57 #include "utils/acl.h"
58 #include "utils/builtins.h"
59 #include "utils/fmgroids.h"
60 #include "utils/guc_hooks.h"
61 #include "utils/memutils.h"
62 #include "utils/pg_locale.h"
63 #include "utils/portal.h"
64 #include "utils/ps_status.h"
65 #include "utils/snapmgr.h"
66 #include "utils/syscache.h"
67 #include "utils/timeout.h"
68 
69 static HeapTuple GetDatabaseTuple(const char *dbname);
70 static HeapTuple GetDatabaseTupleByOid(Oid dboid);
71 static void PerformAuthentication(Port *port);
72 static void CheckMyDatabase(const char *name, bool am_superuser, bool override_allow_connections);
73 static void ShutdownPostgres(int code, Datum arg);
74 static void StatementTimeoutHandler(void);
75 static void LockTimeoutHandler(void);
77 static void TransactionTimeoutHandler(void);
78 static void IdleSessionTimeoutHandler(void);
79 static void IdleStatsUpdateTimeoutHandler(void);
80 static void ClientCheckTimeoutHandler(void);
81 static bool ThereIsAtLeastOneRole(void);
82 static void process_startup_options(Port *port, bool am_superuser);
83 static void process_settings(Oid databaseid, Oid roleid);
84 
85 
86 /*** InitPostgres support ***/
87 
88 
89 /*
90  * GetDatabaseTuple -- fetch the pg_database row for a database
91  *
92  * This is used during backend startup when we don't yet have any access to
93  * system catalogs in general. In the worst case, we can seqscan pg_database
94  * using nothing but the hard-wired descriptor that relcache.c creates for
95  * pg_database. In more typical cases, relcache.c was able to load
96  * descriptors for both pg_database and its indexes from the shared relcache
97  * cache file, and so we can do an indexscan. criticalSharedRelcachesBuilt
98  * tells whether we got the cached descriptors.
99  */
100 static HeapTuple
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 }
139 
140 /*
141  * GetDatabaseTupleByOid -- as above, but search by database OID
142  */
143 static HeapTuple
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 }
182 
183 
184 /*
185  * PerformAuthentication -- authenticate a remote client
186  *
187  * returns: nothing. Will not return at all if there's any failure.
188  */
189 static void
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 }
307 
308 
309 /*
310  * CheckMyDatabase -- fetch information from the pg_database entry for our DB
311  */
312 static void
313 CheckMyDatabase(const char *name, bool am_superuser, bool override_allow_connections)
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 }
504 
505 
506 /*
507  * pg_split_opts -- split a string of options and append it to an argv array
508  *
509  * The caller is responsible for ensuring the argv array is large enough. The
510  * maximum possible number of arguments added by this routine is
511  * (strlen(optstr) + 1) / 2.
512  *
513  * Because some option values can contain spaces we allow escaping using
514  * backslashes, with \\ representing a literal backslash.
515  */
516 void
517 pg_split_opts(char **argv, int *argcp, const char *optstr)
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 }
562 
563 /*
564  * Initialize MaxBackends value from config options.
565  *
566  * This must be called after modules have had the chance to alter GUCs in
567  * shared_preload_libraries and before shared memory size is determined.
568  *
569  * Note that in EXEC_BACKEND environment, the value is passed down from
570  * postmaster to subprocesses via BackendParameters in SubPostmasterMain; only
571  * postmaster itself and processes not under postmaster control should call
572  * this.
573  */
574 void
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 }
587 
588 /*
589  * GUC check_hook for max_connections
590  */
591 bool
593 {
594  if (*newval + autovacuum_max_workers + 1 +
596  return false;
597  return true;
598 }
599 
600 /*
601  * GUC check_hook for autovacuum_max_workers
602  */
603 bool
605 {
606  if (MaxConnections + *newval + 1 +
608  return false;
609  return true;
610 }
611 
612 /*
613  * GUC check_hook for max_worker_processes
614  */
615 bool
617 {
620  return false;
621  return true;
622 }
623 
624 /*
625  * GUC check_hook for max_wal_senders
626  */
627 bool
629 {
632  return false;
633  return true;
634 }
635 
636 /*
637  * Early initialization of a backend (either standalone or under postmaster).
638  * This happens even before InitPostgres.
639  *
640  * This is separate from InitPostgres because it is also called by auxiliary
641  * processes, such as the background writer process, which may not call
642  * InitPostgres at all.
643  */
644 void
645 BaseInit(void)
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 }
691 
692 
693 /* --------------------------------
694  * InitPostgres
695  * Initialize POSTGRES.
696  *
697  * Parameters:
698  * in_dbname, dboid: specify database to connect to, as described below
699  * username, useroid: specify role to connect as, as described below
700  * flags:
701  * - INIT_PG_LOAD_SESSION_LIBS to honor [session|local]_preload_libraries.
702  * - INIT_PG_OVERRIDE_ALLOW_CONNS to connect despite !datallowconn.
703  * - INIT_PG_OVERRIDE_ROLE_LOGIN to connect despite !rolcanlogin.
704  * out_dbname: optional output parameter, see below; pass NULL if not used
705  *
706  * The database can be specified by name, using the in_dbname parameter, or by
707  * OID, using the dboid parameter. Specify NULL or InvalidOid respectively
708  * for the unused parameter. If dboid is provided, the actual database
709  * name can be returned to the caller in out_dbname. If out_dbname isn't
710  * NULL, it must point to a buffer of size NAMEDATALEN.
711  *
712  * Similarly, the role can be passed by name, using the username parameter,
713  * or by OID using the useroid parameter.
714  *
715  * In bootstrap mode the database and username parameters are NULL/InvalidOid.
716  * The autovacuum launcher process doesn't specify these parameters either,
717  * because it only goes far enough to be able to read pg_database; it doesn't
718  * connect to any particular database. An autovacuum worker specifies a
719  * database but not a username; conversely, a physical walsender specifies
720  * username but not database.
721  *
722  * By convention, INIT_PG_LOAD_SESSION_LIBS should be passed in "flags" in
723  * "interactive" sessions (including standalone backends), but not in
724  * background processes such as autovacuum. Note in particular that it
725  * shouldn't be true in parallel worker processes; those have another
726  * mechanism for replicating their leader's set of loaded libraries.
727  *
728  * We expect that InitProcess() was already called, so we already have a
729  * PGPROC struct ... but it's not completely filled in yet.
730  *
731  * Note:
732  * Be very careful with the order of calls in the InitPostgres function.
733  * --------------------------------
734  */
735 void
736 InitPostgres(const char *in_dbname, Oid dboid,
737  const char *username, Oid useroid,
738  bits32 flags,
739  char *out_dbname)
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 }
1255 
1256 /*
1257  * Process any command-line switches and any additional GUC variable
1258  * settings passed in the startup packet.
1259  */
1260 static void
1261 process_startup_options(Port *port, bool am_superuser)
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 }
1318 
1319 /*
1320  * Load GUC settings from pg_db_role_setting.
1321  *
1322  * We try specific settings for the database/role combination, as well as
1323  * general for this database and for this user.
1324  */
1325 static void
1326 process_settings(Oid databaseid, Oid roleid)
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 }
1348 
1349 /*
1350  * Backend-shutdown callback. Do cleanup that we want to be sure happens
1351  * before all the supporting modules begin to nail their doors shut via
1352  * their own callbacks.
1353  *
1354  * User-level cleanup, such as temp-relation removal and UNLISTEN, happens
1355  * via separate callbacks that execute before this one. We don't combine the
1356  * callbacks because we still want this one to happen if the user-level
1357  * cleanup fails.
1358  */
1359 static void
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 }
1371 
1372 
1373 /*
1374  * STATEMENT_TIMEOUT handler: trigger a query-cancel interrupt.
1375  */
1376 static void
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 }
1394 
1395 /*
1396  * LOCK_TIMEOUT handler: trigger a query-cancel interrupt.
1397  */
1398 static void
1400 {
1401 #ifdef HAVE_SETSID
1402  /* try to signal whole process group */
1403  kill(-MyProcPid, SIGINT);
1404 #endif
1405  kill(MyProcPid, SIGINT);
1406 }
1407 
1408 static void
1410 {
1412  InterruptPending = true;
1413  SetLatch(MyLatch);
1414 }
1415 
1416 static void
1418 {
1420  InterruptPending = true;
1421  SetLatch(MyLatch);
1422 }
1423 
1424 static void
1426 {
1428  InterruptPending = true;
1429  SetLatch(MyLatch);
1430 }
1431 
1432 static void
1434 {
1436  InterruptPending = true;
1437  SetLatch(MyLatch);
1438 }
1439 
1440 static void
1442 {
1444  InterruptPending = true;
1445  SetLatch(MyLatch);
1446 }
1447 
1448 /*
1449  * Returns true if at least one role is defined in this database cluster.
1450  */
1451 static bool
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 }
void initialize_acl(void)
Definition: acl.c:4890
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:5134
@ ACLCHECK_OK
Definition: acl.h:183
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3888
void ClientAuthentication(Port *port)
Definition: auth.c:382
int autovacuum_max_workers
Definition: autovacuum.c:117
void pgstat_beinit(void)
void pgstat_bestart(void)
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)
void InitBufferPoolAccess(void)
Definition: bufmgr.c:3565
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define NameStr(name)
Definition: c.h:746
#define Assert(condition)
Definition: c.h:858
uint32 bits32
Definition: c.h:515
#define OidIsValid(objectId)
Definition: c.h:775
bool database_is_invalid_form(Form_pg_database datform)
Definition: dbcommands.c:3178
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
void DebugFileOpen(void)
Definition: elog.c:2075
int errcode_for_file_access(void)
Definition: elog.c:880
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 _(x)
Definition: elog.c:90
#define LOG
Definition: elog.h:31
#define DEBUG3
Definition: elog.h:28
#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
void InitFileAccess(void)
Definition: fd.c:903
void InitTemporaryFileAccess(void)
Definition: fd.c:933
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
volatile sig_atomic_t IdleStatsUpdateTimeoutPending
Definition: globals.c:40
bool MyDatabaseHasLoginEventTriggers
Definition: globals.c:95
volatile sig_atomic_t InterruptPending
Definition: globals.c:30
volatile sig_atomic_t IdleSessionTimeoutPending
Definition: globals.c:37
bool IsBinaryUpgrade
Definition: globals.c:118
volatile sig_atomic_t IdleInTransactionSessionTimeoutPending
Definition: globals.c:35
volatile sig_atomic_t TransactionTimeoutPending
Definition: globals.c:36
int MyProcPid
Definition: globals.c:45
bool IsUnderPostmaster
Definition: globals.c:117
int MaxConnections
Definition: globals.c:140
Oid MyDatabaseTableSpace
Definition: globals.c:93
int MaxBackends
Definition: globals.c:143
struct Port * MyProcPort
Definition: globals.c:49
struct Latch * MyLatch
Definition: globals.c:60
volatile sig_atomic_t CheckClientConnectionPending
Definition: globals.c:33
int max_worker_processes
Definition: globals.c:141
Oid MyDatabaseId
Definition: globals.c:91
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4285
#define newval
GucSource
Definition: guc.h:108
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
@ PGC_S_GLOBAL
Definition: guc.h:114
@ PGC_S_DATABASE
Definition: guc.h:115
@ PGC_S_CLIENT
Definition: guc.h:118
@ PGC_S_DATABASE_USER
Definition: guc.h:117
@ PGC_S_USER
Definition: guc.h:116
GucContext
Definition: guc.h:68
@ PGC_INTERNAL
Definition: guc.h:69
@ PGC_SU_BACKEND
Definition: guc.h:72
@ PGC_BACKEND
Definition: guc.h:73
char * HbaFileName
Definition: guc_tables.c:541
bool load_ident(void)
Definition: hba.c:2959
const char * hba_authname(UserAuth auth_method)
Definition: hba.c:3061
bool load_hba(void)
Definition: hba.c:2583
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1251
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:776
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
static struct @155 value
static char * datlocale
Definition: initdb.c:149
static char * locale
Definition: initdb.c:140
void before_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:337
void SetLatch(Latch *latch)
Definition: latch.c:632
void LockSharedObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
Definition: lmgr.c:1083
void LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
Definition: lock.c:2147
#define USER_LOCKMETHOD
Definition: lock.h:126
#define AccessShareLock
Definition: lockdefs.h:36
#define RowExclusiveLock
Definition: lockdefs.h:38
void InitializeClientEncoding(void)
Definition: mbutils.c:281
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1267
void SetDatabaseEncoding(int encoding)
Definition: mbutils.c:1161
char * pstrdup(const char *in)
Definition: mcxt.c:1695
void pfree(void *pointer)
Definition: mcxt.c:1520
MemoryContext TopMemoryContext
Definition: mcxt.c:149
MemoryContext PostmasterContext
Definition: mcxt.c:151
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1682
void * palloc(Size size)
Definition: mcxt.c:1316
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:454
#define INIT_PG_LOAD_SESSION_LIBS
Definition: miscadmin.h:476
#define AmAutoVacuumWorkerProcess()
Definition: miscadmin.h:375
#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 GetUserId(void)
Definition: miscinit.c:514
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 ACL_CONNECT
Definition: parsenodes.h:87
void * arg
#define NAMEDATALEN
static int sig
Definition: pg_ctl.c:79
FormData_pg_database * Form_pg_database
Definition: pg_database.h:96
void ApplySetting(Snapshot snapshot, Oid databaseid, Oid roleid, Relation relsetting, GucSource source)
#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 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
static int port
Definition: pg_regress.c:116
static rewind_source * source
Definition: pg_rewind.c:89
const char * username
Definition: pgbench.c:296
void pgstat_initialize(void)
Definition: pgstat.c:537
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
void process_postgres_switches(int argc, char *argv[], GucContext ctx, const char **dbname)
Definition: postgres.c:3790
int PostAuthDelay
Definition: postgres.c:101
uintptr_t Datum
Definition: postgres.h:64
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
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
bool check_autovacuum_max_workers(int *newval, void **extra, GucSource source)
Definition: postinit.c:604
void InitializeMaxBackends(void)
Definition: postinit.c:575
void pg_split_opts(char **argv, int *argcp, const char *optstr)
Definition: postinit.c:517
static void IdleStatsUpdateTimeoutHandler(void)
Definition: postinit.c:1433
static void process_settings(Oid databaseid, Oid roleid)
Definition: postinit.c:1326
void BaseInit(void)
Definition: postinit.c:645
bool check_max_connections(int *newval, void **extra, GucSource source)
Definition: postinit.c:592
static void IdleSessionTimeoutHandler(void)
Definition: postinit.c:1425
bool check_max_wal_senders(int *newval, void **extra, GucSource source)
Definition: postinit.c:628
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
bool check_max_worker_processes(int *newval, void **extra, GucSource source)
Definition: postinit.c:616
static HeapTuple GetDatabaseTuple(const char *dbname)
Definition: postinit.c:101
void InitPostgres(const char *in_dbname, Oid dboid, const char *username, Oid useroid, bits32 flags, char *out_dbname)
Definition: postinit.c:736
static HeapTuple GetDatabaseTupleByOid(Oid dboid)
Definition: postinit.c:144
static void TransactionTimeoutHandler(void)
Definition: postinit.c:1409
bool Log_connections
Definition: postmaster.c:231
int ReservedConnections
Definition: postmaster.c:217
bool ClientAuthInProgress
Definition: postmaster.c:350
int AuthenticationTimeout
Definition: postmaster.c:228
int SuperuserReservedConnections
Definition: postmaster.c:216
#define MAX_BACKENDS
Definition: postmaster.h:98
short access
Definition: preproc-type.c:36
int CountDBConnections(Oid databaseid)
Definition: procarray.c:3616
void ProcSignalInit(void)
Definition: procsignal.c:158
static void set_ps_display(const char *activity)
Definition: ps_status.h:40
bool criticalSharedRelcachesBuilt
Definition: relcache.c:146
void RelationCacheInitializePhase3(void)
Definition: relcache.c:4099
void RelationCacheInitialize(void)
Definition: relcache.c:3994
void RelationCacheInitializePhase2(void)
Definition: relcache.c:4040
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
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:12596
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
@ ForwardScanDirection
Definition: sdir.h:28
struct @10::@11 av[32]
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 ReplicationSlotInitialize(void)
Definition: slot.c:224
void smgrinit(void)
Definition: smgr.c:154
Snapshot GetTransactionSnapshot(void)
Definition: snapmgr.c:216
Snapshot GetCatalogSnapshot(Oid relid)
Definition: snapmgr.c:352
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:836
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:794
void InvalidateCatalogSnapshot(void)
Definition: snapmgr.c:422
PGPROC * MyProc
Definition: proc.c:66
bool HaveNFreeProcs(int n, int *nfree)
Definition: proc.c:687
void CheckDeadLockAlert(void)
Definition: proc.c:1840
void InitProcessPhase2(void)
Definition: proc.c:488
#define BTEqualStrategyNumber
Definition: stratnum.h:31
char * dbname
Definition: streamutil.c:52
void resetStringInfo(StringInfo str)
Definition: stringinfo.c:78
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:97
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:194
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
const char * authn_id
Definition: libpq-be.h:103
UserAuth auth_method
Definition: libpq-be.h:109
Oid databaseId
Definition: proc.h:203
Definition: libpq-be.h:133
struct pg_locale_struct::@151::@152 builtin
union pg_locale_struct::@151 info
bool deterministic
Definition: pg_locale.h:76
bool superuser(void)
Definition: superuser.c:46
void InitSync(void)
Definition: sync.c:124
void InitCatalogCache(void)
Definition: syscache.c:107
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
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, struct ScanKeyData *key)
Definition: tableam.c:112
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:1019
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
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
const char * name
bool am_walsender
Definition: walsender.c:115
bool am_db_walsender
Definition: walsender.c:118
int max_wal_senders
Definition: walsender.c:121
#define kill(pid, sig)
Definition: win32_port.h:485
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
void AbortOutOfAnyTransaction(void)
Definition: xact.c:4811
#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
void InitXLogInsert(void)
Definition: xloginsert.c:1348