Redis源码解析：11RDB持久化

Redis的RDB持久化的相关功能主要是在src/rdb.c中实现的。RDB文件是具有一定编码格式的数据文件，因此src/rdb.c中大部分代码都是处理数据格式的问题。

一：RDB文件格式

上图就是一个完整RDB文件的格式。

RDB文件的最开头是REDIS部分，这个部分的长度为5字节，保存着"REDIS"五个字符。通过这个字符串，程序可以在载人文件时，快速检查所载人的文件是否RDB文件。

db_version长度为4字节，它是一个字符串表示的整数，这个整数记录了RDB文件的版本号。比如，”0006”就代表RDB文件的版本为第6版。Redis3.0.5使用的是第6版，因此本文只介绍第6版RDB文件的结构。

databases部分包含着零个或任意多个数据库。也就是保存着Redis服务器中所有数据库中的键值对数据。如果Redis服务器中的所有数据库都是空的，那这个部分也为空的，长度      为0字节。根据数据库所保存键值对的数量、类型和内容不同，这个部分的长度也会有所不同。

EOF部分是一个1字节长度的常量，这个常量标志着RDB文件正文内容的结束，当载入程序遇到这个值的时候，就表明所有数据库的所有键值对都已经载人完毕了。

check_sum是一个8字节长的无符号整数，保存着一个校验和。该校验和是对RED1S，db_version，databases，EOF四个部分的内容计算得到的。服务器在载人RDB文件时，会对载入的数据重新计算校验和，然后与check_sum所记录的校验和进行对比，以此来检查RDB文件是否出错或者损坏。

下图就是一个databases部分为空的RDB文件：

1：databases部分

databases部分可以保存任意多个非空数据库。每个非空数据库都保存为SELECTDB，db_index，key_value_pairs三个部分。

SELECTDB是一个长度为1字节的常量，当载入程序读到这个值时，它知道接下来要读人的将是一个数据库索引db_index。

db_index是一个表示数据库索引号的整数值，根据索引号的大小，这个部分的长度可以编码为1字节、2字节或5字节。当读人db_index部分之后，就切换到相应的数据库上，准备将之后的key_value_pairs载入到该数据库中。

key_value_pairs部分保存了数据库中的所有键值对数据，如果键值对带有过期时间，那么过期时间也会和键值对保存在一起。根据键值对的数量、类型、内容以及是否有过期时间等条件的不同，key_value_pairs部分的长度也会有所不同。

下图展示了一个包含0号数据库和3号数据库的完整RDB文件：

2：key_value_pairs部分

key_value_pairs 部分保存了数据库中所有的键值对数据，如果键值对带有过期时间的话，那么过期时间也会被保存在内。

不带过期时间的键值对由TYPE， key和 value 三部分组成。TYPE记录了 value 的类型，代表了值对象的类型及其底层编码。长度为 1 字节，值可以是以下常量中的一个：

#define REDIS_RDB_TYPE_STRING 0
#define REDIS_RDB_TYPE_LIST   1
#define REDIS_RDB_TYPE_SET    2
#define REDIS_RDB_TYPE_ZSET   3
#define REDIS_RDB_TYPE_HASH   4
#define REDIS_RDB_TYPE_HASH_ZIPMAP    9
#define REDIS_RDB_TYPE_LIST_ZIPLIST  10
#define REDIS_RDB_TYPE_SET_INTSET    11
#define REDIS_RDB_TYPE_ZSET_ZIPLIST  12
#define REDIS_RDB_TYPE_HASH_ZIPLIST  13

key和value分别保存了键对象和值对象。因键对象总是一个字符串，根据其内容以及长度，key可以有不同的编码和长度。

根据值对象中编码和内容长度的不同，value的结构和长度也会有所不同。

带有过期时间的键值对在RDB文件中的结构如下图所示。

EXPIRETIME_MS 是长度为1字节的常量，它告知读入程序，接下来要读入的将是一个以毫秒为单位的过期时间。

ms 是一个 8 字节长的带符号整数，记录着一个以毫秒为单位的UNIX时间戳，这个时间戳就是键值对的过期时间。

剩下的TYPE，key和value三个部分与不带过期时间的键值对意义相同。

4：TYPE编码

TYPE常量记录了值对象的类型和编码，TYPE的编码规则如下：

如果值是字符串对象，则TYPE为REDIS_RDB_TYPE_STRING；

列表对象编码为REDIS_ENCODING_ZIPLIST时，TYPE为REDIS_RDB_TYPE_LIST_ZIPLIST；列表对象编码为REDIS_ENCODING_LINKEDLIST时，TYPE为REDIS_RDB_TYPE_LIST；

集合对象编码为REDIS_ENCODING_INTSET时，TYPE为REDIS_RDB_TYPE_SET_INTSET；集合对象编码为REDIS_ENCODING_HT时，TYPE为REDIS_RDB_TYPE_SET；

有序集合对象编码为REDIS_ENCODING_ZIPLIST时，TYPE为REDIS_RDB_TYPE_ZSET_ZIPLIST；有序集合对象编码为REDIS_ENCODING_SKIPLIST时，TYPE为REDIS_RDB_TYPE_ZSET；

哈希对象编码为REDIS_ENCODING_ZIPLIST时，TYPE为REDIS_RDB_TYPE_HASH_ZIPLIST；哈希对象编码为REDIS_ENCODING_HT时，TYPE为REDIS_RDB_TYPE_HASH；

5：key

key记录了键值对中的键。因键总是一个字符串，根据字符串的形式和长度不同，key也有不同的形式。

如果键字符串长度小于等于11，并且是一个整数型字符串，比如”123”, “-151541”等，则将字符串转换为整数，然后以ENCODING和integer的形式保存：

ENCODING是长度为1字节的编码，integer是具体的整数值。根据integer范围的不同，ENCODING的值也不同，规则如下：

如果integer在范围[-128,127]内，则ENCODING的二进制形式为11000000，integer长度为1字节；

如果integer在范围[-32768,32767]内，则ENCODING的二进制形式为11000001，integer长度为2字节；

如果integer在范围[-2147483648,2147483647]内，则ENCODING的二进制形式为11000010，integer长度为4字节；

如果字符串不满足上面的条件，如果Redis开启了压缩功能，并且字符串长度大于20字节，则字符串需要压缩保存，以下面的格式保存：

REDIS_RDB_ENC_LZF 是长度为1字节的常量，表明这是压缩字符串。其值的二进制形式为11000011；

compressed_len是压缩后的字符串长度；origin_len是压缩前的字符串长度；

compressed_string是压缩后的字符串。

如果未开启压缩功能，或者字符串长度小于等于20字节，则以len+string的格式保存，其中len是字符串的长度，string是字符串：

6：value

value 部分保存了一个值对象，每个值对象的类型和编码由 TYPE 记录。

a：字符串对象

TYPE 的值为 REDIS_RDB_TYPE_STRING，则value保存的是一个字符串对象。保存的格式与key的规则一样，不再赘述。

b：列表对象

TYPE值为REDIS_RDB_TYPE_LIST，则value 保存的是一个 REDIS_ENCODING_LINKEDLIST 编码的列表对象，RDB文件保存这种对象的结构如下图所示：

list_length 记录了列表的长度，也就是列表中的元素个数。接下来以 item 开头的部分代表列表的元素，因为每个列表项都是一个字符串对象，因此保存的规则与key相同。

如果TYPE值为REDIS_RDB_TYPE_LIST_ZIPLIST，则value 保存的是一个 REDIS_ENCODING_ZIPLIST编码的列表对象，这种编码的列表对象底层是连续的内存块，RDB文件保存这种类型时，直接将其当做字符串对象处理，因此保存的规则与key相同。

c：集合对象

TYPE 的值为REDIS_RDB_TYPE_SET，则value 保存的是一个 REDIS_ENCODING_HT 编码的集合对象，RDB文件保存这种对象的结构如下图所示：

set_size记录了集合中的元素个数。接下来以 elem开头的部分代表集合的元素，因为每个集合元素都是一个字符串对象，因此保存的规则与key相同。

如果TYPE值为REDIS_RDB_TYPE_SET_INTSET，则value 保存的是一个 REDIS_ENCODING_INTSET编码的集合对象，这种编码的集合对象底层是连续的内存块，RDB文件保存这种类型时，直接将其当做字符串对象处理，因此保存的规则与key相同。

d：有序集合对象

TYPE 的值为REDIS_RDB_TYPE_ZSET，则 value 保存的是一个 REDIS_ENCODING_SKIPLIST 编码的有序集合对象，RDB文件保存这种对象的结构如下图所示：

sorted_set_size 记录了有序集合的大小，也就是这个有序集合保存了多少元素。接下来是每个元素的成员和分值部分，成员是一个字符串对象，因此保存的规则与key相同。分值是一个 double 类型的浮点数，保存到RDB文件中时，会先将分值转换成字符串对象，因此保存的规则与key相同。

如果TYPE值为REDIS_RDB_TYPE_ZSET_ZIPLIST，则value 保存的是一个 REDIS_ENCODING_ZIPLIST编码的有序集合对象，这种编码的有序集合对象底层是连续的内存块，RDB文件保存这种类型时，直接将其当做字符串对象处理，因此保存的规则与key相同。

e：哈希对象

TYPE 的值为 REDIS_RDB_TYPE_HASH，则value 保存的就是一个 REDIS_ENCODING_HT 编码的哈希对象，RDB文件保存这种对象的结构如下图所示：

hash_size 记录了哈希表的大小，也就是这个哈希表保存了多少键值对。剩下的就是键值对了，键值对的键和值都是字符串对象，因此保存的规则与key相同。

如果TYPE值为REDIS_RDB_TYPE_HASH_ZIPLIST，则value 保存的是一个 REDIS_ENCODING_ZIPLIST编码的哈希对象，这种编码的哈希对象底层是连续的内存块，RDB文件保存这种类型时，直接将其当做字符串对象处理，因此保存的规则与key相同。

二：代码实现

1：保存数据库的实现

保存数据库到RDB文件的操作，是由函数rdbSaveRio实现的，它的代码如下：

int rdbSaveRio(rio *rdb, int *error) {
    dictIterator *di = NULL;
    dictEntry *de;
    char magic[10];
    int j;
    long long now = mstime();
    uint64_t cksum;

    if (server.rdb_checksum)
        rdb->update_cksum = rioGenericUpdateChecksum;
    snprintf(magic,sizeof(magic),"REDIS%04d",REDIS_RDB_VERSION);
    if (rdbWriteRaw(rdb,magic,9) == -1) goto werr;

    for (j = 0; j < server.dbnum; j++) {
        redisDb *db = server.db+j;
        dict *d = db->dict;
        if (dictSize(d) == 0) continue;
        di = dictGetSafeIterator(d);
        if (!di) return REDIS_ERR;

        /* Write the SELECT DB opcode */
        if (rdbSaveType(rdb,REDIS_RDB_OPCODE_SELECTDB) == -1) goto werr;
        if (rdbSaveLen(rdb,j) == -1) goto werr;

        /* Iterate this DB writing every entry */
        while((de = dictNext(di)) != NULL) {
            sds keystr = dictGetKey(de);
            robj key, *o = dictGetVal(de);
            long long expire;

            initStaticStringObject(key,keystr);
            expire = getExpire(db,&key);
            if (rdbSaveKeyValuePair(rdb,&key,o,expire,now) == -1) goto werr;
        }
        dictReleaseIterator(di);
    }
    di = NULL; /* So that we don't release it again on error. */

    /* EOF opcode */
    if (rdbSaveType(rdb,REDIS_RDB_OPCODE_EOF) == -1) goto werr;

    /* CRC64 checksum. It will be zero if checksum computation is disabled, the
     * loading code skips the check in this case. */
    cksum = rdb->cksum;
    memrev64ifbe(&cksum);
    if (rioWrite(rdb,&cksum,8) == 0) goto werr;
    return REDIS_OK;

werr:
    if (error) *error = errno;
    if (di) dictReleaseIterator(di);
    return REDIS_ERR;
}

首先，如果配置文件中的rdbchecksum选项为"yes"的话，则server.rdb_checksum为1，因此设置rdb->update_cksum为rioGenericUpdateChecksum；表明使用该函数作为计算校验码的函数；

然后，构造RDB文件的文件头"REDIS0006"，其中"0006"是RDB文件的版本，目前是6，构造完文件头之后，调用rdbWriteRaw写入到rdb中；

然后，针对Redis中的每一个数据库，只要该数据库不为空，就创建一个轮训数据库字典的安全迭代器di；

然后，首先将常量REDIS_RDB_OPCODE_SELECTDB写入rdb中，再将当前的数据库索引j写入到rdb中；

然后，利用迭代器di，轮训数据库字典中每一个字典项，取出其中的键keystr，值对象o以及键的超时时间expire（如果有的话），因为数据库中保存键时是直接保存的原始字符串，因此需要将keystr转换成字符串对象key，然后调用rdbSaveKeyValuePair将key、o以及expire写入到rdb中；

处理完所有的键值对后，将常量REDIS_RDB_OPCODE_EOF写入rdb中；

最后，因每次向rdb写入数据时，同时会计算当前内容的校验码，并将其记录到rdb->cksum中，因此，将当前所有数据的校验码cksum，转换成小端模式后，写入到rdb中；

2：SAVE命令的实现

执行SAVE命令时，会阻塞当前Redis服务器，此时客户端无法进行操作，该命令主要是通过saveCommand实现的，而该函数又主要是调用rdbSave实现：

void saveCommand(redisClient *c) {
    if (server.rdb_child_pid != -1) {
        addReplyError(c,"Background save already in progress");
        return;
    }
    if (rdbSave(server.rdb_filename) == REDIS_OK) {
        addReply(c,shared.ok);
    } else {
        addReply(c,shared.err);
    }
}

在函数saveCommand中，如果server.rdb_child_pid不是-1，则说明已经有子进程开始进行SAVE过程了，则直接反馈"Background save already in progress"给客户端；

然后调用rdbSave，将数据记录到server.rdb_filename中，成功则反馈shared.ok，失败反馈shared.err。

函数rdbSave的代码如下：

int rdbSave(char *filename) {
    char tmpfile[256];
    FILE *fp;
    rio rdb;
    int error;

    snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
    fp = fopen(tmpfile,"w");
    if (!fp) {
        redisLog(REDIS_WARNING, "Failed opening .rdb for saving: %s",
            strerror(errno));
        return REDIS_ERR;
    }

    rioInitWithFile(&rdb,fp);
    if (rdbSaveRio(&rdb,&error) == REDIS_ERR) {
        errno = error;
        goto werr;
    }

    /* Make sure data will not remain on the OS's output buffers */
    if (fflush(fp) == EOF) goto werr;
    if (fsync(fileno(fp)) == -1) goto werr;
    if (fclose(fp) == EOF) goto werr;

    /* Use RENAME to make sure the DB file is changed atomically only
     * if the generate DB file is ok. */
    if (rename(tmpfile,filename) == -1) {
        redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno));
        unlink(tmpfile);
        return REDIS_ERR;
    }
    redisLog(REDIS_NOTICE,"DB saved on disk");
    server.dirty = 0;
    server.lastsave = time(NULL);
    server.lastbgsave_status = REDIS_OK;
    return REDIS_OK;

werr:
    redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
    fclose(fp);
    unlink(tmpfile);
    return REDIS_ERR;
}

在该函数中，首先在当前目录创建临时文件temp-<pid>.rdb，其中<pid>就是当前进程的PID。然后使用该临时文件的文件指针fp初始化rio结构rdb，该结构是Redis中用于IO操作的数据结构，主要是封装了read和write操作。

然后调用rdbSaveRio，将Redis所有数据写入rdb中，也就是写入上面的临时文件中；之后调用fflush，fsync和fclose，保证数据已经写入到硬盘上，并且关闭临时文件；

然后将该临时文件改名为filename；然后更新server中RDB相关的属性：

server.dirty = 0;
server.lastsave = time(NULL);
server.lastbgsave_status = REDIS_OK;	

server.dirty计数器记录距离上一次成功执行SAYE命令或者BGSAYE命令之后，服务器  对数据库状态（所有数据库）进行了多少次修改（包括写人、删除、更新等操作)；

server.lastsave属性是记录了服务器上一次成功执行SAYE命令或BGSAYE命令的时间。

配置文件中，设置的Redis服务器自动快照的条件，就是根据这两个值进行判断的。

3：BGSAVE命令的实现

BGSAVE命令可以在后台异步地进行快照操作，快照的同时服务器还可以继续响应来自客户端的请求。该命令主要是通过bgsaveCommand实现的，而该函数又主要是调用rdbSaveBackground实现：

void bgsaveCommand(redisClient *c) {
    if (server.rdb_child_pid != -1) {
        addReplyError(c,"Background save already in progress");
    } else if (server.aof_child_pid != -1) {
        addReplyError(c,"Can't BGSAVE while AOF log rewriting is in progress");
    } else if (rdbSaveBackground(server.rdb_filename) == REDIS_OK) {
        addReplyStatus(c,"Background saving started");
    } else {
        addReply(c,shared.err);
    }
}

在函数bgsaveCommand中，如果server.rdb_child_pid不是-1，则说明已经有进程开始进行SAVE过程了，则直接反馈"Backgroundsave already in progress"给客户端；

如果server.aof_child_pid不是-1，则说明已经有进程开始进行重写AOF文件的过程了，为了避免性能问题，则直接反馈"Can't BGSAVE while AOF log rewriting is in progress"给客户端；

然后调用rdbSaveBackground，将数据记录到server.rdb_filename中，成功则反馈shared.ok，失败反馈shared.err；

rdbSaveBackground的代码如下：

int rdbSaveBackground(char *filename) {
    pid_t childpid;
    long long start;

    if (server.rdb_child_pid != -1) return REDIS_ERR;

    server.dirty_before_bgsave = server.dirty;
    server.lastbgsave_try = time(NULL);

    start = ustime();
    if ((childpid = fork()) == 0) {
        int retval;

        /* Child */
        closeListeningSockets(0);
        redisSetProcTitle("redis-rdb-bgsave");
        retval = rdbSave(filename);
        if (retval == REDIS_OK) {
            size_t private_dirty = zmalloc_get_private_dirty();

            if (private_dirty) {
                redisLog(REDIS_NOTICE,
                    "RDB: %zu MB of memory used by copy-on-write",
                    private_dirty/(1024*1024));
            }
        }
        exitFromChild((retval == REDIS_OK) ? 0 : 1);
    } else {
        /* Parent */
        server.stat_fork_time = ustime()-start;
        server.stat_fork_rate = (double) zmalloc_used_memory() * 1000000 / server.stat_fork_time / (1024*1024*1024); /* GB per second. */
        latencyAddSampleIfNeeded("fork",server.stat_fork_time/1000);
        if (childpid == -1) {
            server.lastbgsave_status = REDIS_ERR;
            redisLog(REDIS_WARNING,"Can't save in background: fork: %s",
                strerror(errno));
            return REDIS_ERR;
        }
        redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
        server.rdb_save_time_start = time(NULL);
        server.rdb_child_pid = childpid;
        server.rdb_child_type = REDIS_RDB_CHILD_TYPE_DISK;
        updateDictResizePolicy();
        return REDIS_OK;
    }
    return REDIS_OK; /* unreached */
}

在该函数中，首先如果server.rdb_child_pid不为-1，说明当前已经在后台保存Redis数据了，这种情况直接返回REDIS_ERR；

然后保存当前有关RDB的状态：

server.dirty_before_bgsave = server.dirty;
server.lastbgsave_try = time(NULL);

server.dirty_before_bgsave用于执行完后，恢复server.dirty；server.lastbgsave_try用于记录BGSAVE上一次的执行时间，以便决定何时自动执行下一次BGSAVE操作；

调用fork创建子进程，在子进程中，首先调用closeListeningSockets，关闭不必要的描述符；然后调用redisSetProcTitle然后调用rdbSave保存数据到filename中。

注意，调用fork时，子进程的内存与父进程（Redis服务器）是一模一样的，因此子进程保存的数据库也就是fork时刻的状态。而此时父进程继续接受来自客户端的命令，这就会产生新的数据，新的数据并未追加到RDB中。AOF持久化可以做到这点。因此AOF持久化丢失的数据会更少。

如果rdbSave执行成功，则调用zmalloc_get_private_dirty，从文件/proc/self/smaps中获取当前进程的Private_Dirty值，也就是用于写时复制的内存，将其记录到日志中；然后子进程退出。

调用fork后， 在父进程中，首先计算执行fork系统调用的执行时间，记录到server.stat_fork_time中；然后根据当前使用的内存总量，得到server.stat_fork_rate（单位为GB/s），然后调用latencyAddSampleIfNeeded，根据fork执行时间是否超过阈值，记录到server.latency_events中；以上信息主要用于Redis的延迟分析。

如果fork调用失败，则记录错误信息到日志，并且返回REDIS_ERR；    否则，更新以下信息：

server.rdb_save_time_start = time(NULL);
server.rdb_child_pid = childpid;
server.rdb_child_type = REDIS_RDB_CHILD_TYPE_DISK;

然后调用updateDictResizePolicy，禁止Redis中的字典数据结构rehash（并非完全禁止，字典哈希表负载率大于500%时，依然进行rehash）；最后返回REDIS_OK。

4：加载RDB文件

当Redis服务器启动时，会查找是否存在RDB文件，如果存在，则将RDB文件加载到Redis中。加载RDB文件的操作主要是通过rdbLoad实现的，代码如下：

int rdbLoad(char *filename) {
    uint32_t dbid;
    int type, rdbver;
    redisDb *db = server.db+0;
    char buf[1024];
    long long expiretime, now = mstime();
    FILE *fp;
    rio rdb;

    if ((fp = fopen(filename,"r")) == NULL) return REDIS_ERR;

    rioInitWithFile(&rdb,fp);
    rdb.update_cksum = rdbLoadProgressCallback;
    rdb.max_processing_chunk = server.loading_process_events_interval_bytes;
    if (rioRead(&rdb,buf,9) == 0) goto eoferr;
    buf[9] = '\0';
    if (memcmp(buf,"REDIS",5) != 0) {
        fclose(fp);
        redisLog(REDIS_WARNING,"Wrong signature trying to load DB from file");
        errno = EINVAL;
        return REDIS_ERR;
    }
    rdbver = atoi(buf+5);
    if (rdbver < 1 || rdbver > REDIS_RDB_VERSION) {
        fclose(fp);
        redisLog(REDIS_WARNING,"Can't handle RDB format version %d",rdbver);
        errno = EINVAL;
        return REDIS_ERR;
    }

    startLoading(fp);
    while(1) {
        robj *key, *val;
        expiretime = -1;

        /* Read type. */
        if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
        if (type == REDIS_RDB_OPCODE_EXPIRETIME) {
            if ((expiretime = rdbLoadTime(&rdb)) == -1) goto eoferr;
            /* We read the time so we need to read the object type again. */
            if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
            /* the EXPIRETIME opcode specifies time in seconds, so convert
             * into milliseconds. */
            expiretime *= 1000;
        } else if (type == REDIS_RDB_OPCODE_EXPIRETIME_MS) {
            /* Milliseconds precision expire times introduced with RDB
             * version 3. */
            if ((expiretime = rdbLoadMillisecondTime(&rdb)) == -1) goto eoferr;
            /* We read the time so we need to read the object type again. */
            if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
        }

        if (type == REDIS_RDB_OPCODE_EOF)
            break;

        /* Handle SELECT DB opcode as a special case */
        if (type == REDIS_RDB_OPCODE_SELECTDB) {
            if ((dbid = rdbLoadLen(&rdb,NULL)) == REDIS_RDB_LENERR)
                goto eoferr;
            if (dbid >= (unsigned)server.dbnum) {
                redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server.dbnum);
                exit(1);
            }
            db = server.db+dbid;
            continue;
        }
        /* Read key */
        if ((key = rdbLoadStringObject(&rdb)) == NULL) goto eoferr;
        /* Read value */
        if ((val = rdbLoadObject(type,&rdb)) == NULL) goto eoferr;
        /* Check if the key already expired. This function is used when loading
         * an RDB file from disk, either at startup, or when an RDB was
         * received from the master. In the latter case, the master is
         * responsible for key expiry. If we would expire keys here, the
         * snapshot taken by the master may not be reflected on the slave. */
        if (server.masterhost == NULL && expiretime != -1 && expiretime < now) {
            decrRefCount(key);
            decrRefCount(val);
            continue;
        }
        /* Add the new object in the hash table */
        dbAdd(db,key,val);

        /* Set the expire time if needed */
        if (expiretime != -1) setExpire(db,key,expiretime);

        decrRefCount(key);
    }
    /* Verify the checksum if RDB version is >= 5 */
    if (rdbver >= 5 && server.rdb_checksum) {
        uint64_t cksum, expected = rdb.cksum;

        if (rioRead(&rdb,&cksum,8) == 0) goto eoferr;
        memrev64ifbe(&cksum);
        if (cksum == 0) {
            redisLog(REDIS_WARNING,"RDB file was saved with checksum disabled: no check performed.");
        } else if (cksum != expected) {
            redisLog(REDIS_WARNING,"Wrong RDB checksum. Aborting now.");
            exit(1);
        }
    }

    fclose(fp);
    stopLoading();
    return REDIS_OK;

eoferr: /* unexpected end of file is handled here with a fatal exit */
    redisLog(REDIS_WARNING,"Short read or OOM loading DB. Unrecoverable error, aborting now.");
    exit(1);
    return REDIS_ERR; /* Just to avoid warning */
}

该函数中，首先打开filename，用该文件初始化rdb；然后置rdb.update_cksum为rdbLoadProgressCallback，该函数用于每次读取文件中数据时计算其校验码，以及处理事件等；然后置rdb.max_processing_chunk为server.loading_process_events_interval_bytes，该值表示是一次read操作读取的最大字节数；

开始从rdb中读取9个字节，判断前5个字节是否是"REDIS"，不是直接报错退出；将后4个字节的版本号转换成整数rdbver，如果rdbver小于1，或者大于6，则报错退出；

然后调用startLoading标记开始加载过程，该函数记录load开始的时间，要load的总字节数，以及置server.loading为1表明开始load等；

接下来，开始从rdb中读取数据。首先调用rdbLoadType读取1字节的type，如果type值为REDIS_RDB_OPCODE_EXPIRETIME，则接着调用rdbLoadTime读取键的超时时间(秒)，并将其转换为毫秒单位；如果type值为REDIS_RDB_OPCODE_EXPIRETIME_MS，则调用rdbLoadMillisecondTime读取键的超时时间(毫秒)，然后接着读1字节的type；

如果type值为REDIS_RDB_OPCODE_EOF，则直接退出循环；

如果type值为REDIS_RDB_OPCODE_SELECTDB，则调用rdbLoadLen得到数据库索引，然后判断索引是否有效，无效直接报错退出；索引有效，则切换到相应的数据库，然后接着读取；

调用rdbLoadStringObject从rdb中读取出键对象key，然后调用rdbLoadObject从rdb中读取值对象val；如果当前是主节点，则判断该键是否超时，若是则直接抛弃；如果是从节点，则不判断键是否超时；

调用dbAdd将key和val添加到数据库的字典中；如果键设置了超时时间，则调用setExpire设置该键的超时时间；

如果RDB版本号rdbver大于等于5并且server.rdb_checksum为真，则需要比对校验码，首先从rdb中读取校验码，然后跟当前计算的校验码expected比较，不匹配则报错退出；

最后，关闭filename，调用stopLoading置server.loading为0表示load过程结束，然后返回REDIS_OK；如果以上过程有错误发生，则记录错误之后，程序直接退出。

其他相关RDB的代码，参考：

https://github.com/gqtc/redis-3.0.5/blob/master/redis-3.0.5/src/rdb.c

http://redis.io/topics/latency.