深入剖析Redis RDB持久化机制

jieforest

我们可以看到，在读取rdb文件时，当发现长度类型是REDIS_RDB_ENCVAL，把编码类型返回。

我们来看看知道编码类型后的处理

Rdb.c：633

1. robj *rdbGenericLoadStringObject(FILE*fp, int encode) {
   
2.     int isencoded;
   
3.     uint32_t len;
   
4.     sds val;
   
5. 
   
6.     len = rdbLoadLen(fp,&isencoded);
   
7.     if (isencoded) {
   
8.         switch(len) {
   
9.         case REDIS_RDB_ENC_INT8:
   
10.         case REDIS_RDB_ENC_INT16:
    
11.         case REDIS_RDB_ENC_INT32:
    
12.             return rdbLoadIntegerObject(fp,len,encode);
    
13.         case REDIS_RDB_ENC_LZF:
    
14.             return rdbLoadLzfStringObject(fp);
    
15.         default:
    
16.             redisPanic("Unknown RDB encoding type");
    
17.         }
    
18.     }
    
19. 
    
20.     if (len == REDIS_RDB_LENERR) return NULL;
    
21.     val = sdsnewlen(NULL,len);
    
22.     if (len && fread(val,len,1,fp) == 0) {
    
23.         sdsfree(val);
    
24.         return NULL;
    
25.     }
    
26.     return createObject(REDIS_STRING,val);
    
27. }

复制代码

jieforest

1. 读取长度

2. 如果长度类型是有编码信息的，则根据编码类型进行读取

3. 如果长度类型是有效长度，则根据长度信息读取字符串

REDIS_EXPIRETIME类型

1. 如果一个key被expire设置过，那么在该key与value的前面会有一个REDIS_EXPIRETIME类型与其对应的值。

2. REDIS_EXPIRETIME类型对应的值是过期时间点的timestamp

3. REDIS_EXPIRETIME类型与其值是可选的，不是必须的，只有被expire设置过的key才有这个值

jieforest

假设有一个key被expire命令设置过，把这REDIS_EXPIRETIME类型代入到上边的rdb文件的格式中，那么rdb文件的整体格式变成为：

文件签名 | 版本号 | REDIS_SELECTDB类型 | db编号 | REDIS_EXPIRETIME类型 | timestamp | 类型 | 值 | … | REDIS_SELECTD 类型 | db编号 | 类型 | 值 | … | REDIS_EOF类型

数据类型

数据类型主要有以下类型：

REDIS_STRING类型
REDIS_LIST类型
REDIS_SET类型
REDIS_ZSET类型
REDIS_HASH类型
REDIS_VMPOINTER类型
REDIS_HASH_ZIPMAP类型
REDIS_LIST_ZIPLIST类型
REDIS_SET_INTSET类型
REDIS_ZSET_ZIPLIST类型

其中REDIS_HASH_ZIPMAP，REDIS_LIST_ZIPLIST，REDIS_SET_INTSET和REDIS_ZSET_ZIPLIST这四种数据类型都是只在rdb文件中才有的类型，其他的数据类型其实就是val对象中type字段存储的值。

jieforest

下边以REDIS_STRING类型和REDIS_LIST类型为例进行详解，其他类型都类似

REDIS_STRING类型

假设rdb文件中有一个值是REDIS_STRING类型，比如执行了一个set mykey myval命令，则在rdb文件表示为：

REDIS_STRING类型 | 值

其中值包含了key的长度，key的值，val的长度和val的值，把REDIS_STRING类型值的格式代入得：

REDIS_STRING类型 | keylen | mykey | vallen | myval

长度的存储格式见rdb中长度的存储

jieforest

REDIS_LIST类型

1.List

REDIS_LIST | listlen | len | value | len | value

Listlen是链表长度

Len是链表结点的值value的长度

Value是链表结点的值

2.Ziplist

REDIS_ENCODING_ZIPLIST | ziplist

Ziplist就是通过字符串来实现的，直接将其存储于rdb文件中即可

jieforest

快照保存

我们接下来看看具体实现细节

不管是触发条件满足后通过fork子进程来保存快照还是通过save命令来触发，其实都是调用的同一个函数rdbSave（rdb.c：394）。

先来看看触发条件满足后通过fork子进程的实现保存快照的的实现

在每100ms调用一次的serverCron函数中会对快照保存的条件进行检查，如果满足了则进行快照保存

Redis.c：604

1.     /* Check if a background saving or AOF rewrite in progress terminated */
   
2.     if (server.bgsavechildpid != -1 || server.bgrewritechildpid != -1) {
   
3.         int statloc;
   
4.         pid_t pid;
   
5. 
   
6.         if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
   
7.             if (pid == server.bgsavechildpid) {
   
8.                 backgroundSaveDoneHandler(statloc);
   
9.             }
   
10. …
    
11.             updateDictResizePolicy();
    
12.         }
    
13.     } else {
    
14.          time_t now = time(NULL);
    
15. 
    
16.         /* If there is not a background saving in progress check if
    
17.          * we have to save now */
    
18.          for (j = 0; j < server.saveparamslen; j++) {
    
19.             struct saveparam *sp = server.saveparams+j;
    
20. 
    
21.             if (server.dirty >= sp->changes &&
    
22.                 now-server.lastsave > sp->seconds) {
    
23.                 redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving…",
    
24.                     sp->changes, sp->seconds);
    
25.                 rdbSaveBackground(server.dbfilename);
    
26.                 break;
    
27.             }
    
28.          }
    
29.         …
    
30. }

复制代码

jieforest

如果后端有写rdb的子进程或者写aof的子进程，则检查rdb子进程是否退出了，如果退出了则进行一些收尾处理，比如更新脏数据计数server.dirty和最近快照保存时间server.lastsave。

如果后端没有写rdb的子进程且没有写aof的子进程，则判断下是否有触发写rdb的条件满足了，如果有条件满足，则通过调用rdbSaveBackground函数进行快照保存。

跟着进rdbSaveBackground函数里边看看

Rdb.c：499

1. int rdbSaveBackground(char *filename) {
   
2.     pid_t childpid;
   
3.     long long start;
   
4. 
   
5.     if (server.bgsavechildpid != -1) return REDIS_ERR;
   
6.     if (server.vm_enabled) waitEmptyIOJobsQueue();
   
7.     server.dirty_before_bgsave = server.dirty;
   
8.     start = ustime();
   
9.     if ((childpid = fork()) == 0) {
   
10.         /* Child */
    
11.         if (server.vm_enabled) vmReopenSwapFile();
    
12.         if (server.ipfd > 0) close(server.ipfd);
    
13.         if (server.sofd > 0) close(server.sofd);
    
14.         if (rdbSave(filename) == REDIS_OK) {
    
15.             _exit(0);
    
16.         } else {
    
17.             _exit(1);
    
18.         }
    
19.     } else {
    
20.         /* Parent */
    
21.         server.stat_fork_time = ustime()-start;
    
22.         if (childpid == -1) {
    
23.             redisLog(REDIS_WARNING,"Can't save in background: fork: %s",
    
24.                 strerror(errno));
    
25.             return REDIS_ERR;
    
26.         }
    
27.         redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
    
28.         server.bgsavechildpid = childpid;
    
29.         updateDictResizePolicy();
    
30.         return REDIS_OK;
    
31.     }
    
32.     return REDIS_OK; /* unreached */
    
33. }

复制代码

jieforest

对是否已经有写rdb的子进程进行了判断，如果已经有保存快照的子进程，则返回错误。

如果启动了虚拟内存，则等待所有处理换出换入的任务线程退出，如果还有vm任务在处理就会一直循环等待。一直到所有换入换出任务都完成且所有vm线程退出。

保存当前的脏数据计数，当快照保存完后用于更新当前的脏数据计数（见函数backgroundSaveDoneHandler，rdb.c：1062）

记下当前时间，用于统计fork一个进程需要的时间

Fork一个字进程，子进程调用rdbSave进行快照保存

父进程统计fork一个子进程消耗的时间： server.stat_fork_time = ustime()-start，这个统计可以通过info命令获得。

保存子进程ID和更新增量重哈希的策略，即此时不应该再进行增量重哈希，不然大量key的改变可能导致fork的copy-on-write进行大量的写。

jieforest

到了这里我们知道，rdb的快照保存是通过函数rdbSave函数（rdb.c：394）来实现的。其实save命令也是通过调用这个函数来实现的。我们来简单看看

Db.c：323

1. void saveCommand(redisClient *c) {
   
2.     if (server.bgsavechildpid != -1) {
   
3.         addReplyError(c,"Background save already in progress");
   
4.         return;
   
5.     }
   
6.     if (rdbSave(server.dbfilename) == REDIS_OK) {
   
7.         addReply(c,shared.ok);
   
8.     } else {
   
9.         addReply(c,shared.err);
   
10.     }

复制代码

jieforest

最后我们进rdbSave函数看看

rdb.c：394

1. int rdbSave(char *filename) {
   
2.     ...
   
3.     /* Wait for I/O therads to terminate, just in case this is a
   
4.      * foreground-saving, to avoid seeking the swap file descriptor at the
   
5.      * same time. */
   
6.     if (server.vm_enabled)
   
7.         waitEmptyIOJobsQueue();
   
8. 
   
9.     snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
   
10.     fp = fopen(tmpfile,"w");
    
11.     if (!fp) {
    
12.         redisLog(REDIS_WARNING, "Failed saving the DB: %s", strerror(errno));
    
13.         return REDIS_ERR;
    
14.     }
    
15.     if (fwrite("REDIS0002",9,1,fp) == 0) goto werr;
    
16.     for (j = 0; j < server.dbnum; j++) {
    
17.         redisDb *db = server.db+j;
    
18.         dict *d = db->dict;
    
19.         if (dictSize(d) == 0) continue;
    
20.         di = dictGetSafeIterator(d);
    
21.         if (!di) {
    
22.             fclose(fp);
    
23.             return REDIS_ERR;
    
24.         }
    
25. 
    
26.         /* Write the SELECT DB opcode */
    
27.         if (rdbSaveType(fp,REDIS_SELECTDB) == -1) goto werr;
    
28.         if (rdbSaveLen(fp,j) == -1) goto werr;
    
29. 
    
30.         /* Iterate this DB writing every entry */
    
31.         while((de = dictNext(di)) != NULL) {
    
32.             sds keystr = dictGetEntryKey(de);
    
33.             robj key, *o = dictGetEntryVal(de);
    
34.             time_t expiretime;
    
35. 
    
36.             initStaticStringObject(key,keystr);
    
37.             expiretime = getExpire(db,&key);
    
38. 
    
39.             /* Save the expire time */
    
40.             if (expiretime != -1) {
    
41.                 /* If this key is already expired skip it */
    
42.                 if (expiretime < now) continue;
    
43.                 if (rdbSaveType(fp,REDIS_EXPIRETIME) == -1) goto werr;
    
44.                 if (rdbSaveTime(fp,expiretime) == -1) goto werr;
    
45.             }
    
46.             /* Save the key and associated value. This requires special
    
47.              * handling if the value is swapped out. */
    
48.             if (!server.vm_enabled || o->storage == REDIS_VM_MEMORY ||
    
49.                                       o->storage == REDIS_VM_SWAPPING) {
    
50.                 int otype = getObjectSaveType(o);
    
51. 
    
52.                 /* Save type, key, value */
    
53.                 if (rdbSaveType(fp,otype) == -1) goto werr;
    
54.                 if (rdbSaveStringObject(fp,&key) == -1) goto werr;
    
55.                 if (rdbSaveObject(fp,o) == -1) goto werr;
    
56.             } else {
    
57.                 /* REDIS_VM_SWAPPED or REDIS_VM_LOADING */
    
58.                 robj *po;
    
59.                 /* Get a preview of the object in memory */
    
60.                 po = vmPreviewObject(o);
    
61.                 /* Save type, key, value */
    
62.                 if (rdbSaveType(fp,getObjectSaveType(po)) == -1)
    
63.                     goto werr;
    
64.                 if (rdbSaveStringObject(fp,&key) == -1) goto werr;
    
65.                 if (rdbSaveObject(fp,po) == -1) goto werr;
    
66.                 /* Remove the loaded object from memory */
    
67.                 decrRefCount(po);
    
68.             }
    
69.         }
    
70.         dictReleaseIterator(di);
    
71.     }
    
72.     /* EOF opcode */
    
73.     if (rdbSaveType(fp,REDIS_EOF) == -1) goto werr;
    
74. 
    
75.     /* Make sure data will not remain on the OS's output buffers */
    
76.     fflush(fp);
    
77.     fsync(fileno(fp));
    
78.     fclose(fp);
    
79. 
    
80.     /* Use RENAME to make sure the DB file is changed atomically only
    
81.      * if the generate DB file is ok. */
    
82.     if (rename(tmpfile,filename) == -1) {
    
83.         redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno));
    
84.         unlink(tmpfile);
    
85.         return REDIS_ERR;
    
86.     }
    
87.     redisLog(REDIS_NOTICE,"DB saved on disk");
    
88.     server.dirty = 0;
    
89.     server.lastsave = time(NULL);
    
90.     return REDIS_OK;
    
91. 
    
92. werr:
    
93.     fclose(fp);
    
94.     unlink(tmpfile);
    
95.     redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
    
96.     if (di) dictReleaseIterator(di);
    
97.     return REDIS_ERR;
    
98. }

复制代码