/* ------------------------------------------------------------------------- * * bootstrap.c * routines to support running openGauss in 'bootstrap' mode * bootstrap mode is used to create the initial template database * * Portions Copyright (c) 2020 Huawei Technologies Co.,Ltd. * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 2010-2012 Postgres-XC Development Group * * IDENTIFICATION * src/backend/bootstrap/bootstrap.c * * ------------------------------------------------------------------------- */ #include "postgres.h" #include "knl/knl_variable.h" #include "pgstat.h" #include #include #include #ifdef HAVE_GETOPT_H #include #endif #include "access/tableam.h" #include "bootstrap/bootstrap.h" #include "catalog/index.h" #include "catalog/pg_collation.h" #include "catalog/pg_proc.h" #include "catalog/pg_type.h" #include "catalog/pg_class.h" #include "libpq/pqsignal.h" #include "miscadmin.h" #include "pgstat.h" #include "nodes/makefuncs.h" #include "postmaster/aiocompleter.h" #include "postmaster/bgwriter.h" #include "postmaster/pagewriter.h" #include "postmaster/cbmwriter.h" #include "postmaster/startup.h" #include "postmaster/twophasecleaner.h" #include "postmaster/licensechecker.h" #include "postmaster/walwriter.h" #include "postmaster/lwlockmonitor.h" #include "replication/walreceiver.h" #include "replication/datareceiver.h" #include "storage/buf/bufmgr.h" #include "storage/ipc.h" #include "storage/proc.h" #include "tcop/tcopprot.h" #include "threadpool/threadpool.h" #include "utils/builtins.h" #include "utils/fmgroids.h" #include "utils/guc_storage.h" #include "utils/memutils.h" #include "utils/plog.h" #include "utils/postinit.h" #include "utils/ps_status.h" #include "utils/rel.h" #include "utils/rel_gs.h" #include "utils/relmapper.h" #include "utils/snapmgr.h" #include "access/parallel_recovery/page_redo.h" #ifdef PGXC #include "nodes/nodes.h" #include "pgxc/poolmgr.h" #endif #include "gssignal/gs_signal.h" #include "storage/file/fio_device.h" #include "storage/dss/dss_adaptor.h" #include "storage/dss/dss_log.h" #define ALLOC(t, c) ((t*)selfpalloc0((unsigned)(c) * sizeof(t))) static void CheckerModeMain(void); static void BootstrapModeMain(void); static void bootstrap_signals(void); static Form_pg_attribute AllocateAttribute(void); static Oid gettype(char* type); static void cleanup(void); /* * Basic information associated with each type. This is used before * pg_type is filled, so it has to cover the datatypes used as column types * in the core "bootstrapped" catalogs. * * XXX several of these input/output functions do catalog scans * (e.g., F_REGPROCIN scans pg_proc). this obviously creates some * order dependencies in the catalog creation process. */ struct typinfo { char name[NAMEDATALEN]; Oid oid; Oid elem; int16 len; bool byval; char align; char storage; Oid collation; Oid inproc; Oid outproc; }; static const struct typinfo TypInfo[] = {{"bool", BOOLOID, 0, 1, true, 'c', 'p', InvalidOid, F_BOOLIN, F_BOOLOUT}, {"bytea", BYTEAOID, 0, -1, false, 'i', 'x', InvalidOid, F_BYTEAIN, F_BYTEAOUT}, {"char", CHAROID, 0, 1, true, 'c', 'p', InvalidOid, F_CHARIN, F_CHAROUT}, {"int1", INT1OID, 0, 1, true, 'c', 'p', InvalidOid, F_INT1IN, F_INT1OUT}, {"int2", INT2OID, 0, 2, true, 's', 'p', InvalidOid, F_INT2IN, F_INT2OUT}, {"int4", INT4OID, 0, 4, true, 'i', 'p', InvalidOid, F_INT4IN, F_INT4OUT}, {"float4", FLOAT4OID, 0, 4, FLOAT4PASSBYVAL, 'i', 'p', InvalidOid, F_FLOAT4IN, F_FLOAT4OUT}, {"name", NAMEOID, CHAROID, NAMEDATALEN, false, 'c', 'p', InvalidOid, F_NAMEIN, F_NAMEOUT}, {"regclass", REGCLASSOID, 0, 4, true, 'i', 'p', InvalidOid, F_REGCLASSIN, F_REGCLASSOUT}, {"regproc", REGPROCOID, 0, 4, true, 'i', 'p', InvalidOid, F_REGPROCIN, F_REGPROCOUT}, {"regtype", REGTYPEOID, 0, 4, true, 'i', 'p', InvalidOid, F_REGTYPEIN, F_REGTYPEOUT}, {"text", TEXTOID, 0, -1, false, 'i', 'x', DEFAULT_COLLATION_OID, F_TEXTIN, F_TEXTOUT}, {"oid", OIDOID, 0, 4, true, 'i', 'p', InvalidOid, F_OIDIN, F_OIDOUT}, {"tid", TIDOID, 0, 6, false, 's', 'p', InvalidOid, F_TIDIN, F_TIDOUT}, {"xid", XIDOID, 0, 8, FLOAT8PASSBYVAL, 'd', 'p', InvalidOid, F_XIDIN, F_XIDOUT}, {"xid32", SHORTXIDOID, 0, 4, FLOAT4PASSBYVAL, 'i', 'p', InvalidOid, F_XIDIN4, F_XIDOUT4}, {"cid", CIDOID, 0, 4, true, 'i', 'p', InvalidOid, F_CIDIN, F_CIDOUT}, {"pg_node_tree", PGNODETREEOID, 0, -1, false, 'i', 'x', DEFAULT_COLLATION_OID, F_PG_NODE_TREE_IN, F_PG_NODE_TREE_OUT}, {"int2vector", INT2VECTOROID, INT2OID, -1, false, 'i', 'p', InvalidOid, F_INT2VECTORIN, F_INT2VECTOROUT}, {"oidvector", OIDVECTOROID, OIDOID, -1, false, 'i', 'p', InvalidOid, F_OIDVECTORIN, F_OIDVECTOROUT}, {"_int2", INT2ARRAYOID, INT2OID, -1, false, 'i', 'x', InvalidOid, F_ARRAY_IN, F_ARRAY_OUT}, {"_int4", INT4ARRAYOID, INT4OID, -1, false, 'i', 'x', InvalidOid, F_ARRAY_IN, F_ARRAY_OUT}, {"_text", 1009, TEXTOID, -1, false, 'i', 'x', DEFAULT_COLLATION_OID, F_ARRAY_IN, F_ARRAY_OUT}, {"_oid", 1028, OIDOID, -1, false, 'i', 'x', InvalidOid, F_ARRAY_IN, F_ARRAY_OUT}, {"_char", 1002, CHAROID, -1, false, 'i', 'x', InvalidOid, F_ARRAY_IN, F_ARRAY_OUT}, {"_aclitem", 1034, ACLITEMOID, -1, false, 'i', 'x', InvalidOid, F_ARRAY_IN, F_ARRAY_OUT}, {"raw", RAWOID, 0, -1, false, 'i', 'x', InvalidOid, F_BYTEAIN, F_BYTEAOUT}, {"oidvector_extend", OIDVECTOREXTENDOID, OIDOID, -1, false, 'i', 'x', InvalidOid, F_OIDVECTORIN_EXTEND, F_OIDVECTOROUT_EXTEND}, {"int2vector_extend", INT2VECTOREXTENDOID, INT2OID, -1, false, 'i', 'x', InvalidOid, F_INT2VECTORIN, F_INT2VECTOROUT}}; static const int n_types = sizeof(TypInfo) / sizeof(struct typinfo); struct typmap { /* a hack */ Oid am_oid; FormData_pg_type am_typ; }; static THR_LOCAL Datum values[MAXATTR]; /* current row's attribute values */ static THR_LOCAL bool Nulls[MAXATTR]; /* * At bootstrap time, we first declare all the indices to be built, and * then build them. The IndexList structure stores enough information * to allow us to build the indices after they've been declared. */ typedef struct _IndexList { Oid il_heap; Oid il_ind; IndexInfo* il_info; struct _IndexList* il_next; } IndexList; /* * BootStrapProcessMain * * The main entry point for auxiliary processes, such as the bgwriter, * walwriter, walreceiver, bootstrapper and the shared memory checker code. * * This code is here just because of historical reasons. */ void BootStrapProcessMain(int argc, char* argv[]) { char* progName = argv[0]; int flag; char* userDoption = NULL; OptParseContext optCtxt; errno_t errorno = EOK; /* * initialize globals */ PostmasterPid = gs_thread_self(); t_thrd.proc_cxt.MyProcPid = gs_thread_self(); t_thrd.proc_cxt.MyStartTime = time(NULL); /* * Initialize random() for the first time, like PostmasterMain() would. * In a regular IsUnderPostmaster backend, BackendRun() computes a * high-entropy seed before any user query. Fewer distinct initial seeds * can occur here. */ srandom((unsigned int)(t_thrd.proc_cxt.MyProcPid ^ (unsigned int)t_thrd.proc_cxt.MyStartTime)); t_thrd.proc_cxt.MyProgName = "BootStrap"; /* * Fire up essential subsystems: error and memory management * * If we are running under the postmaster, this is done already. */ if (!IsUnderPostmaster) { MemoryContextInit(); init_plog_global_mem(); } /* Compute paths, if we didn't inherit them from postmaster */ if (my_exec_path[0] == '\0') { if (find_my_exec(progName, my_exec_path) < 0) ereport(FATAL, (errmsg("%s: could not locate my own executable path", progName))); } /* * process command arguments */ /* Set defaults, to be overriden by explicit options below */ if (!IsUnderPostmaster) { InitializeGUCOptions(); } /* Ignore the initial --boot argument, if present */ if (argc > 1 && strcmp(argv[1], "--boot") == 0) { argv++; argc--; } /* If no -x argument, we are a CheckerProcess */ t_thrd.bootstrap_cxt.MyAuxProcType = CheckerProcess; initOptParseContext(&optCtxt); while ((flag = getopt_r(argc, argv, "B:c:d:D:FGr:x:g:-:", &optCtxt)) != -1) { switch (flag) { case 'B': SetConfigOption("shared_buffers", optCtxt.optarg, PGC_POSTMASTER, PGC_S_ARGV); break; case 'D': userDoption = optCtxt.optarg; break; case 'd': { int debugStrLen = strlen("debug") + strlen(optCtxt.optarg) + 1; /* Turn on debugging for the bootstrap process. */ char* debugstr = (char*)palloc(debugStrLen); errorno = snprintf_s(debugstr, debugStrLen, debugStrLen - 1, "debug%s", optCtxt.optarg); securec_check_ss(errorno, "\0", "\0"); SetConfigOption("log_min_messages", debugstr, PGC_POSTMASTER, PGC_S_ARGV); SetConfigOption("client_min_messages", debugstr, PGC_POSTMASTER, PGC_S_ARGV); pfree(debugstr); } break; case 'F': SetConfigOption("fsync", "false", PGC_POSTMASTER, PGC_S_ARGV); break; case 'G': EnableInitDBSegment = true; break; case 'g': SetConfigOption("xlog_file_path", optCtxt.optarg, PGC_POSTMASTER, PGC_S_ARGV); break; case 'r': errorno = strcpy_s(t_thrd.proc_cxt.OutputFileName, MAXPGPATH, optCtxt.optarg); securec_check(errorno, "\0", "\0"); break; case 'x': t_thrd.bootstrap_cxt.MyAuxProcType = (AuxProcType)atoi(optCtxt.optarg); break; case 'c': case '-': { char* name = NULL; char* value = NULL; ParseLongOption(optCtxt.optarg, &name, &value); if (value == NULL) { if (flag == '-') ereport( ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("--%s requires a value", optCtxt.optarg))); else ereport( ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("-c %s requires a value", optCtxt.optarg))); } SetConfigOption(name, value, PGC_POSTMASTER, PGC_S_ARGV); pfree(name); if (value != NULL) pfree(value); break; } default: write_stderr("Try \"%s --help\" for more information.\n", progName); proc_exit(1); break; } } if (argc != optCtxt.optind) { write_stderr("%s: invalid command-line arguments\n", progName); proc_exit(1); } /* Acquire configuration parameters, unless inherited from postmaster */ if (!IsUnderPostmaster) { if (!SelectConfigFiles(userDoption, progName)) { proc_exit(1); } InitializeNumLwLockPartitions(); } g_instance.global_sysdbcache.Init(INSTANCE_GET_MEM_CXT_GROUP(MEMORY_CONTEXT_DEFAULT)); CreateLocalSysDBCache(); /* Validate we have been given a reasonable-looking t_thrd.proc_cxt.DataDir */ Assert(t_thrd.proc_cxt.DataDir); ValidatePgVersion(t_thrd.proc_cxt.DataDir); /* Change into t_thrd.proc_cxt.DataDir (if under postmaster, should be done already) */ if (!IsUnderPostmaster) ChangeToDataDir(); /* If standalone, create lockfile for data directory */ if (!IsUnderPostmaster) CreateDataDirLockFile(false); /* Callback function for dss operator */ if (dss_device_init(g_instance.attr.attr_storage.dss_attr.ss_dss_conn_path, g_instance.attr.attr_storage.dss_attr.ss_enable_dss) != DSS_SUCCESS) { ereport(PANIC, (errmsg("failed to init dss device"))); proc_exit(1); } if (ENABLE_DSS) { dss_log_init(); } initDSSConf(); SetProcessingMode(BootstrapProcessing); u_sess->attr.attr_common.IgnoreSystemIndexes = true; BaseInit(); pgstat_initialize(); pgstat_bestart(); if (!IsUnderPostmaster) { ShareStorageInit(); } /* * XLOG operations */ SetProcessingMode(NormalProcessing); switch (t_thrd.bootstrap_cxt.MyAuxProcType) { case CheckerProcess: /* don't set signals, they're useless here */ CheckerModeMain(); proc_exit(1); /* should never return */ case BootstrapProcess: bootstrap_signals(); BootStrapXLOG(); MemoryContextUnSeal(t_thrd.top_mem_cxt); BootstrapModeMain(); MemoryContextSeal(t_thrd.top_mem_cxt); proc_exit(1); /* should never return */ default: ereport(PANIC, (errmsg("unrecognized process type: %d", (int)t_thrd.bootstrap_cxt.MyAuxProcType))); proc_exit(1); } } /* * In shared memory checker mode, all we really want to do is create shared * memory and semaphores (just to prove we can do it with the current GUC * settings). Since, in fact, that was already done by BaseInit(), * we have nothing more to do here. */ static void CheckerModeMain(void) { proc_exit(0); } /* * The main entry point for running the backend in bootstrap mode * * The bootstrap mode is used to initialize the template database. * The bootstrap backend doesn't speak SQL, but instead expects * commands in a special bootstrap language. */ static void BootstrapModeMain(void) { int i; Assert(!IsUnderPostmaster); SetProcessingMode(BootstrapProcessing); /* * Do backend-like initialization for bootstrap mode */ InitProcess(); t_thrd.proc_cxt.PostInit->SetDatabaseAndUser(NULL, InvalidOid, NULL); t_thrd.proc_cxt.PostInit->InitBootstrap(); /* Initialize stuff for bootstrap-file processing */ for (i = 0; i < MAXATTR; i++) { t_thrd.bootstrap_cxt.attrtypes[i] = NULL; Nulls[i] = false; } /* * Process bootstrap input. */ boot_yyparse(); /* * We should now know about all mapped relations, so it's okay to write * out the initial relation mapping files. */ RelationMapFinishBootstrap(); /* Clean up and exit */ cleanup(); proc_exit(0); } /* ---------------------------------------------------------------- * misc functions * ---------------------------------------------------------------- */ /* * Set up signal handling for a bootstrap process */ static void bootstrap_signals(void) { if (IsUnderPostmaster) { /* * Properly accept or ignore signals the postmaster might send us */ (void)gspqsignal(SIGHUP, SIG_IGN); (void)gspqsignal(SIGINT, SIG_IGN); /* ignore query-cancel */ (void)gspqsignal(SIGTERM, die); (void)gspqsignal(SIGQUIT, quickdie); (void)gspqsignal(SIGALRM, SIG_IGN); (void)gspqsignal(SIGPIPE, SIG_IGN); (void)gspqsignal(SIGUSR1, SIG_IGN); (void)gspqsignal(SIGUSR2, SIG_IGN); /* * Reset some signals that are accepted by postmaster but not here */ (void)gspqsignal(SIGCHLD, SIG_DFL); (void)gspqsignal(SIGTTIN, SIG_DFL); (void)gspqsignal(SIGTTOU, SIG_DFL); (void)gspqsignal(SIGCONT, SIG_DFL); (void)gspqsignal(SIGWINCH, SIG_DFL); /* * Unblock signals (they were blocked when the postmaster forked us) */ gs_signal_setmask(&t_thrd.libpq_cxt.UnBlockSig, NULL); (void)gs_signal_unblock_sigusr2(); } else { /* Set up appropriately for interactive use */ (void)gspqsignal(SIGHUP, die); (void)gspqsignal(SIGINT, die); (void)gspqsignal(SIGTERM, die); (void)gspqsignal(SIGQUIT, die); (void)gs_signal_unblock_sigusr2(); } } /* ---------------------------------------------------------------- * MANUAL BACKEND INTERACTIVE INTERFACE COMMANDS * ---------------------------------------------------------------- */ /* ---------------- * boot_openrel * ---------------- */ void boot_openrel(char* relname) { int i; struct typmap** app; Relation rel; TableScanDesc scan; HeapTuple tup; errno_t rc; if (strlen(relname) >= NAMEDATALEN) relname[NAMEDATALEN - 1] = '\0'; if (t_thrd.bootstrap_cxt.Typ == NULL) { /* We can now load the pg_type data */ rel = heap_open(TypeRelationId, NoLock); scan = tableam_scan_begin(rel, SnapshotNow, 0, NULL); i = 0; while ((tup = (HeapTuple) tableam_scan_getnexttuple(scan, ForwardScanDirection)) != NULL) ++i; tableam_scan_end(scan); app = t_thrd.bootstrap_cxt.Typ = ALLOC(struct typmap*, i + 1); while (i-- > 0) *app++ = ALLOC(struct typmap, 1); *app = NULL; scan = tableam_scan_begin(rel, SnapshotNow, 0, NULL); app = t_thrd.bootstrap_cxt.Typ; while ((tup = (HeapTuple) tableam_scan_getnexttuple(scan, ForwardScanDirection)) != NULL) { (*app)->am_oid = HeapTupleGetOid(tup); rc = memcpy_s((char*)&(*app)->am_typ, sizeof((*app)->am_typ), (char*)GETSTRUCT(tup), sizeof((*app)->am_typ)); securec_check(rc, "\0", "\0"); app++; } tableam_scan_end(scan); heap_close(rel, NoLock); } if (t_thrd.bootstrap_cxt.boot_reldesc != NULL) closerel(NULL); ereport(DEBUG4, (errmsg("open relation %s, attrsize %d", relname, (int)ATTRIBUTE_FIXED_PART_SIZE))); t_thrd.bootstrap_cxt.boot_reldesc = heap_openrv(makeRangeVar(NULL, relname, -1), NoLock); t_thrd.bootstrap_cxt.numattr = RelationGetNumberOfAttributes(t_thrd.bootstrap_cxt.boot_reldesc); for (i = 0; i < t_thrd.bootstrap_cxt.numattr; i++) { if (t_thrd.bootstrap_cxt.attrtypes[i] == NULL) t_thrd.bootstrap_cxt.attrtypes[i] = AllocateAttribute(); rc = memmove_s((char*)t_thrd.bootstrap_cxt.attrtypes[i], ATTRIBUTE_FIXED_PART_SIZE, (char*)t_thrd.bootstrap_cxt.boot_reldesc->rd_att->attrs[i], ATTRIBUTE_FIXED_PART_SIZE); securec_check(rc, "\0", "\0"); { Form_pg_attribute at = t_thrd.bootstrap_cxt.attrtypes[i]; ereport(DEBUG4, (errmsg("create attribute %d name %s len %d num %d type %u", i, NameStr(at->attname), at->attlen, at->attnum, at->atttypid))); } } } /* ---------------- * closerel * ---------------- */ void closerel(char* name) { if (name != NULL) { if (t_thrd.bootstrap_cxt.boot_reldesc) { if (strcmp(RelationGetRelationName(t_thrd.bootstrap_cxt.boot_reldesc), name) != 0) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("close of %s when %s was expected", name, RelationGetRelationName(t_thrd.bootstrap_cxt.boot_reldesc)))); } else ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("close of %s before any relation was opened", name))); } if (t_thrd.bootstrap_cxt.boot_reldesc == NULL) ereport(ERROR, (errcode(ERRCODE_UNEXPECTED_NULL_VALUE), errmsg("no open relation to close"))); else { ereport(DEBUG4, (errmsg("close relation %s", RelationGetRelationName(t_thrd.bootstrap_cxt.boot_reldesc)))); heap_close(t_thrd.bootstrap_cxt.boot_reldesc, NoLock); t_thrd.bootstrap_cxt.boot_reldesc = NULL; } } /* * fix roluseft ,rolmonitoradmin, roloperatoradmin and rolpolicyadmin column of pg_authid to notnull */ static void fix_attr_notnull(const char* name, int attnum) { if (strncmp(name, "roluseft", strlen("roluseft")) == 0 && strlen(name) == strlen("roluseft")) { t_thrd.bootstrap_cxt.attrtypes[attnum]->attnotnull = true; } if (strncmp(name, "rolmonitoradmin", strlen("rolmonitoradmin")) == 0 && strlen(name) == strlen("rolmonitoradmin")) { t_thrd.bootstrap_cxt.attrtypes[attnum]->attnotnull = true; } if (strncmp(name, "roloperatoradmin", strlen("roloperatoradmin")) == 0 && strlen(name) == strlen("roloperatoradmin")) { t_thrd.bootstrap_cxt.attrtypes[attnum]->attnotnull = true; } if (strncmp(name, "rolpolicyadmin", strlen("rolpolicyadmin")) == 0 && strlen(name) == strlen("rolpolicyadmin")) { t_thrd.bootstrap_cxt.attrtypes[attnum]->attnotnull = true; } } /* ---------------- * DEFINEATTR() * * define a pair * if there are n fields in a relation to be created, this routine * will be called n times * ---------------- */ void DefineAttr(const char* name, char* type, int attnum) { Oid typeoid; if (t_thrd.bootstrap_cxt.boot_reldesc != NULL) { ereport(WARNING, (errmsg("no open relations allowed with CREATE command"))); closerel(NULL); } if (t_thrd.bootstrap_cxt.attrtypes[attnum] == NULL) t_thrd.bootstrap_cxt.attrtypes[attnum] = AllocateAttribute(); MemSet(t_thrd.bootstrap_cxt.attrtypes[attnum], 0, ATTRIBUTE_FIXED_PART_SIZE); (void)namestrcpy(&t_thrd.bootstrap_cxt.attrtypes[attnum]->attname, name); ereport(DEBUG4, (errmsg("column %s %s", NameStr(t_thrd.bootstrap_cxt.attrtypes[attnum]->attname), type))); t_thrd.bootstrap_cxt.attrtypes[attnum]->attnum = attnum + 1; /* fillatt */ typeoid = gettype(type); if (t_thrd.bootstrap_cxt.Typ != NULL) { t_thrd.bootstrap_cxt.attrtypes[attnum]->atttypid = t_thrd.bootstrap_cxt.Ap->am_oid; t_thrd.bootstrap_cxt.attrtypes[attnum]->attlen = t_thrd.bootstrap_cxt.Ap->am_typ.typlen; t_thrd.bootstrap_cxt.attrtypes[attnum]->attbyval = t_thrd.bootstrap_cxt.Ap->am_typ.typbyval; t_thrd.bootstrap_cxt.attrtypes[attnum]->attstorage = t_thrd.bootstrap_cxt.Ap->am_typ.typstorage; t_thrd.bootstrap_cxt.attrtypes[attnum]->attalign = t_thrd.bootstrap_cxt.Ap->am_typ.typalign; t_thrd.bootstrap_cxt.attrtypes[attnum]->attcollation = t_thrd.bootstrap_cxt.Ap->am_typ.typcollation; /* if an array type, assume 1-dimensional attribute */ if (t_thrd.bootstrap_cxt.Ap->am_typ.typelem != InvalidOid && t_thrd.bootstrap_cxt.Ap->am_typ.typlen < 0) t_thrd.bootstrap_cxt.attrtypes[attnum]->attndims = 1; else t_thrd.bootstrap_cxt.attrtypes[attnum]->attndims = 0; } else { t_thrd.bootstrap_cxt.attrtypes[attnum]->atttypid = TypInfo[typeoid].oid; t_thrd.bootstrap_cxt.attrtypes[attnum]->attlen = TypInfo[typeoid].len; t_thrd.bootstrap_cxt.attrtypes[attnum]->attbyval = TypInfo[typeoid].byval; t_thrd.bootstrap_cxt.attrtypes[attnum]->attstorage = TypInfo[typeoid].storage; t_thrd.bootstrap_cxt.attrtypes[attnum]->attalign = TypInfo[typeoid].align; t_thrd.bootstrap_cxt.attrtypes[attnum]->attcollation = TypInfo[typeoid].collation; /* if an array type, assume 1-dimensional attribute */ if (TypInfo[typeoid].elem != InvalidOid && t_thrd.bootstrap_cxt.attrtypes[attnum]->attlen < 0) t_thrd.bootstrap_cxt.attrtypes[attnum]->attndims = 1; else t_thrd.bootstrap_cxt.attrtypes[attnum]->attndims = 0; } t_thrd.bootstrap_cxt.attrtypes[attnum]->attstattarget = -1; t_thrd.bootstrap_cxt.attrtypes[attnum]->attcacheoff = -1; t_thrd.bootstrap_cxt.attrtypes[attnum]->atttypmod = -1; t_thrd.bootstrap_cxt.attrtypes[attnum]->attislocal = true; /* * Mark as "not null" if type is fixed-width and prior columns are too. * This corresponds to case where column can be accessed directly via C * struct declaration. * * oidvector and int2vector are also treated as not-nullable, even though * they are no longer fixed-width. */ #define MARKNOTNULL(att) ((att)->attlen > 0 || (att)->atttypid == OIDVECTOROID || (att)->atttypid == INT2VECTOROID) if (MARKNOTNULL(t_thrd.bootstrap_cxt.attrtypes[attnum])) { int i; for (i = 0; i < attnum; i++) { if (!MARKNOTNULL(t_thrd.bootstrap_cxt.attrtypes[i])) break; } if (i == attnum) t_thrd.bootstrap_cxt.attrtypes[attnum]->attnotnull = true; } // fix partkey/intervaltablespace/intspnum columns of pg_partition to nullable if (strcmp(name, "partkey") == 0 || strcmp(name, "intervaltablespace") == 0 || strcmp(name, "intspnum") == 0) { t_thrd.bootstrap_cxt.attrtypes[attnum]->attnotnull = false; } // fix roluseft ,rolmonitoradmin, roloperatoradmin and rolpolicyadmin column of pg_authid to notnull fix_attr_notnull(name, attnum); } /* ---------------- * ChangePgClassBucketValueForSegment * ---------------- */ static inline void ChangePgClassBucketValueForSegment() { values[Anum_pg_class_relbucket - 1] = ObjectIdGetDatum(VirtualSegmentOid); Nulls[Anum_pg_class_relbucket - 1] = false; } /* ---------------- * InsertOneTuple * * If objectid is not zero, it is a specific OID to assign to the tuple. * Otherwise, an OID will be assigned (if necessary) by heap_insert. * ---------------- */ void InsertOneTuple(Oid objectid) { HeapTuple tuple; TupleDesc tupDesc; int i; ereport(DEBUG4, (errmsg("inserting row oid %u, %d columns", objectid, t_thrd.bootstrap_cxt.numattr))); if (IsBootingPgProc(t_thrd.bootstrap_cxt.boot_reldesc)) { ereport(FATAL, (errmsg("Built-in functions should not be added into pg_proc"))); } if (IsBootingPgClass(t_thrd.bootstrap_cxt.boot_reldesc) && EnableInitDBSegment) { ChangePgClassBucketValueForSegment(); } tupDesc = CreateTupleDesc(t_thrd.bootstrap_cxt.numattr, RelationGetForm(t_thrd.bootstrap_cxt.boot_reldesc)->relhasoids, t_thrd.bootstrap_cxt.attrtypes, t_thrd.bootstrap_cxt.boot_reldesc->rd_tam_type); tuple = (HeapTuple) tableam_tops_form_tuple(tupDesc, values, Nulls, HEAP_TUPLE); if (objectid != (Oid)0) HeapTupleSetOid(tuple, objectid); pfree(tupDesc); /* just free's tupDesc, not the attrtypes */ (void)simple_heap_insert(t_thrd.bootstrap_cxt.boot_reldesc, tuple); tableam_tops_free_tuple(tuple); ereport(DEBUG4, (errmsg("row inserted"))); /* * Reset null markers for next tuple */ for (i = 0; i < t_thrd.bootstrap_cxt.numattr; i++) Nulls[i] = false; } /* ---------------- * InsertOneValue * ---------------- */ void InsertOneValue(char* value, int i) { Oid typoid; int16 typlen; bool typbyval = false; char typalign; char typdelim; Oid typioparam; Oid typinput; Oid typoutput; char* prt = NULL; AssertArg(i >= 0 && i < MAXATTR); ereport(DEBUG4, (errmsg("inserting column %d value \"%s\"", i, value))); typoid = t_thrd.bootstrap_cxt.boot_reldesc->rd_att->attrs[i]->atttypid; boot_get_type_io_data(typoid, &typlen, &typbyval, &typalign, &typdelim, &typioparam, &typinput, &typoutput); values[i] = OidInputFunctionCall(typinput, value, typioparam, -1); prt = OidOutputFunctionCall(typoutput, values[i]); ereport(DEBUG4, (errmsg("inserted -> %s", prt))); pfree(prt); } /* ---------------- * InsertOneNull * ---------------- */ void InsertOneNull(int i) { ereport(DEBUG4, (errmsg("inserting column %d NULL", i))); Assert(i >= 0 && i < MAXATTR); values[i] = PointerGetDatum(NULL); Nulls[i] = true; } /* ---------------- * cleanup * ---------------- */ static void cleanup(void) { if (t_thrd.bootstrap_cxt.boot_reldesc != NULL) closerel(NULL); } /* ---------------- * gettype * * NB: this is really ugly; it will return an integer index into TypInfo[], * and not an OID at all, until the first reference to a type not known in * TypInfo[]. At that point it will read and cache pg_type in the Typ array, * and subsequently return a real OID (and set the global pointer Ap to * point at the found row in Typ). So caller must check whether Typ is * still NULL to determine what the return value is! * ---------------- */ static Oid gettype(char* type) { int i; Relation rel; TableScanDesc scan; HeapTuple tup; struct typmap** app; errno_t rc; if (t_thrd.bootstrap_cxt.Typ != NULL) { for (app = t_thrd.bootstrap_cxt.Typ; *app != NULL; app++) { if (strncmp(NameStr((*app)->am_typ.typname), type, NAMEDATALEN) == 0) { t_thrd.bootstrap_cxt.Ap = *app; return (*app)->am_oid; } } } else { for (i = 0; i < n_types; i++) { if (strncmp(type, TypInfo[i].name, NAMEDATALEN) == 0) return i; } ereport(DEBUG4, (errmsg("external type: %s", type))); rel = heap_open(TypeRelationId, NoLock); scan = tableam_scan_begin(rel, SnapshotNow, 0, NULL); i = 0; while ((tup = (HeapTuple) tableam_scan_getnexttuple(scan, ForwardScanDirection)) != NULL) ++i; tableam_scan_end(scan); app = t_thrd.bootstrap_cxt.Typ = ALLOC(struct typmap*, i + 1); while (i-- > 0) *app++ = ALLOC(struct typmap, 1); *app = NULL; scan = tableam_scan_begin(rel, SnapshotNow, 0, NULL); app = t_thrd.bootstrap_cxt.Typ; while ((tup = (HeapTuple) tableam_scan_getnexttuple(scan, ForwardScanDirection)) != NULL) { (*app)->am_oid = HeapTupleGetOid(tup); rc = memmove_s( (char*)&(*app++)->am_typ, sizeof((*app)->am_typ), (char*)GETSTRUCT(tup), sizeof((*app)->am_typ)); securec_check(rc, "\0", "\0"); } tableam_scan_end(scan); heap_close(rel, NoLock); return gettype(type); } ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("unrecognized type \"%s\"", type))); /* not reached, here to make compiler happy */ return 0; } /* ---------------- * boot_get_type_io_data * * Obtain type I/O information at bootstrap time. This intentionally has * almost the same API as lsyscache.c's get_type_io_data, except that * we only support obtaining the typinput and typoutput routines, not * the binary I/O routines. It is exported so that array_in and array_out * can be made to work during early bootstrap. * ---------------- */ void boot_get_type_io_data(Oid typid, int16* typlen, bool* typbyval, char* typalign, char* typdelim, Oid* typioparam, Oid* typinput, Oid* typoutput) { if (t_thrd.bootstrap_cxt.Typ != NULL) { /* We have the boot-time contents of pg_type, so use it */ struct typmap** app; struct typmap* ap = NULL; app = t_thrd.bootstrap_cxt.Typ; while (*app && (*app)->am_oid != typid) ++app; ap = *app; if (ap == NULL) ereport( ERROR, (errcode(ERRCODE_UNEXPECTED_NULL_VALUE), errmsg("type OID %u not found in Typ list", typid))); *typlen = ap->am_typ.typlen; *typbyval = ap->am_typ.typbyval; *typalign = ap->am_typ.typalign; *typdelim = ap->am_typ.typdelim; /* XXX this logic must match getTypeIOParam() */ if (OidIsValid(ap->am_typ.typelem)) *typioparam = ap->am_typ.typelem; else *typioparam = typid; *typinput = ap->am_typ.typinput; *typoutput = ap->am_typ.typoutput; } else { /* We don't have pg_type yet, so use the hard-wired TypInfo array */ int typeindex; for (typeindex = 0; typeindex < n_types; typeindex++) { if (TypInfo[typeindex].oid == typid) break; } if (typeindex >= n_types) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("type OID %u not found in TypInfo", typid))); *typlen = TypInfo[typeindex].len; *typbyval = TypInfo[typeindex].byval; *typalign = TypInfo[typeindex].align; /* We assume typdelim is ',' for all boot-time types */ *typdelim = ','; /* XXX this logic must match getTypeIOParam() */ if (OidIsValid(TypInfo[typeindex].elem)) *typioparam = TypInfo[typeindex].elem; else *typioparam = typid; *typinput = TypInfo[typeindex].inproc; *typoutput = TypInfo[typeindex].outproc; } } /* ---------------- * AllocateAttribute * * Note: bootstrap never sets any per-column ACLs, so we only need * ATTRIBUTE_FIXED_PART_SIZE space per attribute. * ---------------- */ static Form_pg_attribute AllocateAttribute(void) { Form_pg_attribute attribute = (Form_pg_attribute)MemoryContextAlloc( SESS_GET_MEM_CXT_GROUP(MEMORY_CONTEXT_STORAGE), ATTRIBUTE_FIXED_PART_SIZE); if (!PointerIsValid(attribute)) ereport(FATAL, (errmsg("out of memory"))); MemSet(attribute, 0, ATTRIBUTE_FIXED_PART_SIZE); return attribute; } /* ---------------- * MapArrayTypeName * XXX arrays of "basetype" are always "_basetype". * this is an evil hack inherited from rel. 3.1. * XXX array dimension is thrown away because we * don't support fixed-dimension arrays. again, * sickness from 3.1. * * the string passed in must have a '[' character in it * * the string returned is a pointer to static storage and should NOT * be freed by the CALLER. * ---------------- */ const char* MapArrayTypeName(const char* s) { int i; int j; if (s == NULL || s[0] == '\0') return s; j = 1; t_thrd.bootstrap_cxt.newStr[0] = '_'; for (i = 0; i < NAMEDATALEN - 1 && s[i] != '['; i++, j++) t_thrd.bootstrap_cxt.newStr[j] = s[i]; t_thrd.bootstrap_cxt.newStr[j] = '\0'; return t_thrd.bootstrap_cxt.newStr; } /* * index_register() -- record an index that has been set up for building * later. * * At bootstrap time, we define a bunch of indexes on system catalogs. * We postpone actually building the indexes until just before we're * finished with initialization, however. This is because the indexes * themselves have catalog entries, and those have to be included in the * indexes on those catalogs. Doing it in two phases is the simplest * way of making sure the indexes have the right contents at the end. */ void index_register(Oid heap, Oid ind, IndexInfo* indexInfo) { IndexList* newind = NULL; MemoryContext oldcxt; errno_t rc; /* * XXX mao 10/31/92 -- don't gc index reldescs, associated info at * bootstrap time. we'll declare the indexes now, but want to create them * later. */ if (t_thrd.bootstrap_cxt.nogc == NULL) t_thrd.bootstrap_cxt.nogc = AllocSetContextCreate( NULL, "BootstrapNoGC", ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE); oldcxt = MemoryContextSwitchTo(t_thrd.bootstrap_cxt.nogc); newind = (IndexList*)palloc(sizeof(IndexList)); newind->il_heap = heap; newind->il_ind = ind; newind->il_info = (IndexInfo*)palloc(sizeof(IndexInfo)); rc = memcpy_s(newind->il_info, sizeof(IndexInfo), indexInfo, sizeof(IndexInfo)); securec_check(rc, "\0", "\0"); /* expressions will likely be null, but may as well copy it */ newind->il_info->ii_Expressions = (List*)copyObject(indexInfo->ii_Expressions); newind->il_info->ii_ExpressionsState = NIL; /* predicate will likely be null, but may as well copy it */ newind->il_info->ii_Predicate = (List*)copyObject(indexInfo->ii_Predicate); newind->il_info->ii_PredicateState = NIL; /* no exclusion constraints at bootstrap time, so no need to copy */ Assert(indexInfo->ii_ExclusionOps == NULL); Assert(indexInfo->ii_ExclusionProcs == NULL); Assert(indexInfo->ii_ExclusionStrats == NULL); newind->il_next = t_thrd.bootstrap_cxt.ILHead; t_thrd.bootstrap_cxt.ILHead = newind; (void)MemoryContextSwitchTo(oldcxt); } /* * build_indices -- fill in all the indexes registered earlier */ void build_indices(void) { for (; t_thrd.bootstrap_cxt.ILHead != NULL; t_thrd.bootstrap_cxt.ILHead = t_thrd.bootstrap_cxt.ILHead->il_next) { Relation heap; Relation ind; /* need not bother with locks during bootstrap */ heap = heap_open(t_thrd.bootstrap_cxt.ILHead->il_heap, NoLock); ind = index_open(t_thrd.bootstrap_cxt.ILHead->il_ind, NoLock); index_build( heap, NULL, ind, NULL, t_thrd.bootstrap_cxt.ILHead->il_info, false, false, INDEX_CREATE_NONE_PARTITION); index_close(ind, NoLock); heap_close(heap, NoLock); } }