背景

PostgreSQL 有3种停库模式：

“Smart” mode waits for all active clients to disconnect and any online backup to finish.
If the server is in hot standby, recovery and streaming replication will be terminated once all clients have disconnected.

“Fast” mode (the default) does not wait for clients to disconnect and will terminate an online backup in progress.
All active transactions are rolled back and clients are forcibly disconnected, then the server is shut down.

“Immediate” mode will abort all server processes immediately, without a clean shutdown.
This choice will lead to a crash-recovery cycle during the next server start.

smart ：等用户进程自然退出。最后做检查点。

fast ： 主动断开用户进程。最后做检查点。

immediate ： 直接停库（不做检查点，最快）。

除了用户进程，还有归档进程、walsender进程。smart,fast停库时，这些进程又会如何处理呢？

如果数据库开启了归档，smart, fast 停库时会怎么处理pgarch进程

发起最后一次archive周期，将所有.ready的wal进行归档，除非中间archive_command遇到错误，否则要等所有的.ready文件都触发并执行完成archive_command。

如果有walsender进程在，smart, fast 停库时会怎么处理walsender进程

如果有walsender进程存在（例如有standby，有pg_basebackup，有pg_receivewal等利用流复制协议的客户端就有walsender进程），那么要等这个walsender将所有未发送完的wal日志都发送给下游。

src/backend/postmaster/postmaster.c

注释如下

  1. /*  
  2.  * Reaper -- signal handler to cleanup after a child process dies.  
  3.  */  
  4. static void  
  5. reaper(SIGNAL_ARGS)  
  6. {  
  8. .....................  
  9.         while ((pid = waitpid(-1, &exitstatus, WNOHANG)) > 0)  
  10.         {  
  12. .......................  
  14.                 /*  
  15.                  * Was it the checkpointer?  
  16.                  */  
  17.                 if (pid == CheckpointerPID)  
  18.                 {  
  19.                         CheckpointerPID = 0;  
  20.                         if (EXIT_STATUS_0(exitstatus) && pmState == PM_SHUTDOWN)  
  21.                         {  
  22.                                 /*  
  23.                                  * OK, we saw normal exit of the checkpointer after it's been  
  24.                                  * told to shut down.  We expect that it wrote a shutdown  
  25.                                  * checkpoint.  (If for some reason it didn't, recovery will  
  26.                                  * occur on next postmaster start.)  
  27.                                  *  
  28.                                  * At this point we should have no normal backend children  
  29.                                  * left (else we'd not be in PM_SHUTDOWN state) but we might  
  30.                                  * have dead_end children to wait for.  
  31.                                  *  
  32.                                  * If we have an archiver subprocess, tell it to do a last  
  33.                                  * archive cycle and quit. Likewise, if we have walsender  
  34.                                  * processes, tell them to send any remaining WAL and quit.  
  35.                                  */  
  36.                                 Assert(Shutdown > NoShutdown);  
  38.                                 /* 唤醒归档进程 进行一轮归档 */  
  39.                                 /* Waken archiver for the last time */  
  40.                                 if (PgArchPID != 0)  
  41.                                         signal_child(PgArchPID, SIGUSR2);  
  43.                                 /* wal sender，发送完所有未发送的redo */  
  44.                                 /*  
  45.                                  * Waken walsenders for the last time. No regular backends  
  46.                                  * should be around anymore.  
  47.                                  */  
  48.                                 SignalChildren(SIGUSR2);  
  50.                                 pmState = PM_SHUTDOWN_2;  
  52.                                 /*  
  53.                                  * We can also shut down the stats collector now; there's  
  54.                                  * nothing left for it to do.  
  55.                                  */  
  56.                                 if (PgStatPID != 0)  
  57.                                         signal_child(PgStatPID, SIGQUIT);  
  58.                         }

唤醒归档

src/backend/postmaster/pgarch.c

  1. /* SIGUSR2 signal handler for archiver process */  
  2. static void  
  3. pgarch_waken_stop(SIGNAL_ARGS)  
  4. {  
  5.         int                     save_errno = errno;  
  7.         /* set flag to do a final cycle and shut down afterwards */  
  8.         /* 停库，触发最后一轮归档周期 */  
  9.         ready_to_stop = true;  
  10.         SetLatch(MyLatch);  
  12.         errno = save_errno;  
  13. }
  1. /*  
  2.  * pgarch_MainLoop  
  3.  *  
  4.  * Main loop for archiver  
  5.  */  
  6. static void  
  7. pgarch_MainLoop(void)  
  8. {  
  9.         pg_time_t       last_copy_time = 0;  
  10.         bool            time_to_stop;  
  12.         /*  
  13.          * We run the copy loop immediately upon entry, in case there are  
  14.          * unarchived files left over from a previous database run (or maybe the  
  15.          * archiver died unexpectedly).  After that we wait for a signal or  
  16.          * timeout before doing more.  
  17.          */  
  18.         wakened = true;  
  20.         /*  
  21.          * There shouldn't be anything for the archiver to do except to wait for a  
  22.          * signal ... however, the archiver exists to protect our data, so she  
  23.          * wakes up occasionally to allow herself to be proactive.  
  24.          */  
  25.         do  
  26.         {  
  27.                 ResetLatch(MyLatch);  
  29.                 /* When we get SIGUSR2, we do one more archive cycle, then exit */  
  30.                 /* 停库，触发最后一轮归档周期 */  
  31.                 time_to_stop = ready_to_stop;  
  33.                 /* Check for config update */  
  34.                 if (got_SIGHUP)  
  35.                 {  
  36.                         got_SIGHUP = false;  
  37.                         ProcessConfigFile(PGC_SIGHUP);  
  38.                 }  
  40.                 /*  
  41.                  * If we've gotten SIGTERM, we normally just sit and do nothing until  
  42.                  * SIGUSR2 arrives.  However, that means a random SIGTERM would  
  43.                  * disable archiving indefinitely, which doesn't seem like a good  
  44.                  * idea.  If more than 60 seconds pass since SIGTERM, exit anyway, so  
  45.                  * that the postmaster can start a new archiver if needed.  
  46.                  */  
  47.                 if (got_SIGTERM)  
  48.                 {  
  49.                         time_t          curtime = time(NULL);  
  51.                         if (last_sigterm_time == 0)  
  52.                                 last_sigterm_time = curtime;  
  53.                         else if ((unsigned int) (curtime - last_sigterm_time) >=  
  54.                                          (unsigned int) 60)  
  55.                                 break;  
  56.                 }  
  58.                 /* Do what we're here for */  
  59.                 if (wakened || time_to_stop)  
  60.                 {  
  61.                         wakened = false;  
  62.                         pgarch_ArchiverCopyLoop();   // 最后一次循环  
  63.                         last_copy_time = time(NULL);  
  64.                 }  
  66.                 /*  
  67.                  * Sleep until a signal is received, or until a poll is forced by  
  68.                  * PGARCH_AUTOWAKE_INTERVAL having passed since last_copy_time, or  
  69.                  * until postmaster dies.  
  70.                  */  
  71.                 if (!time_to_stop)              /* Don't wait during last iteration */  
  72.                 {  
  73.                         pg_time_t       curtime = (pg_time_t) time(NULL);  
  74.                         int                     timeout;  
  76.                         timeout = PGARCH_AUTOWAKE_INTERVAL - (curtime - last_copy_time);  
  77.                         if (timeout > 0)  
  78.                         {  
  79.                                 int                     rc;  
  81.                                 rc = WaitLatch(MyLatch,  
  82.                                                            WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH,  
  83.                                                            timeout * 1000L,  
  84.                                                            WAIT_EVENT_ARCHIVER_MAIN);  
  85.                                 if (rc & WL_TIMEOUT)  
  86.                                         wakened = true;  
  87.                                 if (rc & WL_POSTMASTER_DEATH)  
  88.                                         time_to_stop = true;  
  89.                         }  
  90.                         else  
  91.                                 wakened = true;  
  92.                 }  
  94.                 /*  
  95.                  * The archiver quits either when the postmaster dies (not expected)  
  96.                  * or after completing one more archiving cycle after receiving  
  97.                  * SIGUSR2.  
  98.                  */  
  99.         } while (!time_to_stop);  /* 停库，触发最后一轮归档周期 */  
  100. }

归档所有未归档日志，直到全部的.ready对应调度wal都归档完成，或者报错

  1. /*  
  2.  * pgarch_ArchiverCopyLoop  
  3.  *  
  4.  * Archives all outstanding xlogs then returns  
  5.  */  
  6. static void  
  7. pgarch_ArchiverCopyLoop(void)  
  8. {  
  9.         char            xlog[MAX_XFN_CHARS + 1];  
  11.         /*  
  12.          * loop through all xlogs with archive_status of .ready and archive  
  13.          * them...mostly we expect this to be a single file, though it is possible  
  14.          * some backend will add files onto the list of those that need archiving  
  15.          * while we are still copying earlier archives  
  16.          */  
  17.         while (pgarch_readyXlog(xlog))  
  18.         {  
  19.                 int                     failures = 0;  
  20.                 int                     failures_orphan = 0;  
  22.                 for (;;)  
  23.                 {  
  24.                         struct stat stat_buf;  
  25.                         char            pathname[MAXPGPATH];  
  27.                         /*  
  28.                          * Do not initiate any more archive commands after receiving  
  29.                          * SIGTERM, nor after the postmaster has died unexpectedly. The  
  30.                          * first condition is to try to keep from having init SIGKILL the  
  31.                          * command, and the second is to avoid conflicts with another  
  32.                          * archiver spawned by a newer postmaster.  
  33.                          */  
  34.                         if (got_SIGTERM || !PostmasterIsAlive())  
  35.                                 return;  
  37.                         /*  
  38.                          * Check for config update.  This is so that we'll adopt a new  
  39.                          * setting for archive_command as soon as possible, even if there  
  40.                          * is a backlog of files to be archived.  
  41.                          */  
  42.                         if (got_SIGHUP)  
  43.                         {  
  44.                                 got_SIGHUP = false;  
  45.                                 ProcessConfigFile(PGC_SIGHUP);  
  46.                         }  
  48.                         /* can't do anything if no command ... */  
  49.                         if (!XLogArchiveCommandSet())  
  50.                         {  
  51.                                 ereport(WARNING,  
  52.                                                 (errmsg("archive_mode enabled, yet archive_command is not set")));  
  53.                                 return;  
  54.                         }  
  56.                         /*  
  57.                          * Since archive status files are not removed in a durable manner,  
  58.                          * a system crash could leave behind .ready files for WAL segments  
  59.                          * that have already been recycled or removed.  In this case,  
  60.                          * simply remove the orphan status file and move on.  unlink() is  
  61.                          * used here as even on subsequent crashes the same orphan files  
  62.                          * would get removed, so there is no need to worry about  
  63.                          * durability.  
  64.                          */  
  65.                         snprintf(pathname, MAXPGPATH, XLOGDIR "/%s", xlog);  
  66.                         if (stat(pathname, &stat_buf) != 0 && errno == ENOENT)  
  67.                         {  
  68.                                 char            xlogready[MAXPGPATH];  
  70.                                 StatusFilePath(xlogready, xlog, ".ready");  
  71.                                 if (unlink(xlogready) == 0)  
  72.                                 {  
  73.                                         ereport(WARNING,  
  74.                                                         (errmsg("removed orphan archive status file \"%s\"",  
  75.                                                                         xlogready)));  
  77.                                         /* leave loop and move to the next status file */  
  78.                                         break;  
  79.                                 }  
  81.                                 if (++failures_orphan >= NUM_ORPHAN_CLEANUP_RETRIES)  
  82.                                 {  
  83.                                         ereport(WARNING,  
  84.                                                         (errmsg("removal of orphan archive status file \"%s\" failed too many times, will try again later",  
  85.                                                                         xlogready)));  
  87.                                         /* give up cleanup of orphan status files */  
  88.                                         return;  
  89.                                 }  
  91.                                 /* wait a bit before retrying */  
  92.                                 pg_usleep(1000000L);  
  93.                                 continue;  
  94.                         }  
  96.                         if (pgarch_archiveXlog(xlog))  
  97.                         {  
  98.                                 /* successful */  
  99.                                 pgarch_archiveDone(xlog);  
  101.                                 /*  
  102.                                  * Tell the collector about the WAL file that we successfully  
  103.                                  * archived  
  104.                                  */  
  105.                                 pgstat_send_archiver(xlog, false);  
  107.                                 break;                  /* out of inner retry loop */  
  108.                         }  
  109.                         else  
  110.                         {  
  111.                                 /*  
  112.                                  * Tell the collector about the WAL file that we failed to  
  113.                                  * archive  
  114.                                  */  
  115.                                 pgstat_send_archiver(xlog, true);  
  117.                                 if (++failures >= NUM_ARCHIVE_RETRIES)  
  118.                                 {  
  119.                                         ereport(WARNING,  
  120.                                                         (errmsg("archiving write-ahead log file \"%s\" failed too many times, will try again later",  
  121.                                                                         xlog)));  
  122.                                         return;         /* give up archiving for now */  
  123.                                 }  
  124.                                 pg_usleep(1000000L);    /* wait a bit before retrying */  
  125.                         }  
  126.                 }  
  127.         }  
  128. }

那么fast,smart停库时，如果有walsender或归档时到底有什么问题？

1、如果walsender有很多很多的wal没有发送完，则停库可能要很久很久（因为要等walsender发完）

2、同样的道理，如果有很多很多文件没有归档，并且归档过程中没有报错，则一个归档周期会非常漫长，也会导致停库可能要很久很久。

immediate模式停库没有影响，但是immediate停库不写检查点，启动数据库时需要进入recovery模式恢复数据库。