本节简单介绍了PostgreSQL的后台进程:autovacuum,主要分析了launch_worker函数的实现逻辑。 ### 一、数据结构 **AutoVacuumShmem** 主要的autovacuum共享内存结构体,存储在shared memory中,同时WorkerInfo也会存储在其中. ``` /*------------- * The main autovacuum shmem struct. On shared memory we store this main * struct and the array of WorkerInfo structs. This struct keeps: * 主要的autovacuum共享内存结构体,存储在shared memory中,同时WorkerInfo也会存储在其中. * 该结构体包括: * * av_signal set by other processes to indicate various conditions * 其他进程设置用于提示不同的条件 * av_launcherpid the PID of the autovacuum launcher * autovacuum launcher的PID * av_freeWorkers the WorkerInfo freelist * WorkerInfo空闲链表 * av_runningWorkers the WorkerInfo non-free queue * WorkerInfo非空闲队列 * av_startingWorker pointer to WorkerInfo currently being started (cleared by * the worker itself as soon as it's up and running) * av_startingWorker指向当前正在启动的WorkerInfo * av_workItems work item array * av_workItems 工作条目数组 * * This struct is protected by AutovacuumLock, except for av_signal and parts * of the worker list (see above). * 除了av_signal和worker list的一部分信息，该数据结构通过AutovacuumLock保护 *------------- */ typedef struct { sig_atomic_t av_signal[AutoVacNumSignals]; pid_t av_launcherpid; dlist_head av_freeWorkers; dlist_head av_runningWorkers; WorkerInfo av_startingWorker; AutoVacuumWorkItem av_workItems[NUM_WORKITEMS]; } AutoVacuumShmemStruct; static AutoVacuumShmemStruct *AutoVacuumShmem; ``` **FullTransactionId** 64 bit的事务ID ``` /* * A 64 bit value that contains an epoch and a TransactionId. This is * wrapped in a struct to prevent implicit conversion to/from TransactionId. * Not all values represent valid normal XIDs. * 保护epoch和TransactionId的64 bit值.封装在结构体中避免与事务ID的隐式转换.并不是所有的值都表示有效的普通xid。 */ typedef struct FullTransactionId { uint64 value; } FullTransactionId; ``` **avw_dbase** 用于跟踪worker中的数据库的结构体 ``` /* struct to keep track of databases in worker */ //用于跟踪worker中的数据库的结构体 typedef struct avw_dbase { Oid adw_datid; char *adw_name; TransactionId adw_frozenxid; MultiXactId adw_minmulti; PgStat_StatDBEntry *adw_entry; } avw_dbase; ``` **WorkerInfo** ``` /* * Structure to hold info passed by _beginthreadex() to the function it calls * via its single allowed argument. */ typedef struct { ArchiveHandle *AH; /* master database connection */ ParallelSlot *slot; /* this worker's parallel slot */ } WorkerInfo; ``` ### 二、源码解读 主要的实现逻辑在do_start_worker中 ``` /* * launch_worker * * Wrapper for starting a worker from the launcher. Besides actually starting * it, update the database list to reflect the next time that another one will * need to be started on the selected database. The actual database choice is * left to do_start_worker. * 从autovacuum launcher启动worker的封装器. * 除了实际启动它之外，还要更新数据库链表，以反映下一次需要在选定的数据库上启动另一个worker时的情况。 * 实际的数据库选择留给do_start_worker。 * * This routine is also expected to insert an entry into the database list if * the selected database was previously absent from the list. * 这段例程同样希望在数据库链表中插入一个新的条目,如果选定的数据库先前在链表中出现. */ static void launch_worker(TimestampTz now) { Oid dbid; dlist_iter iter; dbid = do_start_worker(); if (OidIsValid(dbid)) { bool found = false; /* * Walk the database list and update the corresponding entry. If the * database is not on the list, we'll recreate the list. * 遍历数据库链表,更新相应的条目. * 如果数据库不在链表链表中,重建链表. */ dlist_foreach(iter, &DatabaseList) { avl_dbase *avdb = dlist_container(avl_dbase, adl_node, iter.cur); if (avdb->adl_datid == dbid) { found = true; /* * add autovacuum_naptime seconds to the current time, and use * that as the new "next_worker" field for this database. * 在当前时间上增加autovacuum_naptime, * 并为该数据库使用该时间作为新的next_worker字段的值. */ avdb->adl_next_worker = TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000); dlist_move_head(&DatabaseList, iter.cur); break; } } /* * If the database was not present in the database list, we rebuild * the list. It's possible that the database does not get into the * list anyway, for example if it's a database that doesn't have a * pgstat entry, but this is not a problem because we don't want to * schedule workers regularly into those in any case. * 如果数据库不在数据库链表中,重建链表. * 有可能该数据库没有进入过链表中,比如,该数据库没有pgstat条目入口, * 但这不是一个问题,因为我们不希望在任何情况调度到这些数据库上面. */ if (!found) rebuild_database_list(dbid); } } ``` **do_start_worker** 选择一个DB,算法如下: 选择最近最小清理的DB,或者需要清理以防止XID回卷导致数据丢失的DB. 如果存在XID回卷风险的DB,那么选择datfrozenxid最老的DB,而不管该DB做了多少次autovacuum. 自动忽略没有连接过(统计信息为空)的DB. ``` /* * do_start_worker * * Bare-bones procedure for starting an autovacuum worker from the launcher. * It determines what database to work on, sets up shared memory stuff and * signals postmaster to start the worker. It fails gracefully if invoked when * autovacuum_workers are already active. * 启动autovacuum worker。 * 确定处理哪个库，配置共享内存并通知postmaster启动worker。 * 如autovacuum_workers已处于活动状态，则启动失败。 * * Return value is the OID of the database that the worker is going to process, * or InvalidOid if no worker was actually started. * 返回正在处理的数据库OID，如worker启动不成功，则返回InvalidOid。 */ static Oid do_start_worker(void) { List *dblist;//数据库链表 ListCell *cell;//临时变量 //typedef uint32 TransactionId; TransactionId xidForceLimit;//事务id,无符号32bit整型 MultiXactId multiForceLimit;// bool for_xid_wrap; bool for_multi_wrap; avw_dbase *avdb; TimestampTz current_time;//当前时间 bool skipit = false;//是否跳过? Oid retval = InvalidOid;//返回的数据库OID MemoryContext tmpcxt, oldcxt;//内存上下文 /* return quickly when there are no free workers */ //如无空闲的worker(AutoVacuumShmem数据结构维护),则退出 LWLockAcquire(AutovacuumLock, LW_SHARED); if (dlist_is_empty(&AutoVacuumShmem->av_freeWorkers)) { LWLockRelease(AutovacuumLock); return InvalidOid; } LWLockRelease(AutovacuumLock); /* * Create and switch to a temporary context to avoid leaking the memory * allocated for the database list. * 内存上下文切换 */ tmpcxt = AllocSetContextCreate(CurrentMemoryContext, "Start worker tmp cxt", ALLOCSET_DEFAULT_SIZES); oldcxt = MemoryContextSwitchTo(tmpcxt); /* use fresh stats */ //统计信息刷新 autovac_refresh_stats(); /* Get a list of databases */ //获取数据库链表 dblist = get_database_list(); /* * Determine the oldest datfrozenxid/relfrozenxid that we will allow to * pass without forcing a vacuum. (This limit can be tightened for * particular tables, but not loosened.) * 确定最老的datfrozenxid/relfrozenxid,用以确定是否需要强制vacuum */ recentXid = ReadNewTransactionId(); xidForceLimit = recentXid - autovacuum_freeze_max_age; /* ensure it's a "normal" XID, else TransactionIdPrecedes misbehaves */ /* this can cause the limit to go backwards by 3, but that's OK */ //#define FirstNormalTransactionId ((TransactionId) 3) //小于3(常规的XID),则减去3 if (xidForceLimit < FirstNormalTransactionId) xidForceLimit -= FirstNormalTransactionId; /* Also determine the oldest datminmxid we will consider. */ //确定需要考虑的最老的datminmxid //从MultiXactState->nextMXact中获取MultiXactId recentMulti = ReadNextMultiXactId(); multiForceLimit = recentMulti - MultiXactMemberFreezeThreshold(); if (multiForceLimit < FirstMultiXactId) multiForceLimit -= FirstMultiXactId; /* * Choose a database to connect to. We pick the database that was least * recently auto-vacuumed, or one that needs vacuuming to prevent Xid * wraparound-related data loss. If any db at risk of Xid wraparound is * found, we pick the one with oldest datfrozenxid, independently of * autovacuum times; similarly we pick the one with the oldest datminmxid * if any is in MultiXactId wraparound. Note that those in Xid wraparound * danger are given more priority than those in multi wraparound danger. * * Note that a database with no stats entry is not considered, except for * Xid wraparound purposes. The theory is that if no one has ever * connected to it since the stats were last initialized, it doesn't need * vacuuming. * * XXX This could be improved if we had more info about whether it needs * vacuuming before connecting to it. Perhaps look through the pgstats * data for the database's tables? One idea is to keep track of the * number of new and dead tuples per database in pgstats. However it * isn't clear how to construct a metric that measures that and not cause * starvation for less busy databases. * 选择一个DB. * 算法:选择最近最小清理的DB,或者需要清理以防止XID回卷导致数据丢失的DB. * 如果存在XID回卷风险的DB,那么选择datfrozenxid最老的DB,而不管该DB做了多少次autovacuum. * 自动忽略没有连接过(统计信息为空)的DB. */ avdb = NULL;//待清理的DB for_xid_wrap = false;//xid回卷 for_multi_wrap = false; current_time = GetCurrentTimestamp();//当前时间 foreach(cell, dblist)//循环db链表 { avw_dbase *tmp = lfirst(cell); dlist_iter iter; /* Check to see if this one is at risk of wraparound */ //判断是否存在回卷风险? //TransactionIdPrecedes --- is id1 logically < id2? if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit)) { if (avdb == NULL || TransactionIdPrecedes(tmp->adw_frozenxid, avdb->adw_frozenxid)) avdb = tmp;//选择较旧的那个 for_xid_wrap = true; continue; } else if (for_xid_wrap) continue; /* ignore not-at-risk DBs */ else if (MultiXactIdPrecedes(tmp->adw_minmulti, multiForceLimit)) { if (avdb == NULL || MultiXactIdPrecedes(tmp->adw_minmulti, avdb->adw_minmulti)) avdb = tmp; for_multi_wrap = true; continue; } else if (for_multi_wrap) continue; /* ignore not-at-risk DBs */ /* Find pgstat entry if any */ tmp->adw_entry = pgstat_fetch_stat_dbentry(tmp->adw_datid); /* * Skip a database with no pgstat entry; it means it hasn't seen any * activity. * 如无统计信息,跳过 */ if (!tmp->adw_entry) continue; /* * Also, skip a database that appears on the database list as having * been processed recently (less than autovacuum_naptime seconds ago). * We do this so that we don't select a database which we just * selected, but that pgstat hasn't gotten around to updating the last * autovacuum time yet. * 跳过出现在数据库链表中已处理过的DB(先前小于autovacuum_naptime秒) * 执行该操作是为了避免选择刚才才选择的DB */ skipit = false; dlist_reverse_foreach(iter, &DatabaseList) { avl_dbase *dbp = dlist_container(avl_dbase, adl_node, iter.cur); if (dbp->adl_datid == tmp->adw_datid) { /* * Skip this database if its next_worker value falls between * the current time and the current time plus naptime. * 未超过时(naptime定义) */ if (!TimestampDifferenceExceeds(dbp->adl_next_worker, current_time, 0) && !TimestampDifferenceExceeds(current_time, dbp->adl_next_worker, autovacuum_naptime * 1000)) skipit = true; break; } } if (skipit) continue; /* * Remember the db with oldest autovac time. (If we are here, both * tmp->entry and db->entry must be non-null.) */ if (avdb == NULL || tmp->adw_entry->last_autovac_time < avdb->adw_entry->last_autovac_time) avdb = tmp; } /* Found a database -- process it */ if (avdb != NULL) { WorkerInfo worker; dlist_node *wptr; LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE); /* * Get a worker entry from the freelist. We checked above, so there * really should be a free slot. * 从空闲链表中获取一个worker */ wptr = dlist_pop_head_node(&AutoVacuumShmem->av_freeWorkers); worker = dlist_container(WorkerInfoData, wi_links, wptr); worker->wi_dboid = avdb->adw_datid; worker->wi_proc = NULL; worker->wi_launchtime = GetCurrentTimestamp(); AutoVacuumShmem->av_startingWorker = worker; LWLockRelease(AutovacuumLock); SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER); retval = avdb->adw_datid; } else if (skipit) { /* * If we skipped all databases on the list, rebuild it, because it * probably contains a dropped database. */ rebuild_database_list(InvalidOid); } MemoryContextSwitchTo(oldcxt); MemoryContextDelete(tmpcxt); return retval; } /* * For callers that just need the XID part of the next transaction ID. */ static inline TransactionId ReadNewTransactionId(void) { return XidFromFullTransactionId(ReadNextFullTransactionId()); } #define XidFromFullTransactionId(x) ((uint32) (x).value) /* * Read nextFullXid but don't allocate it. */ FullTransactionId ReadNextFullTransactionId(void) { FullTransactionId fullXid; LWLockAcquire(XidGenLock, LW_SHARED); fullXid = ShmemVariableCache->nextFullXid; LWLockRelease(XidGenLock); return fullXid; } ``` ### 三、跟踪分析 启动gdb,设置信号处理,设置断点 ``` (gdb) handle SIGINT print nostop pass SIGINT is used by the debugger. Are you sure you want to change it? (y or n) Please answer y or n. SIGINT is used by the debugger. Are you sure you want to change it? (y or n) y Signal Stop Print Pass to program Description SIGINT No Yes Yes Interrupt (gdb) b autovacuum.c:launch_worker Breakpoint 1 at 0x82f3e7: file autovacuum.c, line 1338. (gdb) b autovacuum.c:783 Breakpoint 2 at 0x82e8f0: file autovacuum.c, line 783. (gdb) c Continuing. ``` 在其他session执行更新等操作 ``` [pg12@localhost test]$ psql -c "update tbl set id = 1;" Expanded display is used automatically. UPDATE 2000000 [pg12@localhost test]$ psql -c "update t1 set id = 1;" Expanded display is used automatically. UPDATE 20000 [pg12@localhost test]$ psql -c "update t2 set id = 1;" Expanded display is used automatically. UPDATE 10000 [pg12@localhost test]$ psql -c "select txid_current();" Expanded display is used automatically. txid_current -------------- 2917 (1 row) ``` 60s后在gdb console中continue ``` Breakpoint 2, AutoVacLauncherMain (argc=0, argv=0x0) at autovacuum.c:783 783 if (dlist_is_empty(&DatabaseList)) (gdb) n 804 avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList); (gdb) n 810 if (TimestampDifferenceExceeds(avdb->adl_next_worker, (gdb) 812 launch_worker(current_time); (gdb) p *avdb $1 = {adl_datid = 16384, adl_next_worker = 628852948486950, adl_score = 0, adl_node = { prev = 0xfd9880 <DatabaseList>, next = 0xfd9880 <DatabaseList>}} (gdb) step Breakpoint 1, launch_worker (now=628853296722794) at autovacuum.c:1338 1338 dbid = do_start_worker(); ``` 进入do_start_worker ``` (gdb) step do_start_worker () at autovacuum.c:1128 1128 bool skipit = false; (gdb) n 1129 Oid retval = InvalidOid; (gdb) 1134 LWLockAcquire(AutovacuumLock, LW_SHARED); (gdb) 1135 if (dlist_is_empty(&AutoVacuumShmem->av_freeWorkers)) ``` 查看AutoVacuumShmem结构体 ``` (gdb) p *AutoVacuumShmem $2 = {av_signal = {0, 0}, av_launcherpid = 5476, av_freeWorkers = {head = {prev = 0x7f8ccf1a4938, next = 0x7f8ccf1a49b8}}, av_runningWorkers = {head = {prev = 0x7f8ccf1a3520, next = 0x7f8ccf1a3520}}, av_startingWorker = 0x0, av_workItems = {{avw_type = AVW_BRINSummarizeRange, avw_used = false, avw_active = false, avw_database = 0, avw_relation = 0, avw_blockNumber = 0} <repeats 256 times>}} (gdb) n 1140 LWLockRelease(AutovacuumLock); (gdb) p AutoVacuumShmem->av_runningWorkers $3 = {head = {prev = 0x7f8ccf1a3520, next = 0x7f8ccf1a3520}} (gdb) n ``` 找到需要vacuum的database ``` 1146 tmpcxt = AllocSetContextCreate(CurrentMemoryContext, (gdb) 1149 oldcxt = MemoryContextSwitchTo(tmpcxt); (gdb) 1152 autovac_refresh_stats(); (gdb) n 1155 dblist = get_database_list(); (gdb) 1162 recentXid = ReadNewTransactionId(); (gdb) p *dblist $8 = {type = T_List, length = 5, head = 0x2382d48, tail = 0x2382f90} (gdb) n 1163 xidForceLimit = recentXid - autovacuum_freeze_max_age; (gdb) p recentXid $9 = 2917 (gdb) p autovacuum_freeze_max_age $10 = 200000000 (gdb) n 1166 if (xidForceLimit < FirstNormalTransactionId) (gdb) p xidForceLimit $11 = 4094970213 (gdb) p FirstNormalTransactionId $12 = 3 (gdb) n 1170 recentMulti = ReadNextMultiXactId(); (gdb) 1171 multiForceLimit = recentMulti - MultiXactMemberFreezeThreshold(); (gdb) 1172 if (multiForceLimit < FirstMultiXactId) (gdb) p recentMulti $13 = 1 (gdb) p MultiXactMemberFreezeThreshold() $14 = 400000000 (gdb) n 1196 avdb = NULL; (gdb) 1197 for_xid_wrap = false; (gdb) 1198 for_multi_wrap = false; (gdb) 1199 current_time = GetCurrentTimestamp(); (gdb) 1200 foreach(cell, dblist) (gdb) 1202 avw_dbase *tmp = lfirst(cell); (gdb) 1206 if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit)) (gdb) p *tmp --> 这是postgres数据库 $15 = {adw_datid = 13591, adw_name = 0x2382d20 "postgres", adw_frozenxid = 479, adw_minmulti = 1, adw_entry = 0x0} (gdb) n 1215 else if (for_xid_wrap) (gdb) 1217 else if (MultiXactIdPrecedes(tmp->adw_minmulti, multiForceLimit)) (gdb) 1225 else if (for_multi_wrap) (gdb) 1229 tmp->adw_entry = pgstat_fetch_stat_dbentry(tmp->adw_datid); (gdb) 1235 if (!tmp->adw_entry) (gdb) 1236 continue; (gdb) 1200 foreach(cell, dblist) (gdb) 1202 avw_dbase *tmp = lfirst(cell); (gdb) 1206 if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit)) (gdb) p *tmp --> 这是testdb数据库 $16 = {adw_datid = 16384, adw_name = 0x2382de0 "testdb", adw_frozenxid = 531, adw_minmulti = 1, adw_entry = 0x0} (gdb) p tmp->adw_frozenxid $17 = 531 (gdb) p xidForceLimit $18 = 4094970213 (gdb) n 1215 else if (for_xid_wrap) (gdb) 1217 else if (MultiXactIdPrecedes(tmp->adw_minmulti, multiForceLimit)) (gdb) 1225 else if (for_multi_wrap) (gdb) 1229 tmp->adw_entry = pgstat_fetch_stat_dbentry(tmp->adw_datid); (gdb) 1235 if (!tmp->adw_entry) (gdb) 1245 skipit = false; (gdb) 1247 dlist_reverse_foreach(iter, &DatabaseList) (gdb) 1249 avl_dbase *dbp = dlist_container(avl_dbase, adl_node, iter.cur); (gdb) 1251 if (dbp->adl_datid == tmp->adw_datid) (gdb) 1257 if (!TimestampDifferenceExceeds(dbp->adl_next_worker, (gdb) 1267 if (skipit) (gdb) 1274 if (avdb == NULL || (gdb) 1276 avdb = tmp; (gdb) n 1200 foreach(cell, dblist) (gdb) 1202 avw_dbase *tmp = lfirst(cell); (gdb) 1206 if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit)) (gdb) 1215 else if (for_xid_wrap) (gdb) p *tmp $19 = {adw_datid = 1, adw_name = 0x2382e60 "template1", adw_frozenxid = 479, adw_minmulti = 1, adw_entry = 0x0} (gdb) n 1217 else if (MultiXactIdPrecedes(tmp->adw_minmulti, multiForceLimit)) (gdb) 1225 else if (for_multi_wrap) (gdb) 1229 tmp->adw_entry = pgstat_fetch_stat_dbentry(tmp->adw_datid); (gdb) 1235 if (!tmp->adw_entry) (gdb) 1236 continue; --> 没有统计信息的,忽略 (gdb) 1200 foreach(cell, dblist) (gdb) 1202 avw_dbase *tmp = lfirst(cell); (gdb) 1206 if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit)) (gdb) 1215 else if (for_xid_wrap) (gdb) 1217 else if (MultiXactIdPrecedes(tmp->adw_minmulti, multiForceLimit)) (gdb) 1225 else if (for_multi_wrap) (gdb) 1229 tmp->adw_entry = pgstat_fetch_stat_dbentry(tmp->adw_datid); (gdb) 1235 if (!tmp->adw_entry) (gdb) 1236 continue; (gdb) 1200 foreach(cell, dblist) (gdb) 1202 avw_dbase *tmp = lfirst(cell); (gdb) 1206 if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit)) (gdb) 1215 else if (for_xid_wrap) (gdb) 1217 else if (MultiXactIdPrecedes(tmp->adw_minmulti, multiForceLimit)) (gdb) 1225 else if (for_multi_wrap) (gdb) 1229 tmp->adw_entry = pgstat_fetch_stat_dbentry(tmp->adw_datid); (gdb) 1235 if (!tmp->adw_entry) (gdb) 1236 continue; (gdb) 1200 foreach(cell, dblist) (gdb) ``` 完成db遍历,找到了需要处理的数据库->testdb,接下来就是找空闲worker并启动此worker执行vacuum ``` 1280 if (avdb != NULL) (gdb) 1285 LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE); (gdb) 1291 wptr = dlist_pop_head_node(&AutoVacuumShmem->av_freeWorkers); (gdb) 1293 worker = dlist_container(WorkerInfoData, wi_links, wptr); (gdb) p *wptr $20 = {prev = 0x7f8ccf1a3510, next = 0x7f8ccf1a4978} (gdb) n 1294 worker->wi_dboid = avdb->adw_datid; (gdb) p *worker $21 = {wi_links = {prev = 0x7f8ccf1a3510, next = 0x7f8ccf1a4978}, wi_dboid = 0, wi_tableoid = 0, wi_proc = 0x0, wi_launchtime = 0, wi_dobalance = false, wi_sharedrel = false, wi_cost_delay = 0, wi_cost_limit = 0, wi_cost_limit_base = 0} (gdb) n 1295 worker->wi_proc = NULL; (gdb) 1296 worker->wi_launchtime = GetCurrentTimestamp(); (gdb) 1298 AutoVacuumShmem->av_startingWorker = worker; (gdb) 1300 LWLockRelease(AutovacuumLock); (gdb) 1302 SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER); (gdb) p *AutoVacuumShmem $22 = {av_signal = {0, 0}, av_launcherpid = 5476, av_freeWorkers = {head = {prev = 0x7f8ccf1a4938, next = 0x7f8ccf1a4978}}, av_runningWorkers = {head = {prev = 0x7f8ccf1a3520, next = 0x7f8ccf1a3520}}, av_startingWorker = 0x7f8ccf1a49b8, av_workItems = {{avw_type = AVW_BRINSummarizeRange, avw_used = false, avw_active = false, avw_database = 0, avw_relation = 0, avw_blockNumber = 0} <repeats 256 times>}} (gdb) n 1304 retval = avdb->adw_datid; (gdb) Program received signal SIGUSR2, User defined signal 2. do_start_worker () at autovacuum.c:1304 1304 retval = avdb->adw_datid; (gdb) avl_sigusr2_handler (postgres_signal_arg=32764) at autovacuum.c:1405 1405 { (gdb) ``` DONE! ### 四、参考资料 [PG Source Code](https://doxygen.postgresql.org)