【深度】ArteryBase事务日志（2）--从关机中恢复

2022-03-29 00:00:00 数据库 事务 记录 进程 检查点

【深度】ArteryBase事务日志（2）--从关机中恢复

@(arterybase)

概述

我们对数据库的关机、重启往往习以为常，甚至认为启动数据库和打开一个word文档差不多。实际上，在数据库启动的过程中，需要做很多事情，包括守护进程的初始化、建立辅助进程等很多复杂的工作。 本文尝试分析数据库如何利用事务日志实现从关机中恢复数据库全局状态、实现数据一致性。

术语

参见《【深度】ArteryBase事务日志（1）》

数据库关闭时涉及事务日志简单描述

数据库实例正常关闭时，数据库服务器会创建关机检查点并将检查点信息记录到xlog日志文件中并写回磁盘，将缓存中的数据写回磁盘。 如果数据库未正常关闭，xlog日志中将没有该次关机检查点，会存在已经提交的事务没有保存到磁盘的情况。

数据库启动时的事务日志处理概述

数据库启动时，首先启动守护进程，守护进程创建：startup process进程；该进程通过读取控制文件，找到后一个checkpoint（检查点）在xlog文件中的位置，根据位置信息在xlog中读取到检查点信息，然后判断：

  • 如果检查点为关机检查点，说明数据正确写回磁盘，startup process进程使命完成，startup process进程关闭。

  • 如果非正常关闭数据库，则后一个检查点不是关机检查点： （1）此时就需要对检查点以后的xlog日志重做（redo），使数据和事务日志保持一致，从而保证了数据库的持久性要求，即对数据库所作的更改，事务一旦提交生效。startup process进程关闭。 （2）守护进程检测到startup process退出后，判断其是否为正确退出，如果为是，数据库启动完成；否则，数据库无法启动，关闭所有数据库进程。

startup process重要步骤分析

重要步骤有7步，具体为：

  • 1、启动进程读取控制文件$PGDATA/global/pg_control

    

  1. /* 读取控制文件 global/pg_control*/
    2. 

  2. ReadControlFile(); 
    3.

源码及调用堆栈：

    

  1.    ┌──xlog.c──────────────────────────────────┐
    2. 

  2.    │5891             * Read control file and check XLOG status look   │
    3. 

  3.    │5892             *                                                │
    4. 

  4.    │5893             * Note: in most control paths, *ControlFile is a │
    5. 

  5.    │5894             * not do ReadControlFile() here, but might as    │
    6. 

  6.    │5895             */                                               │
    7. 

  7.   >│5896            ReadControlFile();                                │
    8. 

  8.    │5897                                                              │
    9. 

  9.    │5898            if (ControlFile->state < DB_SHUTDOWNED ||         │
    10. 

  10.    │5899                    ControlFile->state > DB_IN_PRODUCTION ||  │
    11. 

  11.    │5900                    !XRecOffIsValid(ControlFile->checkPoint)) │
    12. 

  12.    │5901                    ereport(FATAL,                            │
    13. 

  13.    │5902                                    (errmsg("control file cont│
    14. 

  14.    │5903                                                              │
    15. 

  15.    └────────────────────────────────────────┘
    16. 

  16. multi-thre Thread 0x7ffff In: StartupXLOG               Line: 5896 PC: 0x52652d 
    17. 

  17. #0  StartupXLOG    () at xlog.c:5896
    18. 

  18. #1  0x000000000076e394 in StartupProcessMain ()    at startup.c:215
    19. 

  19. #2  0x000000000053af6f in AuxiliaryProcessMain (argc=2,    argv=0x7fffffffdf70)
    20. 

  20.     at bootstrap.c:418
    21. 

  21. #3  0x000000000076d557 in StartChildProcess (type=StartupProcess)
    22. 

  22.     at postmaster.c:5203
    23. 

  23. #4  0x00000000007683b3 in PostmasterMain (argc=1, argv=0xe50fa0)
    24. 

  24. bootstrap.c:418
    25. 

  25. #5  0x00000000006c018a in main (argc=1,    argv=0xe50fa0) at main.c:228
    26.

  • 2、启动进程从xlog日志中得到检查点信息，检查点数据结构包括很多内容，包括当前数据库的时间线ThisTimeLineID值，检查点的数据结构为：

    

  1. typedef struct CheckPoint
    2. 

  2. {
    3. 

  3.     XLogRecPtr  redo;           /* next RecPtr available when we began to
    4. 

  4.                                  * create CheckPoint (i.e. REDO start point) */
    5. 

  5.     TimeLineID  ThisTimeLineID; /* current TLI */
    6. 

  6.     TimeLineID  PrevTimeLineID; /* previous TLI, if this record begins a new
    7. 

  7.                                  * timeline (equals ThisTimeLineID otherwise) */
    8. 

  8.     bool        fullPageWrites; /* current full_page_writes */
    9. 

  9.     uint32      nextXidEpoch;   /* higher-order bits of nextXid */
    10. 

  10.     TransactionId nextXid;      /* next free XID */
    11. 

  11.     Oid         nextOid;        /* next free OID */
    12. 

  12.     MultiXactId nextMulti;      /* next free MultiXactId */
    13. 

  13.     MultiXactOffset nextMultiOffset;    /* next free MultiXact offset */
    14. 

  14.     TransactionId oldestXid;    /* cluster-wide minimum datfrozenxid */
    15. 

  15.     Oid         oldestXidDB;    /* database with minimum datfrozenxid */
    16. 

  16.     MultiXactId oldestMulti;    /* cluster-wide minimum datminmxid */
    17. 

  17.     Oid         oldestMultiDB;  /* database with minimum datminmxid */
    18. 

  18.     pg_time_t   time;           /* time stamp of checkpoint */
    19. 

  19.     TransactionId oldestCommitTsXid;    /* oldest Xid with valid commit
    20. 

  20.                                          * timestamp */
    21. 

  21.     TransactionId newestCommitTsXid;    /* newest Xid with valid commit
    22. 

  22.                                          * timestamp */
    23. 

    24. 

  24.     TransactionId oldestActiveXid;
    25. 

  25. } CheckPoint;
    26.

得到检查点信息的处理过程为：

    

  1. /* xlog.c */
    2. 

  2. void
    3. 

  3. StartupXLOG(void)
    4. 

  4. {
    5. 

  5.     ...
    6. 

  6.     /* 从控制文件中得到检查点的位置 */
    7. 

  7.     checkPointLoc = ControlFile->checkPoint;
    8. 

  8.     ...
    9. 

  9.     /* 从xlog中，根据检查点位置读取检查点记录 */
    10. 

  10.     record = ReadCheckpointRecord(xlogreader, checkPointLoc, 1, true);
    11. 

  11.     ...
    12. 

  12.     /* 得到检查点信息 */
    13. 

  13.     memcpy(&checkPoint, XLogRecGetData(xlogreader), sizeof(CheckPoint));
    14. 

  14.     ...
    15. 

  15. }
    16.

  • 3、将从检查点得到的信息写入共享内存的相应变量中，包括XLogCtl、ShmemVariableCache等

    

  1. /* xlog.c */
    2. 

  2. void
    3. 

  3. StartupXLOG(void)
    4. 

  4. {
    5. 

  5.     ...
    6. 

  6.     /* 初始化共享内存变量 */
    7. 

  7.     ShmemVariableCache->nextXid = checkPoint.nextXid;
    8. 

  8.     ShmemVariableCache->nextOid = checkPoint.nextOid;
    9. 

  9.     ShmemVariableCache->oidCount = ;
    10. 

  10.     MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
    11. 

  11.     SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
    12. 

  12.     SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB);
    13. 

  13.     SetCommitTsLimit(checkPoint.oldestCommitTsXid,
    14. 

  14.                      checkPoint.newestCommitTsXid);
    15. 

    16. 

  16.     XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch;
    17. 

  17.     XLogCtl->ckptXid = checkPoint.nextXid;
    18. 

  18.     /* 将ThisTimeLineID保存到共享内存中 */
    19. 

  19.     XLogCtl->ThisTimeLineID = ThisTimeLineID;
    20. 

  20.     ShmemVariableCache->nextXid = checkPoint.nextXid;
    21. 

  21.     ShmemVariableCache->nextOid = checkPoint.nextOid;
    22. 

  22.     ...
    23. 

  23. }
    24.

P.S. 全局变量XLogCtl等信息在守护进程postmaster启动时已加入到共享内存中，源码及调用堆栈如下图所示： 

 至此，数据库已经恢复到了检查点位置。

  • 4、利用xlog日志重做（redo）检查点以后的事务

制作不正常关闭数据库的场景的方法：psql 登录执行DDL、DML操作，成功后马上用kill -9 命令把postmaster守护进程杀掉。

    

  1. /*
    2. 

  2.    xlog.c
    3. 

  3.      */
    4. 

  4. void startxlog()
    5. 

  5. {
    6. 

  6.     ...
    7. 

  7.     /*
    8. 

  8.     当控制文件的状态不是关机时，需要恢复
    9. 

  9.      */
    10. 

  10.     if (ControlFile->state != DB_SHUTDOWNED)
    11. 

  11.         InRecovery = true;
    12. 

  12.     ...
    13. 

    14. 

  14. /* 对xlog中记录了，但是不一定刷回磁盘的事务，根据xlog日志记录的信息进行重做 */
    15. 

  15.     if (InRecovery)
    16. 

  16.     {
    17. 

  17.         //找到需要重做的条记录。如果检查点记录的redo位置小于检查点自身的位置，取值小的开始重做。（这种情况发生在需要在线备份的数据库中）
    18. 

  18.         if (checkPoint.redo < RecPtr)
    19. 

  19.         {
    20. 

  20.             /* 根据检查点中的redo标识，得到条record记录 */
    21. 

  21.             record = ReadRecord(xlogreader, checkPoint.redo, PANIC, false);
    22. 

  22.         }
    23. 

  23.         else
    24. 

  24.         {
    25. 

  25.             /* 读取 CheckPoint记录后面的条记录即可 */
    26. 

  26.             record = ReadRecord(xlogreader, InvalidXLogRecPtr, LOG, false);
    27. 

  27.         }
    28. 

  28.         do
    29. 

  29.         {
    30. 

  30.             /* 调用xlog记录对应的重做函数 */
    31. 

  31.             RmgrTable[record->xl_rmid].rm_redo(xlogreader);
    32. 

  32.             /* 下一条重做函数 */
    33. 

  33.             record = ReadRecord(xlogreader, InvalidXLogRecPtr, LOG, false);
    34. 

  34.         }while (record != NULL);
    35. 

  35. }
    36.

根据ID和函数映射表（类似面向对象的多态调用），调用相应的方法执行某条xlog记录，可以看到不同类型的xlog记录，redo方法各不相同。

    

  1. PG_RMGR(RM_XLOG_ID, "XLOG", xlog_redo, xlog_desc, xlog_identify, NULL, NULL)
    2. 

  2. PG_RMGR(RM_XACT_ID, "Transaction", xact_redo, xact_desc, xact_identify, NULL, NULL)
    3. 

  3. PG_RMGR(RM_SMGR_ID, "Storage", smgr_redo, smgr_desc, smgr_identify, NULL, NULL)
    4. 

  4. PG_RMGR(RM_CLOG_ID, "CLOG", clog_redo, clog_desc, clog_identify, NULL, NULL)
    5. 

  5. ...
    6. 

  6. PG_RMGR(RM_HEAP_ID, "Heap", heap_redo, heap_desc, heap_identify, NULL, NULL)
    7. 

  7. PG_RMGR(RM_BTREE_ID, "Btree", btree_redo, btree_desc, btree_identify, NULL, NULL)
    8. 

  8. PG_RMGR(RM_HASH_ID, "Hash", hash_redo, hash_desc, hash_identify, NULL, NULL)
    9. 

  9. PG_RMGR(RM_GIN_ID, "Gin", gin_redo, gin_desc, gin_identify, gin_xlog_startup, gin_xlog_cleanup)
    10. 

  10. ...
    11.

  • 5、redo方法的具体执行 以表数据修改涉及的heap_redo为例。由于xlog记录是按照元组粒度记录的，并且记录的是该元组要在哪个位置上变化，因此，即使数据已经存在，也不会出现数据重复的问题（只是覆盖该位置上的数据）。

    

  1. void
    2. 

  2. heap_redo(XLogReaderState *record)
    3. 

  3. {
    4. 

  4.     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    5. 

    6. 

    7. 

    8. 

  8.     switch (info & XLOG_HEAP_OPMASK)
    9. 

  9.     {
    10. 

  10.         case XLOG_HEAP_INSERT:
    11. 

  11.             heap_xlog_insert(record);
    12. 

  12.             break;
    13. 

  13.         case XLOG_HEAP_DELETE:
    14. 

  14.             heap_xlog_delete(record);
    15. 

  15.             break;
    16. 

  16.         case XLOG_HEAP_UPDATE:
    17. 

  17.             heap_xlog_update(record, false);
    18. 

  18.             break;
    19. 

  19.         case XLOG_HEAP_HOT_UPDATE:
    20. 

  20.             heap_xlog_update(record, true);
    21. 

  21.             break;
    22. 

  22.         case XLOG_HEAP_CONFIRM:
    23. 

  23.             heap_xlog_confirm(record);
    24. 

  24.             break;
    25. 

  25.         case XLOG_HEAP_LOCK:
    26. 

  26.             heap_xlog_lock(record);
    27. 

  27.             break;
    28. 

  28.         case XLOG_HEAP_INPLACE:
    29. 

  29.             heap_xlog_inplace(record);
    30. 

  30.             break;
    31. 

  31.         default:
    32. 

  32.             elog(PANIC, "heap_redo: unknown op code %u", info);
    33. 

  33.     }
    34. 

  34. }
    35.

  • 6、redo后，创建检查点

    

  1. ...
    2. 

  2. /*进行了恢复 */
    3. 

  3. if (InRecovery)
    4. 

  4. {
    5. 

  5.     /* 后台辅助进程bgwrite进程已经启动，由后台进程创建检查点，否则startup 进程创建检查点 */
    6. 

  6.     if (bgwriterLaunched)
    7. 

  7.     {
    8. 

  8.         ...
    9. 

  9.         RequestCheckpoint(CHECKPOINT_END_OF_RECOVERY |
    10. 

  10.                               CHECKPOINT_IMMEDIATE |
    11. 

  11.                               CHECKPOINT_WAIT);
    12. 

  12.     }
    13. 

  13.     else
    14. 

  14.         CreateCheckPoint(CHECKPOINT_END_OF_RECOVERY | CHECKPOINT_IMMEDIATE);
    15. 

  15. }
    16. 

  16. ...
    17.

  • 7、startup process完成使命，结束进程。守护进程捕捉到startup process正常结束，设置数据库为运行状态。

    

  1. /* startup.c 
    2. 

  2. startup process退出 */
    3. 

  3. void
    4. 

  4. StartupProcessMain(void)
    5. 

  5. {
    6. 

  6.     ...
    7. 

  7.     /* 正常退出*/
    8. 

  8.     proc_exit();
    9. 

  9. }
    10. 

  10. /*
    11. 

  11.  * postmaster.c
    12. 

  12.  * 捕获到进程退出信号
    13. 

  13.  */
    14. 

  14. static void
    15. 

  15. reaper(SIGNAL_ARGS)
    16. 

  16. {
    17. 

  17.     //检测子进程的退出
    18. 

  18.     while ((pid = waitpid(-1, &exitstatus, WNOHANG)) > )
    19. 

  19.     {
    20. 

  20.         if (pid == StartupPID)
    21. 

  21.         {
    22. 

  22.             ...
    23. 

  23.             //先进行非常复杂的退出状态的判断，判断通过后，将数据库状态设置为运行中
    24. 

  24.             pmState = PM_RUN;
    25. 

  25.             ...
    26. 

  26.             /* 输出数据库已经准备接受连接，代表数据库成功启动 */
    27. 

  27.             ereport(LOG,
    28. 

  28.                  (errmsg("database system is ready to accept connections")));
    29. 

  29.             ...
    30. 

  30.         }
    31. 

  31.         ...
    32. 

  32.     }
    33. 

  33.     ...
    34. 

  34. }
    35.

总结

通过以上的分析过程，我们可以看到事务日志的重要性：没有事务日志，数据库就无法启动。因此，数据库需要不断的记录事务日志。下一篇我们介绍事务日志膨胀原因及解决方法，希望能够从实战角度解决事务日志膨胀的问题。

来自：https://mp.weixin.qq.com/s/3nuPLEbWvq7PvopWKa9LKQ


相关文章