| blob | c0e2e00a7e3e6cdbea9cfc568db2d8e6469252a7 |
1 /*-------------------------------------------------------------------------
2 *
3 * autovacuum.c
4 *
5 * PostgreSQL Integrated Autovacuum Daemon
6 *
7 * The autovacuum system is structured in two different kinds of processes: the
8 * autovacuum launcher and the autovacuum worker. The launcher is an
9 * always-running process, started by the postmaster when the autovacuum GUC
10 * parameter is set. The launcher schedules autovacuum workers to be started
11 * when appropriate. The workers are the processes which execute the actual
12 * vacuuming; they connect to a database as determined in the launcher, and
13 * once connected they examine the catalogs to select the tables to vacuum.
14 *
15 * The autovacuum launcher cannot start the worker processes by itself,
16 * because doing so would cause robustness issues (namely, failure to shut
17 * them down on exceptional conditions, and also, since the launcher is
18 * connected to shared memory and is thus subject to corruption there, it is
19 * not as robust as the postmaster). So it leaves that task to the postmaster.
20 *
21 * There is an autovacuum shared memory area, where the launcher stores
22 * information about the database it wants vacuumed. When it wants a new
23 * worker to start, it sets a flag in shared memory and sends a signal to the
24 * postmaster. Then postmaster knows nothing more than it must start a worker;
25 * so it forks a new child, which turns into a worker. This new process
26 * connects to shared memory, and there it can inspect the information that the
27 * launcher has set up.
28 *
29 * If the fork() call fails in the postmaster, it sets a flag in the shared
30 * memory area, and sends a signal to the launcher. The launcher, upon
31 * noticing the flag, can try starting the worker again by resending the
32 * signal. Note that the failure can only be transient (fork failure due to
33 * high load, memory pressure, too many processes, etc); more permanent
34 * problems, like failure to connect to a database, are detected later in the
35 * worker and dealt with just by having the worker exit normally. The launcher
36 * will launch a new worker again later, per schedule.
37 *
38 * When the worker is done vacuuming it sends SIGUSR2 to the launcher. The
39 * launcher then wakes up and is able to launch another worker, if the schedule
40 * is so tight that a new worker is needed immediately. At this time the
41 * launcher can also balance the settings for the various remaining workers'
42 * cost-based vacuum delay feature.
43 *
44 * Note that there can be more than one worker in a database concurrently.
45 * They will store the table they are currently vacuuming in shared memory, so
46 * that other workers avoid being blocked waiting for the vacuum lock for that
47 * table. They will also fetch the last time the table was vacuumed from
48 * pgstats just before vacuuming each table, to avoid vacuuming a table that
49 * was just finished being vacuumed by another worker and thus is no longer
50 * noted in shared memory. However, there is a small window (due to not yet
51 * holding the relation lock) during which a worker may choose a table that was
52 * already vacuumed; this is a bug in the current design.
53 *
54 * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
55 * Portions Copyright (c) 1994, Regents of the University of California
56 *
57 *
58 * IDENTIFICATION
59 * src/backend/postmaster/autovacuum.c
60 *
61 *-------------------------------------------------------------------------
62 */
65 #include <signal.h>
66 #include <sys/time.h>
67 #include <unistd.h>
113 /*
114 * GUC parameters
115 */
134 /* the minimum allowed time between two awakenings of the launcher */
138 /* Flags to tell if we are in an autovacuum process */
142 /* Flags set by signal handlers */
145 /* Comparison points for determining whether freeze_max_age is exceeded */
149 /* Default freeze ages to use for autovacuum (varies by database) */
155 /* Memory context for long-lived data */
158 /* struct to keep track of databases in launcher */
160 {
162 TimestampTz adl_next_worker;
164 dlist_node adl_node;
167 /* struct to keep track of databases in worker */
169 {
170 Oid adw_datid;
172 TransactionId adw_frozenxid;
173 MultiXactId adw_minmulti;
177 /* struct to keep track of tables to vacuum and/or analyze, in 1st pass */
179 {
181 Oid ar_relid;
184 * reloptions, or NULL if none */
187 /* struct to keep track of tables to vacuum and/or analyze, after rechecking */
189 {
190 Oid at_relid;
191 VacuumParams at_params;
201 /*-------------
202 * This struct holds information about a single worker's whereabouts. We keep
203 * an array of these in shared memory, sized according to
204 * autovacuum_max_workers.
205 *
206 * wi_links entry into free list or running list
207 * wi_dboid OID of the database this worker is supposed to work on
208 * wi_tableoid OID of the table currently being vacuumed, if any
209 * wi_sharedrel flag indicating whether table is marked relisshared
210 * wi_proc pointer to PGPROC of the running worker, NULL if not started
211 * wi_launchtime Time at which this worker was launched
212 * wi_cost_* Vacuum cost-based delay parameters current in this worker
213 *
214 * All fields are protected by AutovacuumLock, except for wi_tableoid and
215 * wi_sharedrel which are protected by AutovacuumScheduleLock (note these
216 * two fields are read-only for everyone except that worker itself).
217 *-------------
218 */
220 {
221 dlist_node wi_links;
222 Oid wi_dboid;
223 Oid wi_tableoid;
225 TimestampTz wi_launchtime;
235 /*
236 * Possible signals received by the launcher from remote processes. These are
237 * stored atomically in shared memory so that other processes can set them
238 * without locking.
239 */
241 {
244 AutoVacNumSignals /* must be last */
247 /*
248 * Autovacuum workitem array, stored in AutoVacuumShmem->av_workItems. This
249 * list is mostly protected by AutovacuumLock, except that if an item is
250 * marked 'active' other processes must not modify the work-identifying
251 * members.
252 */
254 {
255 AutoVacuumWorkItemType avw_type;
258 Oid avw_database;
259 Oid avw_relation;
260 BlockNumber avw_blockNumber;
263 #define NUM_WORKITEMS 256
265 /*-------------
266 * The main autovacuum shmem struct. On shared memory we store this main
267 * struct and the array of WorkerInfo structs. This struct keeps:
268 *
269 * av_signal set by other processes to indicate various conditions
270 * av_launcherpid the PID of the autovacuum launcher
271 * av_freeWorkers the WorkerInfo freelist
272 * av_runningWorkers the WorkerInfo non-free queue
273 * av_startingWorker pointer to WorkerInfo currently being started (cleared by
274 * the worker itself as soon as it's up and running)
275 * av_workItems work item array
276 *
277 * This struct is protected by AutovacuumLock, except for av_signal and parts
278 * of the worker list (see above).
279 *-------------
280 */
282 {
284 pid_t av_launcherpid;
285 dlist_head av_freeWorkers;
286 dlist_head av_runningWorkers;
287 WorkerInfo av_startingWorker;
293 /*
294 * the database list (of avl_dbase elements) in the launcher, and the context
295 * that contains it
296 */
300 /* Pointer to my own WorkerInfo, valid on each worker */
303 /* PID of launcher, valid only in worker while shutting down */
306 #ifdef EXEC_BACKEND
309 #endif
328 TupleDesc pg_class_desc,
331 Form_pg_class classForm,
335 Form_pg_class classForm,
341 BufferAccessStrategy bstrategy);
343 TupleDesc pg_class_desc);
352 /********************************************************************
353 * AUTOVACUUM LAUNCHER CODE
354 ********************************************************************/
356 #ifdef EXEC_BACKEND
357 /*
358 * forkexec routine for the autovacuum launcher process.
359 *
360 * Format up the arglist, then fork and exec.
361 */
362 static pid_t
364 {
376 }
378 /*
379 * We need this set from the outside, before InitProcess is called
380 */
381 void
383 {
385 }
386 #endif
388 /*
389 * Main entry point for autovacuum launcher process, to be called from the
390 * postmaster.
391 */
392 int
394 {
395 pid_t AutoVacPID;
397 #ifdef EXEC_BACKEND
399 #else
401 #endif
402 {
408 #ifndef EXEC_BACKEND
410 /* in postmaster child ... */
413 /* Close the postmaster's sockets */
418 #endif
421 }
423 /* shouldn't get here */
425 }
427 /*
428 * Main loop for the autovacuum launcher process.
429 */
430 NON_EXEC_STATIC void
432 {
433 sigjmp_buf local_sigjmp_buf;
448 /*
449 * Set up signal handlers. We operate on databases much like a regular
450 * backend, so we use the same signal handling. See equivalent code in
451 * tcop/postgres.c.
452 */
456 /* SIGQUIT handler was already set up by InitPostmasterChild */
466 /*
467 * Create a per-backend PGPROC struct in shared memory, except in the
468 * EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
469 * this before we can use LWLocks (and in the EXEC_BACKEND case we already
470 * had to do some stuff with LWLocks).
471 */
472 #ifndef EXEC_BACKEND
474 #endif
476 /* Early initialization */
483 /*
484 * Create a memory context that we will do all our work in. We do this so
485 * that we can reset the context during error recovery and thereby avoid
486 * possible memory leaks.
487 */
490 ALLOCSET_DEFAULT_SIZES);
493 /*
494 * If an exception is encountered, processing resumes here.
495 *
496 * This code is a stripped down version of PostgresMain error recovery.
497 *
498 * Note that we use sigsetjmp(..., 1), so that the prevailing signal mask
499 * (to wit, BlockSig) will be restored when longjmp'ing to here. Thus,
500 * signals other than SIGQUIT will be blocked until we complete error
501 * recovery. It might seem that this policy makes the HOLD_INTERRUPTS()
502 * call redundant, but it is not since InterruptPending might be set
503 * already.
504 */
506 {
507 /* since not using PG_TRY, must reset error stack by hand */
510 /* Prevents interrupts while cleaning up */
513 /* Forget any pending QueryCancel or timeout request */
517 /* Report the error to the server log */
520 /* Abort the current transaction in order to recover */
523 /*
524 * Release any other resources, for the case where we were not in a
525 * transaction.
526 */
531 /* this is probably dead code, but let's be safe: */
539 /*
540 * Now return to normal top-level context and clear ErrorContext for
541 * next time.
542 */
546 /* Flush any leaked data in the top-level context */
549 /* don't leave dangling pointers to freed memory */
553 /* Now we can allow interrupts again */
556 /* if in shutdown mode, no need for anything further; just go away */
560 /*
561 * Sleep at least 1 second after any error. We don't want to be
562 * filling the error logs as fast as we can.
563 */
565 }
567 /* We can now handle ereport(ERROR) */
570 /* must unblock signals before calling rebuild_database_list */
573 /*
574 * Set always-secure search path. Launcher doesn't connect to a database,
575 * so this has no effect.
576 */
579 /*
580 * Force zero_damaged_pages OFF in the autovac process, even if it is set
581 * in postgresql.conf. We don't really want such a dangerous option being
582 * applied non-interactively.
583 */
586 /*
587 * Force settable timeouts off to avoid letting these settings prevent
588 * regular maintenance from being executed.
589 */
595 /*
596 * Force default_transaction_isolation to READ COMMITTED. We don't want
597 * to pay the overhead of serializable mode, nor add any risk of causing
598 * deadlocks or delaying other transactions.
599 */
603 /*
604 * Even when system is configured to use a different fetch consistency,
605 * for autovac we always want fresh stats.
606 */
609 /*
610 * In emergency mode, just start a worker (unless shutdown was requested)
611 * and go away.
612 */
614 {
618 }
622 /*
623 * Create the initial database list. The invariant we want this list to
624 * keep is that it's ordered by decreasing next_time. As soon as an entry
625 * is updated to a higher time, it will be moved to the front (which is
626 * correct because the only operation is to add autovacuum_naptime to the
627 * entry, and time always increases).
628 */
631 /* loop until shutdown request */
633 {
638 /*
639 * This loop is a bit different from the normal use of WaitLatch,
640 * because we'd like to sleep before the first launch of a child
641 * process. So it's WaitLatch, then ResetLatch, then check for
642 * wakening conditions.
643 */
648 /*
649 * Wait until naptime expires or we get some type of signal (all the
650 * signal handlers will wake us by calling SetLatch).
651 */
655 WAIT_EVENT_AUTOVACUUM_MAIN);
661 /*
662 * a worker finished, or postmaster signaled failure to start a worker
663 */
665 {
668 /* rebalance cost limits, if needed */
670 {
675 }
678 {
679 /*
680 * If the postmaster failed to start a new worker, we sleep
681 * for a little while and resend the signal. The new worker's
682 * state is still in memory, so this is sufficient. After
683 * that, we restart the main loop.
684 *
685 * XXX should we put a limit to the number of times we retry?
686 * I don't think it makes much sense, because a future start
687 * of a worker will continue to fail in the same way.
688 */
693 }
694 }
696 /*
697 * There are some conditions that we need to check before trying to
698 * start a worker. First, we need to make sure that there is a worker
699 * slot available. Second, we need to make sure that no other worker
700 * failed while starting up.
701 */
709 {
713 /*
714 * We can't launch another worker when another one is still
715 * starting up (or failed while doing so), so just sleep for a bit
716 * more; that worker will wake us up again as soon as it's ready.
717 * We will only wait autovacuum_naptime seconds (up to a maximum
718 * of 60 seconds) for this to happen however. Note that failure
719 * to connect to a particular database is not a problem here,
720 * because the worker removes itself from the startingWorker
721 * pointer before trying to connect. Problems detected by the
722 * postmaster (like fork() failure) are also reported and handled
723 * differently. The only problems that may cause this code to
724 * fire are errors in the earlier sections of AutoVacWorkerMain,
725 * before the worker removes the WorkerInfo from the
726 * startingWorker pointer.
727 */
730 waittime))
731 {
735 /*
736 * No other process can put a worker in starting mode, so if
737 * startingWorker is still INVALID after exchanging our lock,
738 * we assume it's the same one we saw above (so we don't
739 * recheck the launch time).
740 */
742 {
754 }
755 }
756 else
758 }
761 /* if we can't do anything, just go back to sleep */
765 /* We're OK to start a new worker */
768 {
769 /*
770 * Special case when the list is empty: start a worker right away.
771 * This covers the initial case, when no database is in pgstats
772 * (thus the list is empty). Note that the constraints in
773 * launcher_determine_sleep keep us from starting workers too
774 * quickly (at most once every autovacuum_naptime when the list is
775 * empty).
776 */
778 }
779 else
780 {
781 /*
782 * because rebuild_database_list constructs a list with most
783 * distant adl_next_worker first, we obtain our database from the
784 * tail of the list.
785 */
790 /*
791 * launch a worker if next_worker is right now or it is in the
792 * past
793 */
797 }
798 }
801 }
803 /*
804 * Process any new interrupts.
805 */
806 static void
808 {
809 /* the normal shutdown case */
814 {
818 /* shutdown requested in config file? */
822 /* rebalance in case the default cost parameters changed */
827 /* rebuild the list in case the naptime changed */
829 }
831 /* Process barrier events */
835 /* Perform logging of memory contexts of this process */
839 /* Process sinval catchup interrupts that happened while sleeping */
841 }
843 /*
844 * Perform a normal exit from the autovac launcher.
845 */
846 static void
848 {
854 }
856 /*
857 * Determine the time to sleep, based on the database list.
858 *
859 * The "canlaunch" parameter indicates whether we can start a worker right now,
860 * for example due to the workers being all busy. If this is false, we will
861 * cause a long sleep, which will be interrupted when a worker exits.
862 */
863 static void
865 {
866 /*
867 * We sleep until the next scheduled vacuum. We trust that when the
868 * database list was built, care was taken so that no entries have times
869 * in the past; if the first entry has too close a next_worker value, or a
870 * time in the past, we will sleep a small nominal time.
871 */
873 {
876 }
878 {
880 TimestampTz next_wakeup;
892 }
893 else
894 {
895 /* list is empty, sleep for whole autovacuum_naptime seconds */
898 }
900 /*
901 * If the result is exactly zero, it means a database had an entry with
902 * time in the past. Rebuild the list so that the databases are evenly
903 * distributed again, and recalculate the time to sleep. This can happen
904 * if there are more tables needing vacuum than workers, and they all take
905 * longer to vacuum than autovacuum_naptime.
906 *
907 * We only recurse once. rebuild_database_list should always return times
908 * in the future, but it seems best not to trust too much on that.
909 */
911 {
915 }
917 /* The smallest time we'll allow the launcher to sleep. */
919 {
922 }
924 /*
925 * If the sleep time is too large, clamp it to an arbitrary maximum (plus
926 * any fractional seconds, for simplicity). This avoids an essentially
927 * infinite sleep in strange cases like the system clock going backwards a
928 * few years.
929 */
932 }
934 /*
935 * Build an updated DatabaseList. It must only contain databases that appear
936 * in pgstats, and must be sorted by next_worker from highest to lowest,
937 * distributed regularly across the next autovacuum_naptime interval.
938 *
939 * Receives the Oid of the database that made this list be generated (we call
940 * this the "new" database, because when the database was already present on
941 * the list, we expect that this function is not called at all). The
942 * preexisting list, if any, will be used to preserve the order of the
943 * databases in the autovacuum_naptime period. The new database is put at the
944 * end of the interval. The actual values are not saved, which should not be
945 * much of a problem.
946 */
947 static void
949 {
952 MemoryContext newcxt;
953 MemoryContext oldcxt;
954 MemoryContext tmpcxt;
955 HASHCTL hctl;
959 dlist_iter iter;
963 ALLOCSET_DEFAULT_SIZES);
966 ALLOCSET_DEFAULT_SIZES);
969 /*
970 * Implementing this is not as simple as it sounds, because we need to put
971 * the new database at the end of the list; next the databases that were
972 * already on the list, and finally (at the tail of the list) all the
973 * other databases that are not on the existing list.
974 *
975 * To do this, we build an empty hash table of scored databases. We will
976 * start with the lowest score (zero) for the new database, then
977 * increasing scores for the databases in the existing list, in order, and
978 * lastly increasing scores for all databases gotten via
979 * get_database_list() that are not already on the hash.
980 *
981 * Then we will put all the hash elements into an array, sort the array by
982 * score, and finally put the array elements into the new doubly linked
983 * list.
984 */
989 * FIXME */
992 /* start by inserting the new database */
995 {
999 /* only consider this database if it has a pgstat entry */
1002 {
1003 /* we assume it isn't found because the hash was just created */
1006 /* hash_search already filled in the key */
1008 /* next_worker is filled in later */
1009 }
1010 }
1012 /* Now insert the databases from the existing list */
1014 {
1020 /*
1021 * skip databases with no stat entries -- in particular, this gets rid
1022 * of dropped databases
1023 */
1031 {
1032 /* hash_search already filled in the key */
1034 /* next_worker is filled in later */
1035 }
1036 }
1038 /* finally, insert all qualifying databases not previously inserted */
1041 {
1047 /* only consider databases with a pgstat entry */
1053 /* only update the score if the database was not already on the hash */
1055 {
1056 /* hash_search already filled in the key */
1058 /* next_worker is filled in later */
1059 }
1060 }
1063 /* from here on, the allocated memory belongs to the new list */
1068 {
1069 TimestampTz current_time;
1073 HASH_SEQ_STATUS seq;
1076 /* put all the hash elements into an array */
1084 /* sort the array */
1087 /*
1088 * Determine the time interval between databases in the schedule. If
1089 * we see that the configured naptime would take us to sleep times
1090 * lower than our min sleep time (which launcher_determine_sleep is
1091 * coded not to allow), silently use a larger naptime (but don't touch
1092 * the GUC variable).
1093 */
1100 /*
1101 * move the elements from the array into the dlist, setting the
1102 * next_worker while walking the array
1103 */
1105 {
1109 millis_increment);
1112 /* later elements should go closer to the head of the list */
1114 }
1115 }
1117 /* all done, clean up memory */
1123 }
1125 /* qsort comparator for avl_dbase, using adl_score */
1126 static int
1128 {
1131 else
1133 }
1135 /*
1136 * do_start_worker
1137 *
1138 * Bare-bones procedure for starting an autovacuum worker from the launcher.
1139 * It determines what database to work on, sets up shared memory stuff and
1140 * signals postmaster to start the worker. It fails gracefully if invoked when
1141 * autovacuum_workers are already active.
1142 *
1143 * Return value is the OID of the database that the worker is going to process,
1144 * or InvalidOid if no worker was actually started.
1145 */
1146 static Oid
1148 {
1151 TransactionId xidForceLimit;
1152 MultiXactId multiForceLimit;
1156 TimestampTz current_time;
1159 MemoryContext tmpcxt,
1160 oldcxt;
1162 /* return quickly when there are no free workers */
1165 {
1168 }
1171 /*
1172 * Create and switch to a temporary context to avoid leaking the memory
1173 * allocated for the database list.
1174 */
1177 ALLOCSET_DEFAULT_SIZES);
1180 /* Get a list of databases */
1183 /*
1184 * Determine the oldest datfrozenxid/relfrozenxid that we will allow to
1185 * pass without forcing a vacuum. (This limit can be tightened for
1186 * particular tables, but not loosened.)
1187 */
1190 /* ensure it's a "normal" XID, else TransactionIdPrecedes misbehaves */
1191 /* this can cause the limit to go backwards by 3, but that's OK */
1195 /* Also determine the oldest datminmxid we will consider. */
1201 /*
1202 * Choose a database to connect to. We pick the database that was least
1203 * recently auto-vacuumed, or one that needs vacuuming to prevent Xid
1204 * wraparound-related data loss. If any db at risk of Xid wraparound is
1205 * found, we pick the one with oldest datfrozenxid, independently of
1206 * autovacuum times; similarly we pick the one with the oldest datminmxid
1207 * if any is in MultiXactId wraparound. Note that those in Xid wraparound
1208 * danger are given more priority than those in multi wraparound danger.
1209 *
1210 * Note that a database with no stats entry is not considered, except for
1211 * Xid wraparound purposes. The theory is that if no one has ever
1212 * connected to it since the stats were last initialized, it doesn't need
1213 * vacuuming.
1214 *
1215 * XXX This could be improved if we had more info about whether it needs
1216 * vacuuming before connecting to it. Perhaps look through the pgstats
1217 * data for the database's tables? One idea is to keep track of the
1218 * number of new and dead tuples per database in pgstats. However it
1219 * isn't clear how to construct a metric that measures that and not cause
1220 * starvation for less busy databases.
1221 */
1227 {
1229 dlist_iter iter;
1231 /* Check to see if this one is at risk of wraparound */
1233 {
1240 }
1244 {
1250 }
1254 /* Find pgstat entry if any */
1257 /*
1258 * Skip a database with no pgstat entry; it means it hasn't seen any
1259 * activity.
1260 */
1264 /*
1265 * Also, skip a database that appears on the database list as having
1266 * been processed recently (less than autovacuum_naptime seconds ago).
1267 * We do this so that we don't select a database which we just
1268 * selected, but that pgstat hasn't gotten around to updating the last
1269 * autovacuum time yet.
1270 */
1274 {
1278 {
1279 /*
1280 * Skip this database if its next_worker value falls between
1281 * the current time and the current time plus naptime.
1282 */
1291 }
1292 }
1296 /*
1297 * Remember the db with oldest autovac time. (If we are here, both
1298 * tmp->entry and db->entry must be non-null.)
1299 */
1303 }
1305 /* Found a database -- process it */
1307 {
1308 WorkerInfo worker;
1313 /*
1314 * Get a worker entry from the freelist. We checked above, so there
1315 * really should be a free slot.
1316 */
1331 }
1333 {
1334 /*
1335 * If we skipped all databases on the list, rebuild it, because it
1336 * probably contains a dropped database.
1337 */
1339 }
1345 }
1347 /*
1348 * launch_worker
1349 *
1350 * Wrapper for starting a worker from the launcher. Besides actually starting
1351 * it, update the database list to reflect the next time that another one will
1352 * need to be started on the selected database. The actual database choice is
1353 * left to do_start_worker.
1354 *
1355 * This routine is also expected to insert an entry into the database list if
1356 * the selected database was previously absent from the list.
1357 */
1358 static void
1360 {
1361 Oid dbid;
1362 dlist_iter iter;
1366 {
1369 /*
1370 * Walk the database list and update the corresponding entry. If the
1371 * database is not on the list, we'll recreate the list.
1372 */
1374 {
1378 {
1381 /*
1382 * add autovacuum_naptime seconds to the current time, and use
1383 * that as the new "next_worker" field for this database.
1384 */
1390 }
1391 }
1393 /*
1394 * If the database was not present in the database list, we rebuild
1395 * the list. It's possible that the database does not get into the
1396 * list anyway, for example if it's a database that doesn't have a
1397 * pgstat entry, but this is not a problem because we don't want to
1398 * schedule workers regularly into those in any case.
1399 */
1402 }
1403 }
1405 /*
1406 * Called from postmaster to signal a failure to fork a process to become
1407 * worker. The postmaster should kill(SIGUSR2) the launcher shortly
1408 * after calling this function.
1409 */
1410 void
1412 {
1414 }
1416 /* SIGUSR2: a worker is up and running, or just finished, or failed to fork */
1417 static void
1419 {
1426 }
1429 /********************************************************************
1430 * AUTOVACUUM WORKER CODE
1431 ********************************************************************/
1433 #ifdef EXEC_BACKEND
1434 /*
1435 * forkexec routines for the autovacuum worker.
1436 *
1437 * Format up the arglist, then fork and exec.
1438 */
1439 static pid_t
1441 {
1453 }
1455 /*
1456 * We need this set from the outside, before InitProcess is called
1457 */
1458 void
1460 {
1462 }
1463 #endif
1465 /*
1466 * Main entry point for autovacuum worker process.
1467 *
1468 * This code is heavily based on pgarch.c, q.v.
1469 */
1470 int
1472 {
1473 pid_t worker_pid;
1475 #ifdef EXEC_BACKEND
1477 #else
1479 #endif
1480 {
1486 #ifndef EXEC_BACKEND
1488 /* in postmaster child ... */
1491 /* Close the postmaster's sockets */
1496 #endif
1499 }
1501 /* shouldn't get here */
1503 }
1505 /*
1506 * AutoVacWorkerMain
1507 */
1508 NON_EXEC_STATIC void
1510 {
1511 sigjmp_buf local_sigjmp_buf;
1512 Oid dbid;
1521 /*
1522 * Set up signal handlers. We operate on databases much like a regular
1523 * backend, so we use the same signal handling. See equivalent code in
1524 * tcop/postgres.c.
1525 */
1528 /*
1529 * SIGINT is used to signal canceling the current table's vacuum; SIGTERM
1530 * means abort and exit cleanly, and SIGQUIT means abandon ship.
1531 */
1534 /* SIGQUIT handler was already set up by InitPostmasterChild */
1544 /*
1545 * Create a per-backend PGPROC struct in shared memory, except in the
1546 * EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
1547 * this before we can use LWLocks (and in the EXEC_BACKEND case we already
1548 * had to do some stuff with LWLocks).
1549 */
1550 #ifndef EXEC_BACKEND
1552 #endif
1554 /* Early initialization */
1557 /*
1558 * If an exception is encountered, processing resumes here.
1559 *
1560 * Unlike most auxiliary processes, we don't attempt to continue
1561 * processing after an error; we just clean up and exit. The autovac
1562 * launcher is responsible for spawning another worker later.
1563 *
1564 * Note that we use sigsetjmp(..., 1), so that the prevailing signal mask
1565 * (to wit, BlockSig) will be restored when longjmp'ing to here. Thus,
1566 * signals other than SIGQUIT will be blocked until we exit. It might
1567 * seem that this policy makes the HOLD_INTERRUPTS() call redundant, but
1568 * it is not since InterruptPending might be set already.
1569 */
1571 {
1572 /* since not using PG_TRY, must reset error stack by hand */
1575 /* Prevents interrupts while cleaning up */
1578 /* Report the error to the server log */
1581 /*
1582 * We can now go away. Note that because we called InitProcess, a
1583 * callback was registered to do ProcKill, which will clean up
1584 * necessary state.
1585 */
1587 }
1589 /* We can now handle ereport(ERROR) */
1594 /*
1595 * Set always-secure search path, so malicious users can't redirect user
1596 * code (e.g. pg_index.indexprs). (That code runs in a
1597 * SECURITY_RESTRICTED_OPERATION sandbox, so malicious users could not
1598 * take control of the entire autovacuum worker in any case.)
1599 */
1602 /*
1603 * Force zero_damaged_pages OFF in the autovac process, even if it is set
1604 * in postgresql.conf. We don't really want such a dangerous option being
1605 * applied non-interactively.
1606 */
1609 /*
1610 * Force settable timeouts off to avoid letting these settings prevent
1611 * regular maintenance from being executed.
1612 */
1618 /*
1619 * Force default_transaction_isolation to READ COMMITTED. We don't want
1620 * to pay the overhead of serializable mode, nor add any risk of causing
1621 * deadlocks or delaying other transactions.
1622 */
1626 /*
1627 * Force synchronous replication off to allow regular maintenance even if
1628 * we are waiting for standbys to connect. This is important to ensure we
1629 * aren't blocked from performing anti-wraparound tasks.
1630 */
1635 /*
1636 * Even when system is configured to use a different fetch consistency,
1637 * for autovac we always want fresh stats.
1638 */
1641 /*
1642 * Get the info about the database we're going to work on.
1643 */
1646 /*
1647 * beware of startingWorker being INVALID; this should normally not
1648 * happen, but if a worker fails after forking and before this, the
1649 * launcher might have decided to remove it from the queue and start
1650 * again.
1651 */
1653 {
1658 /* insert into the running list */
1662 /*
1663 * remove from the "starting" pointer, so that the launcher can start
1664 * a new worker if required
1665 */
1671 /* wake up the launcher */
1674 }
1675 else
1676 {
1677 /* no worker entry for me, go away */
1681 }
1684 {
1687 /*
1688 * Report autovac startup to the cumulative stats system. We
1689 * deliberately do this before InitPostgres, so that the
1690 * last_autovac_time will get updated even if the connection attempt
1691 * fails. This is to prevent autovac from getting "stuck" repeatedly
1692 * selecting an unopenable database, rather than making any progress
1693 * on stuff it can connect to.
1694 */
1697 /*
1698 * Connect to the selected database, specifying no particular user
1699 *
1700 * Note: if we have selected a just-deleted database (due to using
1701 * stale stats info), we'll fail and exit here.
1702 */
1704 dbname);
1713 /* And do an appropriate amount of work */
1717 }
1719 /*
1720 * The launcher will be notified of my death in ProcKill, *if* we managed
1721 * to get a worker slot at all
1722 */
1724 /* All done, go away */
1726 }
1728 /*
1729 * Return a WorkerInfo to the free list
1730 */
1731 static void
1733 {
1735 {
1738 /*
1739 * Wake the launcher up so that he can launch a new worker immediately
1740 * if required. We only save the launcher's PID in local memory here;
1741 * the actual signal will be sent when the PGPROC is recycled. Note
1742 * that we always do this, so that the launcher can rebalance the cost
1743 * limit setting of the remaining workers.
1744 *
1745 * We somewhat ignore the risk that the launcher changes its PID
1746 * between us reading it and the actual kill; we expect ProcKill to be
1747 * called shortly after us, and we assume that PIDs are not reused too
1748 * quickly after a process exits.
1749 */
1764 /* not mine anymore */
1767 /*
1768 * now that we're inactive, cause a rebalancing of the surviving
1769 * workers
1770 */
1773 }
1774 }
1776 /*
1777 * Update the cost-based delay parameters, so that multiple workers consume
1778 * each a fraction of the total available I/O.
1779 */
1780 void
1782 {
1784 {
1787 }
1788 }
1790 /*
1791 * autovac_balance_cost
1792 * Recalculate the cost limit setting for each active worker.
1793 *
1794 * Caller must hold the AutovacuumLock in exclusive mode.
1795 */
1796 static void
1798 {
1799 /*
1800 * The idea here is that we ration out I/O equally. The amount of I/O
1801 * that a worker can consume is determined by cost_limit/cost_delay, so we
1802 * try to equalize those ratios rather than the raw limit settings.
1803 *
1804 * note: in cost_limit, zero also means use value from elsewhere, because
1805 * zero is not a valid value.
1806 */
1813 dlist_iter iter;
1815 /* not set? nothing to do */
1819 /* calculate the total base cost limit of participating active workers */
1822 {
1828 cost_total +=
1830 }
1832 /* there are no cost limits -- nothing to do */
1836 /*
1837 * Adjust cost limit of each active worker to balance the total of cost
1838 * limit to autovacuum_vacuum_cost_limit.
1839 */
1842 {
1848 {
1852 /*
1853 * We put a lower bound of 1 on the cost_limit, to avoid division-
1854 * by-zero in the vacuum code. Also, in case of roundoff trouble
1855 * in these calculations, let's be sure we don't ever set
1856 * cost_limit to more than the base value.
1857 */
1861 }
1864 elog(DEBUG2, "autovac_balance_cost(pid=%d db=%u, rel=%u, dobalance=%s cost_limit=%d, cost_limit_base=%d, cost_delay=%g)",
1869 }
1870 }
1872 /*
1873 * get_database_list
1874 * Return a list of all databases found in pg_database.
1875 *
1876 * The list and associated data is allocated in the caller's memory context,
1877 * which is in charge of ensuring that it's properly cleaned up afterwards.
1878 *
1879 * Note: this is the only function in which the autovacuum launcher uses a
1880 * transaction. Although we aren't attached to any particular database and
1881 * therefore can't access most catalogs, we do have enough infrastructure
1882 * to do a seqscan on pg_database.
1883 */
1886 {
1888 Relation rel;
1889 TableScanDesc scan;
1890 HeapTuple tup;
1891 MemoryContext resultcxt;
1893 /* This is the context that we will allocate our output data in */
1896 /*
1897 * Start a transaction so we can access pg_database, and get a snapshot.
1898 * We don't have a use for the snapshot itself, but we're interested in
1899 * the secondary effect that it sets RecentGlobalXmin. (This is critical
1900 * for anything that reads heap pages, because HOT may decide to prune
1901 * them even if the process doesn't attempt to modify any tuples.)
1902 *
1903 * FIXME: This comment is inaccurate / the code buggy. A snapshot that is
1904 * not pushed/active does not reliably prevent HOT pruning (->xmin could
1905 * e.g. be cleared when cache invalidations are processed).
1906 */
1914 {
1917 MemoryContext oldcxt;
1919 /*
1920 * Allocate our results in the caller's context, not the
1921 * transaction's. We do this inside the loop, and restore the original
1922 * context at the end, so that leaky things like heap_getnext() are
1923 * not called in a potentially long-lived context.
1924 */
1933 /* this gets set later: */
1938 }
1945 /* Be sure to restore caller's memory context */
1949 }
1951 /*
1952 * Process a database table-by-table
1953 *
1954 * Note that CHECK_FOR_INTERRUPTS is supposed to be used in certain spots in
1955 * order not to ignore shutdown commands for too long.
1956 */
1957 static void
1959 {
1960 Relation classRel;
1961 HeapTuple tuple;
1962 TableScanDesc relScan;
1963 Form_pg_database dbForm;
1966 HASHCTL ctl;
1969 BufferAccessStrategy bstrategy;
1970 ScanKeyData key;
1971 TupleDesc pg_class_desc;
1977 /*
1978 * StartTransactionCommand and CommitTransactionCommand will automatically
1979 * switch to other contexts. We need this one to keep the list of
1980 * relations to vacuum/analyze across transactions.
1981 */
1984 ALLOCSET_DEFAULT_SIZES);
1987 /* Start a transaction so our commands have one to play into. */
1990 /*
1991 * Compute the multixact age for which freezing is urgent. This is
1992 * normally autovacuum_multixact_freeze_max_age, but may be less if we are
1993 * short of multixact member space.
1994 */
1997 /*
1998 * Find the pg_database entry and select the default freeze ages. We use
1999 * zero in template and nonconnectable databases, else the system-wide
2000 * default.
2001 */
2008 {
2013 }
2014 else
2015 {
2020 }
2024 /* StartTransactionCommand changed elsewhere */
2029 /* create a copy so we can use it after closing pg_class */
2032 /* create hash table for toast <-> main relid mapping */
2041 /*
2042 * Scan pg_class to determine which tables to vacuum.
2043 *
2044 * We do this in two passes: on the first one we collect the list of plain
2045 * relations and materialized views, and on the second one we collect
2046 * TOAST tables. The reason for doing the second pass is that during it we
2047 * want to use the main relation's pg_class.reloptions entry if the TOAST
2048 * table does not have any, and we cannot obtain it unless we know
2049 * beforehand what's the main table OID.
2050 *
2051 * We need to check TOAST tables separately because in cases with short,
2052 * wide tables there might be proportionally much more activity in the
2053 * TOAST table than in its parent.
2054 */
2057 /*
2058 * On the first pass, we collect main tables to vacuum, and also the main
2059 * table relid to TOAST relid mapping.
2060 */
2062 {
2066 Oid relid;
2077 /*
2078 * Check if it is a temp table (presumably, of some other backend's).
2079 * We cannot safely process other backends' temp tables.
2080 */
2082 {
2083 /*
2084 * We just ignore it if the owning backend is still active and
2085 * using the temporary schema. Also, for safety, ignore it if the
2086 * namespace doesn't exist or isn't a temp namespace after all.
2087 */
2089 {
2090 /*
2091 * The table seems to be orphaned -- although it might be that
2092 * the owning backend has already deleted it and exited; our
2093 * pg_class scan snapshot is not necessarily up-to-date
2094 * anymore, so we could be looking at a committed-dead entry.
2095 * Remember it so we can try to delete it later.
2096 */
2098 }
2100 }
2102 /* Fetch reloptions and the pgstat entry for this table */
2105 relid);
2107 /* Check if it needs vacuum or analyze */
2109 effective_multixact_freeze_max_age,
2112 /* Relations that need work are added to table_oids */
2116 /*
2117 * Remember TOAST associations for the second pass. Note: we must do
2118 * this whether or not the table is going to be vacuumed, because we
2119 * don't automatically vacuum toast tables along the parent table.
2120 */
2122 {
2131 {
2132 /* hash_search already filled in the key */
2136 {
2140 }
2141 }
2142 }
2143 }
2147 /* second pass: check TOAST tables */
2149 Anum_pg_class_relkind,
2155 {
2158 Oid relid;
2164 /*
2165 * We cannot safely process other backends' temp tables, so skip 'em.
2166 */
2172 /*
2173 * fetch reloptions -- if this toast table does not have them, try the
2174 * main rel
2175 */
2178 {
2185 }
2187 /* Fetch the pgstat entry for this table */
2189 relid);
2192 effective_multixact_freeze_max_age,
2195 /* ignore analyze for toast tables */
2198 }
2203 /*
2204 * Recheck orphan temporary tables, and if they still seem orphaned, drop
2205 * them. We'll eat a transaction per dropped table, which might seem
2206 * excessive, but we should only need to do anything as a result of a
2207 * previous backend crash, so this should not happen often enough to
2208 * justify "optimizing". Using separate transactions ensures that we
2209 * don't bloat the lock table if there are many temp tables to be dropped,
2210 * and it ensures that we don't lose work if a deletion attempt fails.
2211 */
2213 {
2215 Form_pg_class classForm;
2216 ObjectAddress object;
2218 /*
2219 * Check for user-requested abort.
2220 */
2223 /*
2224 * Try to lock the table. If we can't get the lock immediately,
2225 * somebody else is using (or dropping) the table, so it's not our
2226 * concern anymore. Having the lock prevents race conditions below.
2227 */
2231 /*
2232 * Re-fetch the pg_class tuple and re-check whether it still seems to
2233 * be an orphaned temp table. If it's not there or no longer the same
2234 * relation, ignore it.
2235 */
2238 {
2239 /* be sure to drop useless lock so we don't bloat lock table */
2242 }
2245 /*
2246 * Make all the same tests made in the loop above. In event of OID
2247 * counter wraparound, the pg_class entry we have now might be
2248 * completely unrelated to the one we saw before.
2249 */
2253 {
2256 }
2259 {
2262 }
2264 /* OK, let's delete it */
2275 PERFORM_DELETION_INTERNAL |
2276 PERFORM_DELETION_QUIETLY |
2277 PERFORM_DELETION_SKIP_EXTENSIONS);
2279 /*
2280 * To commit the deletion, end current transaction and start a new
2281 * one. Note this also releases the lock we took.
2282 */
2286 /* StartTransactionCommand changed current memory context */
2288 }
2290 /*
2291 * Create a buffer access strategy object for VACUUM to use. We want to
2292 * use the same one across all the vacuum operations we perform, since the
2293 * point is for VACUUM not to blow out the shared cache.
2294 */
2297 /*
2298 * create a memory context to act as fake PortalContext, so that the
2299 * contexts created in the vacuum code are cleaned up for each table.
2300 */
2303 ALLOCSET_DEFAULT_SIZES);
2305 /*
2306 * Perform operations on collected tables.
2307 */
2309 {
2311 HeapTuple classTup;
2317 dlist_iter iter;
2321 /*
2322 * Check for config changes before processing each collected table.
2323 */
2325 {
2329 /*
2330 * You might be tempted to bail out if we see autovacuum is now
2331 * disabled. Must resist that temptation -- this might be a
2332 * for-wraparound emergency worker, in which case that would be
2333 * entirely inappropriate.
2334 */
2335 }
2337 /*
2338 * Find out whether the table is shared or not. (It's slightly
2339 * annoying to fetch the syscache entry just for this, but in typical
2340 * cases it adds little cost because table_recheck_autovac would
2341 * refetch the entry anyway. We could buy that back by copying the
2342 * tuple here and passing it to table_recheck_autovac, but that
2343 * increases the odds of that function working with stale data.)
2344 */
2351 /*
2352 * Hold schedule lock from here until we've claimed the table. We
2353 * also need the AutovacuumLock to walk the worker array, but that one
2354 * can just be a shared lock.
2355 */
2359 /*
2360 * Check whether the table is being vacuumed concurrently by another
2361 * worker.
2362 */
2365 {
2368 /* ignore myself */
2372 /* ignore workers in other databases (unless table is shared) */
2377 {
2381 }
2382 }
2385 {
2388 }
2390 /*
2391 * Store the table's OID in shared memory before releasing the
2392 * schedule lock, so that other workers don't try to vacuum it
2393 * concurrently. (We claim it here so as not to hold
2394 * AutovacuumScheduleLock while rechecking the stats.)
2395 */
2400 /*
2401 * Check whether pgstat data still says we need to vacuum this table.
2402 * It could have changed if something else processed the table while
2403 * we weren't looking. This doesn't entirely close the race condition,
2404 * but it is very small.
2405 */
2408 effective_multixact_freeze_max_age);
2410 {
2411 /* someone else vacuumed the table, or it went away */
2417 }
2419 /*
2420 * Remember the prevailing values of the vacuum cost GUCs. We have to
2421 * restore these at the bottom of the loop, else we'll compute wrong
2422 * values in the next iteration of autovac_balance_cost().
2423 */
2427 /* Must hold AutovacuumLock while mucking with cost balance info */
2430 /* advertise my cost delay parameters for the balancing algorithm */
2436 /* do a balance */
2439 /* set the active cost parameters from the result of that */
2442 /* done */
2445 /* clean up memory before each iteration */
2448 /*
2449 * Save the relation name for a possible error message, to avoid a
2450 * catalog lookup in case of an error. If any of these return NULL,
2451 * then the relation has been dropped since last we checked; skip it.
2452 * Note: they must live in a long-lived memory context because we call
2453 * vacuum and analyze in different transactions.
2454 */
2462 /*
2463 * We will abort vacuuming the current table if something errors out,
2464 * and continue with the next one in schedule; in particular, this
2465 * happens if we are interrupted with SIGINT.
2466 */
2468 {
2469 /* Use PortalContext for any per-table allocations */
2472 /* have at it */
2475 /*
2476 * Clear a possible query-cancel signal, to avoid a late reaction
2477 * to an automatically-sent signal because of vacuuming the
2478 * current table (we're done with it, so it would make no sense to
2479 * cancel at this point.)
2480 */
2482 }
2484 {
2485 /*
2486 * Abort the transaction, start a new one, and proceed with the
2487 * next table in our list.
2488 */
2493 else
2498 /* this resets ProcGlobal->statusFlags[i] too */
2503 /* restart our transaction for the following operations */
2506 }
2509 /* Make sure we're back in AutovacMemCxt */
2514 /* ProcGlobal->statusFlags[i] are reset at the next end of xact */
2516 /* be tidy */
2517 deleted:
2526 /*
2527 * Remove my info from shared memory. We could, but intentionally
2528 * don't, clear wi_cost_limit and friends --- this is on the
2529 * assumption that we probably have more to do with similar cost
2530 * settings, so we don't want to give up our share of I/O for a very
2531 * short interval and thereby thrash the global balance.
2532 */
2538 /* restore vacuum cost GUCs for the next iteration */
2541 }
2543 /*
2544 * Perform additional work items, as requested by backends.
2545 */
2548 {
2558 /* claim this one, and release lock while performing it */
2564 /*
2565 * Check for config changes before acquiring lock for further jobs.
2566 */
2569 {
2572 }
2576 /* and mark it done */
2579 }
2582 /*
2583 * We leak table_toast_map here (among other things), but since we're
2584 * going away soon, it's not a problem.
2585 */
2587 /*
2588 * Update pg_database.datfrozenxid, and truncate pg_xact if possible. We
2589 * only need to do this once, not after each table.
2590 *
2591 * Even if we didn't vacuum anything, it may still be important to do
2592 * this, because one indirect effect of vac_update_datfrozenxid() is to
2593 * update ShmemVariableCache->xidVacLimit. That might need to be done
2594 * even if we haven't vacuumed anything, because relations with older
2595 * relfrozenxid values or other databases with older datfrozenxid values
2596 * might have been dropped, allowing xidVacLimit to advance.
2597 *
2598 * However, it's also important not to do this blindly in all cases,
2599 * because when autovacuum=off this will restart the autovacuum launcher.
2600 * If we're not careful, an infinite loop can result, where workers find
2601 * no work to do and restart the launcher, which starts another worker in
2602 * the same database that finds no work to do. To prevent that, we skip
2603 * this if (1) we found no work to do and (2) we skipped at least one
2604 * table due to concurrent autovacuum activity. In that case, the other
2605 * worker has already done it, or will do so when it finishes.
2606 */
2610 /* Finally close out the last transaction. */
2612 }
2614 /*
2615 * Execute a previously registered work item.
2616 */
2617 static void
2619 {
2624 /*
2625 * Note we do not store table info in MyWorkerInfo, since this is not
2626 * vacuuming proper.
2627 */
2629 /*
2630 * Save the relation name for a possible error message, to avoid a catalog
2631 * lookup in case of an error. If any of these return NULL, then the
2632 * relation has been dropped since last we checked; skip it.
2633 */
2644 /* clean up memory before each work item */
2647 /*
2648 * We will abort the current work item if something errors out, and
2649 * continue with the next one; in particular, this happens if we are
2650 * interrupted with SIGINT. Note that this means that the work item list
2651 * can be lossy.
2652 */
2654 {
2655 /* Use PortalContext for any per-work-item allocations */
2658 /* have at it */
2660 {
2670 }
2672 /*
2673 * Clear a possible query-cancel signal, to avoid a late reaction to
2674 * an automatically-sent signal because of vacuuming the current table
2675 * (we're done with it, so it would make no sense to cancel at this
2676 * point.)
2677 */
2679 }
2681 {
2682 /*
2683 * Abort the transaction, start a new one, and proceed with the next
2684 * table in our list.
2685 */
2691 /* this resets ProcGlobal->statusFlags[i] too */
2696 /* restart our transaction for the following operations */
2699 }
2702 /* Make sure we're back in AutovacMemCxt */
2705 /* We intentionally do not set did_vacuum here */
2707 /* be tidy */
2708 deleted2:
2715 }
2717 /*
2718 * extract_autovac_opts
2719 *
2720 * Given a relation's pg_class tuple, return the AutoVacOpts portion of
2721 * reloptions, if set; otherwise, return NULL.
2722 *
2723 * Note: callers do not have a relation lock on the table at this point,
2724 * so the table could have been dropped, and its catalog rows gone, after
2725 * we acquired the pg_class row. If pg_class had a TOAST table, this would
2726 * be a risk; fortunately, it doesn't.
2727 */
2730 {
2747 }
2750 /*
2751 * table_recheck_autovac
2752 *
2753 * Recheck whether a table still needs vacuum or analyze. Return value is a
2754 * valid autovac_table pointer if it does, NULL otherwise.
2755 *
2756 * Note that the returned autovac_table does not have the name fields set.
2757 */
2760 TupleDesc pg_class_desc,
2762 {
2763 Form_pg_class classForm;
2764 HeapTuple classTup;
2771 /* fetch the relation's relcache entry */
2777 /*
2778 * Get the applicable reloptions. If it is a TOAST table, try to get the
2779 * main table reloptions if the toast table itself doesn't have.
2780 */
2784 {
2791 }
2794 effective_multixact_freeze_max_age,
2797 /* OK, it needs something done */
2799 {
2808 /*
2809 * Calculate the vacuum cost parameters and the freeze ages. If there
2810 * are options set in pg_class.reloptions, use them; in the case of a
2811 * toast table, try the main table too. Otherwise use the GUC
2812 * defaults, autovacuum's own first and plain vacuum second.
2813 */
2815 /* -1 in autovac setting means use plain vacuum_cost_delay */
2819 ? autovacuum_vac_cost_delay
2822 /* 0 or -1 in autovac setting means use plain vacuum_cost_limit */
2826 ? autovacuum_vac_cost_limit
2829 /* -1 in autovac setting means use log_autovacuum_min_duration */
2834 /* these do not have autovacuum-specific settings */
2857 /*
2858 * Select VACUUM options. Note we don't say VACOPT_PROCESS_TOAST, so
2859 * that vacuum() skips toast relations. Also note we tell vacuum() to
2860 * skip vac_update_datfrozenxid(); we'll do that separately.
2861 */
2864 VACOPT_PROCESS_MAIN |
2869 /*
2870 * index_cleanup and truncate are unspecified at first in autovacuum.
2871 * They will be filled in with usable values using their reloptions
2872 * (or reloption defaults) later.
2873 */
2876 /* As of now, we don't support parallel vacuum for autovacuum */
2890 /*
2891 * If any of the cost delay parameters has been set individually for
2892 * this table, disable the balancing algorithm.
2893 */
2897 }
2901 }
2903 /*
2904 * recheck_relation_needs_vacanalyze
2905 *
2906 * Subroutine for table_recheck_autovac.
2907 *
2908 * Fetch the pgstat of a relation and recheck whether a relation
2909 * needs to be vacuumed or analyzed.
2910 */
2911 static void
2914 Form_pg_class classForm,
2919 {
2922 /* fetch the pgstat table entry */
2924 relid);
2927 effective_multixact_freeze_max_age,
2930 /* ignore ANALYZE for toast tables */
2933 }
2935 /*
2936 * relation_needs_vacanalyze
2937 *
2938 * Check whether a relation needs to be vacuumed or analyzed; return each into
2939 * "dovacuum" and "doanalyze", respectively. Also return whether the vacuum is
2940 * being forced because of Xid or multixact wraparound.
2941 *
2942 * relopts is a pointer to the AutoVacOpts options (either for itself in the
2943 * case of a plain table, or for either itself or its parent table in the case
2944 * of a TOAST table), NULL if none; tabentry is the pgstats entry, which can be
2945 * NULL.
2946 *
2947 * A table needs to be vacuumed if the number of dead tuples exceeds a
2948 * threshold. This threshold is calculated as
2949 *
2950 * threshold = vac_base_thresh + vac_scale_factor * reltuples
2951 *
2952 * For analyze, the analysis done is that the number of tuples inserted,
2953 * deleted and updated since the last analyze exceeds a threshold calculated
2954 * in the same fashion as above. Note that the cumulative stats system stores
2955 * the number of tuples (both live and dead) that there were as of the last
2956 * analyze. This is asymmetric to the VACUUM case.
2957 *
2958 * We also force vacuum if the table's relfrozenxid is more than freeze_max_age
2959 * transactions back, and if its relminmxid is more than
2960 * multixact_freeze_max_age multixacts back.
2961 *
2962 * A table whose autovacuum_enabled option is false is
2963 * automatically skipped (unless we have to vacuum it due to freeze_max_age).
2964 * Thus autovacuum can be disabled for specific tables. Also, when the cumulative
2965 * stats system does not have data about a table, it will be skipped.
2966 *
2967 * A table whose vac_base_thresh value is < 0 takes the base value from the
2968 * autovacuum_vacuum_threshold GUC variable. Similarly, a vac_scale_factor
2969 * value < 0 is substituted with the value of
2970 * autovacuum_vacuum_scale_factor GUC variable. Ditto for analyze.
2971 */
2972 static void
2975 Form_pg_class classForm,
2978 /* output params below */
2982 {
2987 /* constants from reloptions or GUC variables */
2989 vac_ins_base_thresh,
2990 anl_base_thresh;
2991 float4 vac_scale_factor,
2992 vac_ins_scale_factor,
2993 anl_scale_factor;
2995 /* thresholds calculated from above constants */
2996 float4 vacthresh,
2997 vacinsthresh,
2998 anlthresh;
3000 /* number of vacuum (resp. analyze) tuples at this time */
3001 float4 vactuples,
3002 instuples,
3003 anltuples;
3005 /* freeze parameters */
3008 TransactionId xidForceLimit;
3009 MultiXactId multiForceLimit;
3014 /*
3015 * Determine vacuum/analyze equation parameters. We have two possible
3016 * sources: the passed reloptions (which could be a main table or a toast
3017 * table), or the autovacuum GUC variables.
3018 */
3020 /* -1 in autovac setting means use plain vacuum_scale_factor */
3033 /* -1 is used to disable insert vacuums */
3056 /* Force vacuum if table is at risk of wraparound */
3062 xidForceLimit));
3064 {
3070 }
3073 /* User disabled it in pg_class.reloptions? (But ignore if at risk) */
3075 {
3079 }
3081 /*
3082 * If we found stats for the table, and autovacuum is currently enabled,
3083 * make a threshold-based decision whether to vacuum and/or analyze. If
3084 * autovacuum is currently disabled, we must be here for anti-wraparound
3085 * vacuuming only, so don't vacuum (or analyze) anything that's not being
3086 * forced.
3087 */
3089 {
3095 /* If the table hasn't yet been vacuumed, take reltuples as zero */
3103 /*
3104 * Note that we don't need to take special consideration for stat
3105 * reset, because if that happens, the last vacuum and analyze counts
3106 * will be reset too.
3107 */
3109 elog(DEBUG3, "%s: vac: %.0f (threshold %.0f), ins: %.0f (threshold %.0f), anl: %.0f (threshold %.0f)",
3112 else
3117 /* Determine if this table needs vacuum or analyze. */
3121 }
3122 else
3123 {
3124 /*
3125 * Skip a table not found in stat hash, unless we have to force vacuum
3126 * for anti-wrap purposes. If it's not acted upon, there's no need to
3127 * vacuum it.
3128 */
3131 }
3133 /* ANALYZE refuses to work with pg_statistic */
3136 }
3138 /*
3139 * autovacuum_do_vac_analyze
3140 * Vacuum and/or analyze the specified table
3141 */
3142 static void
3144 {
3149 /* Let pgstat know what we're doing */
3152 /* Set up one VacuumRelation target, identified by OID, for vacuum() */
3158 }
3160 /*
3161 * autovac_report_activity
3162 * Report to pgstat what autovacuum is doing
3163 *
3164 * We send a SQL string corresponding to what the user would see if the
3165 * equivalent command was to be issued manually.
3166 *
3167 * Note we assume that we are going to report the next command as soon as we're
3168 * done with the current one, and exit right after the last one, so we don't
3169 * bother to report "<IDLE>" or some such.
3170 */
3171 static void
3173 {
3174 #define MAX_AUTOVAC_ACTIV_LEN (NAMEDATALEN * 2 + 56)
3178 /* Report the command and possible options */
3183 else
3187 /*
3188 * Report the qualified name of the relation.
3189 */
3196 /* Set statement_timestamp() to current time for pg_stat_activity */
3200 }
3202 /*
3203 * autovac_report_workitem
3204 * Report to pgstat that autovacuum is processing a work item
3205 */
3206 static void
3209 {
3215 {
3220 }
3222 /*
3223 * Report the qualified name of the relation, and the block number if any
3224 */
3229 else
3235 /* Set statement_timestamp() to current time for pg_stat_activity */
3239 }
3241 /*
3242 * AutoVacuumingActive
3243 * Check GUC vars and report whether the autovacuum process should be
3244 * running.
3245 */
3246 bool
3248 {
3252 }
3254 /*
3255 * Request one work item to the next autovacuum run processing our database.
3256 * Return false if the request can't be recorded.
3257 */
3258 bool
3260 BlockNumber blkno)
3261 {
3267 /*
3268 * Locate an unused work item and fill it with the given data.
3269 */
3271 {
3285 /* done */
3287 }
3292 }
3294 /*
3295 * autovac_init
3296 * This is called at postmaster initialization.
3297 *
3298 * All we do here is annoy the user if he got it wrong.
3299 */
3300 void
3302 {
3307 }
3309 /*
3310 * IsAutoVacuum functions
3311 * Return whether this is either a launcher autovacuum process or a worker
3312 * process.
3313 */
3314 bool
3316 {
3318 }
3320 bool
3322 {
3324 }
3327 /*
3328 * AutoVacuumShmemSize
3329 * Compute space needed for autovacuum-related shared memory
3330 */
3331 Size
3333 {
3334 Size size;
3336 /*
3337 * Need the fixed struct and the array of WorkerInfoData.
3338 */
3344 }
3346 /*
3347 * AutoVacuumShmemInit
3348 * Allocate and initialize autovacuum-related shared memory
3349 */
3350 void
3352 {
3361 {
3362 WorkerInfo worker;
3377 /* initialize the WorkerInfo free list */
3381 }
3382 else
3384 }
3386 /*
3387 * GUC check_hook for autovacuum_work_mem
3388 */
3389 bool
3391 {
3392 /*
3393 * -1 indicates fallback.
3394 *
3395 * If we haven't yet changed the boot_val default of -1, just let it be.
3396 * Autovacuum will look to maintenance_work_mem instead.
3397 */
3401 /*
3402 * We clamp manually-set values to at least 1MB. Since
3403 * maintenance_work_mem is always set to at least this value, do the same
3404 * here.
3405 */
3410 }