一.概述
AOF持久化不同于RDB的存储整个数据结构，AOF是通过记录redis执行的服务器所执行的写命令来记录数据库状态的。
二.AOF持久化的实现
AOF持久化操作分为三个步骤，分别是：命令追加，文件写入，文件同步。具体如下：redis在每次执行写命令时（比如增删改），都会将该条命令加入到服务器结构redisServer的AOF缓冲区中，redis向muduo一样是基于eventloop（事件循环）的，在每次循环中，redis都会根据设置的策略决定是否要将AOF缓冲中的数据写入AOF文件，以及是否要进行等待文件同步（fsync,参博文《文件访问》）。
Redis事件循环中的serverCron函数默认会每隔100ms执行一次，其中会调用flushAppendOnlyFile函数，该函数会判断是否将aof_buf内的数据写入到文件以及是否进行文件同步，且当同步策略为everysec时文件的同步操作由后台线程完成，具体代码如下所示：
1.redis任务线程代码：
bio.c文件中定义了redis工作线程池，每种任务选项都对应了一个线程（如：AOF的文件同步操作便对应着一个线程），但工作线程只执行两种操作：关闭文件和AOF文件同步。redis的线程实现如下：
static pthread_t bio_threads[REDIS_BIO_NUM_OPS]; // 记录了线程标识符
static pthread_mutex_t bio_mutex[REDIS_BIO_NUM_OPS]; // 记录了每线程锁，用于互斥访问任务队列及用于条件变量
static pthread_cond_t bio_condvar[REDIS_BIO_NUM_OPS]; // 每线程的条件变量
static list *bio_jobs[REDIS_BIO_NUM_OPS]; // 每任务类型任务队列，也是每线程任务队列
static unsigned long long bio_pending[REDIS_BIO_NUM_OPS]; //记录了每个线程上挂起的任务数
// 该结构表示着一个任务，该结构仅在本文件中使用
struct bio_job {
time_t time; // 任务创建的时间
void *arg1, *arg2, *arg3; // 用于该任务的参数，若参数数超过3个，则需要通过结构体传递
};
// 初始化线程池
// 每种任务选项都有一个对应的线程
void bioInit(void) {
pthread_attr_t attr;
pthread_t thread;
size_t stacksize;
int j;
// 初始化每操作类型的锁，条件变量，任务队列及挂起作业数，#define REDIS_BIO_NUM_OPS 2
for (j = 0; j < REDIS_BIO_NUM_OPS; j++) {
pthread_mutex_init(&bio_mutex[j],NULL);
pthread_cond_init(&bio_condvar[j],NULL);
bio_jobs[j] = listCreate();
bio_pending[j] = 0;
}
// 设置线程属性（在有些系统中的默认栈大小可能过小）
// - 首先使用pthread_attr_init初始化一个pthread_attr_t结构attr
// - 使用函数pthread_attr_setstacksize设置attr中的栈属性（栈大小）
// - 最后使用属性attr调用函数pthread_create创建线程
pthread_attr_init(&attr);
pthread_attr_getstacksize(&attr,&stacksize); // 获取当前的栈大小属性
if (!stacksize) stacksize = 1;
while (stacksize < REDIS_THREAD_STACK_SIZE) stacksize *= 2; // 扩展线程栈大小（但不超过4G）
pthread_attr_setstacksize(&attr, stacksize);
for (j = 0; j < REDIS_BIO_NUM_OPS; j++) {
void *arg = (void*)(unsigned long) j;
// 创建线程，线程入口函数为bioProcessBackgroundJobs
if (pthread_create(&thread,&attr,bioProcessBackgroundJobs,arg) != 0) {
redisLog(REDIS_WARNING,"Fatal: Can't initialize Background Jobs.");
exit(1);
}
bio_threads[j] = thread; // 将线程标识符记录在bio_threads中
}
}
// 创建任务，并添加至任务队列
// type : 任务类型
// arg1,arg2,arg3 ： 本任务需要使用的参数
void bioCreateBackgroundJob(int type, void *arg1, void *arg2, void *arg3) {
struct bio_job *job = zmalloc(sizeof(*job));
// 设置时间及参数
job->time = time(NULL);
job->arg1 = arg1;
job->arg2 = arg2;
job->arg3 = arg3;
// 加锁后将该任务放至type类型操作的任务队列末尾
// 并调用pthread_cond_signal函数唤醒阻塞在信号量上的线程
pthread_mutex_lock(&bio_mutex[type]);
listAddNodeTail(bio_jobs[type],job);
bio_pending[type]++;
pthread_cond_signal(&bio_condvar[type]);
pthread_mutex_unlock(&bio_mutex[type]);
}
// 返回type类型任务队列中挂起任务的个数
unsigned long long bioPendingJobsOfType(int type) {
unsigned long long val;
pthread_mutex_lock(&bio_mutex[type]);
val = bio_pending[type];
pthread_mutex_unlock(&bio_mutex[type]);
return val;
}
// 取消所有任务线程
void bioKillThreads(void) {
int err, j;
for (j = 0; j < REDIS_BIO_NUM_OPS; j++) {
if (pthread_cancel(bio_threads[j]) == 0) {
if ((err = pthread_join(bio_threads[j],NULL)) != 0) {
redisLog(REDIS_WARNING,
"Bio thread for job type #%d can be joined: %s",
j, strerror(err));
} else {
redisLog(REDIS_WARNING,
"Bio thread for job type #%d terminated",j);
}
}
}
}
// 线程的入口函数
void *bioProcessBackgroundJobs(void *arg) {
struct bio_job *job;
unsigned long type = (unsigned long) arg;
sigset_t sigset;
// 线程的取消选项未包含于pthread_attr_t结构中，而是使用特定的函数设置（参APUE p362）
// pthread_setcancelstate函数设置线程是否可被取消，PTHREAD_CANCEL_ENABLE可，PTHREAD_CANCEL_DISABLE不可
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
// 设置取消类型，默认为推迟取消（PTHREADCANCEL_DEFERRED）,即遇到取消点时才会取消线程
// redis将取消类型设置为异步取消（PTHREAD_CANCEL_ASYNCHRONOUS）,即线程可以在任意时间被取消
// 参APUE p364
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
pthread_mutex_lock(&bio_mutex[type]);
// 阻塞本线程接受SIGALRM信号，这样可以保证只有主线程可以收到看门狗程序的信号
sigemptyset(&sigset); //清空sigset
sigaddset(&sigset, SIGALRM); // 设置SIGALRM信号在sigset中对应的位
if (pthread_sigmask(SIG_BLOCK, &sigset, NULL)) // 设置该线程的信号屏蔽字
redisLog(REDIS_WARNING,
"Warning: can't mask SIGALRM in bio.c thread: %s", strerror(errno));
while(1) {
listNode *ln;
// 若该类型操作的任务队列为空，则将该线程阻塞在该条件变量的阻塞队列上
// pthread_cond_wait函数会解锁bio_mutex，当被唤醒时再次加锁
if (listLength(bio_jobs[type]) == 0) {
pthread_cond_wait(&bio_condvar[type],&bio_mutex[type]);
continue;
}
// 取出任务队列中的首个工作任务
ln = listFirst(bio_jobs[type]);
job = ln->value;
pthread_mutex_unlock(&bio_mutex[type]);
// redis任务线程只做两种工作：关闭文件和文件同步（AOF持久化时要进行文件同步）
if (type == REDIS_BIO_CLOSE_FILE) {
close((long)job->arg1); // 关闭文件
} else if (type == REDIS_BIO_AOF_FSYNC) {
aof_fsync((long)job->arg1); // 进行文件同步操作
} else {
redisPanic("Wrong job type in bioProcessBackgroundJobs().");
}
zfree(job);
// 再次加锁，因为下次循环调用条件变量的函数pthread_cond_wait需要上锁
pthread_mutex_lock(&bio_mutex[type]);
listDelNode(bio_jobs[type],ln);
bio_pending[type]--;
}
}在了解了redis任务线程后，接下来说明flushAppendOnlyFile如何进行AOF持久化操作，其代码如下所示：
#define AOF_WRITE_LOG_ERROR_RATE 30 /* Seconds between errors logging. */
// 将aof缓存中的数据写入aof文件，并依据选择的同步策略进行文件同步
// 当force为1时，将忽略AOF同步
void flushAppendOnlyFile(int force) {
ssize_t nwritten;
int sync_in_progress = 0;
mstime_t latency;
// 若aof_buf中无命令，则无需进行持久化操作
if (sdslen(server.aof_buf) == 0) return;
// server.aof_fsync选项设置了同步文件的策略
// AOF_FSYNC_EVERYSEC ：若距上次同步AOF持久化的时间超过2s，则AOF文件进行同步，且该同步操作由一个线程执行
if (server.aof_fsync == AOF_FSYNC_EVERYSEC)
sync_in_progress = bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC) != 0; // 是否已存在AOF同步任务
// 若同步策略是AOF_FSYNC_EVERYSEC，且未强制忽略同步操作
if (server.aof_fsync == AOF_FSYNC_EVERYSEC && !force) {
// 若当前已存在同步任务，且距前一次进行成功写入AOF文件小于2s，则此次循环不进行后续写入操作，以等待同步操作完成
if (sync_in_progress) {
if (server.aof_flush_postponed_start == 0) {
// server.aof_flush_postponed_start记录了前一次延期（拒绝）AOF同步的时间
server.aof_flush_postponed_start = server.unixtime;
return;
} else if (server.unixtime - server.aof_flush_postponed_start < 2) {
// server.unixtime 保存了精确到秒的时间，以免每次都要进行系统调用
return;
}
// 进行EVERYSEC同步的次数
server.aof_delayed_fsync++;
redisLog(REDIS_NOTICE,"Asynchronous AOF fsync is taking too long (disk is busy?). Writing the AOF buffer without waiting for fsync to complete, this may slow down Redis.");
}
}
// 将aof_buf写入aof文件，并计算写入时间
latencyStartMonitor(latency);
nwritten = write(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));
latencyEndMonitor(latency);
// 根据执行的事件不同，当此次写入aof文件超过最大时限时,
// 会更新服务器用于超时事件记录的字典server.latency_events
if (sync_in_progress) {
// 若任务线程中还存在aof同步任务，则此次超时事件为aof-write-pending-fsync
latencyAddSampleIfNeeded("aof-write-pending-fsync",latency);
} else if (server.aof_child_pid != -1 || server.rdb_child_pid != -1) {
// 若正在进行AOF重写或BGSAVE，那么超时事件为aof-write-active-child
latencyAddSampleIfNeeded("aof-write-active-child",latency);
} else {
// 若只进行了aof写入文件，那么超时事件为aof-write-alone
latencyAddSampleIfNeeded("aof-write-alone",latency);
}
// 更新超时事件aof-write
latencyAddSampleIfNeeded("aof-write",latency);
// 完成了写AOF文件，因此将aof_flush_postponed_start（前一次同步时间）清0
server.aof_flush_postponed_start = 0;
// 若写入aof文件的长度少于aof_buf，则说明写入异常
if (nwritten != (signed)sdslen(server.aof_buf)) {
static time_t last_write_error_log = 0;
int can_log = 0;
// 若此次写入异常事件距上次异常的时间间隔大于30s，则更新异常时间，并置位记录日志标志can_log为1
if ((server.unixtime - last_write_error_log) > AOF_WRITE_LOG_ERROR_RATE) {
can_log = 1;
last_write_error_log = server.unixtime;
}
// 记录aof写入异常和错误码到日志。
if (nwritten == -1) {
if (can_log) {
// 记录未写入错误
redisLog(REDIS_WARNING,"Error writing to the AOF file: %s",
strerror(errno));
server.aof_last_write_errno = errno;
}
} else {
if (can_log) {
// 记录未完全写入异常
redisLog(REDIS_WARNING,"Short write while writing to "
"the AOF file: (nwritten=%lld, "
"expected=%lld)",
(long long)nwritten,
(long long)sdslen(server.aof_buf));
}
// 使用文件截断函数删除此次添加的不完整数据
if (ftruncate(server.aof_fd, server.aof_current_size) == -1) {
if (can_log) {
redisLog(REDIS_WARNING, "Could not remove short write "
"from the append-only file. Redis may refuse "
"to load the AOF the next time it starts. "
"ftruncate: %s", strerror(errno));
}
} else {
// 截断成功则nwritten = -1
nwritten = -1;
}
server.aof_last_write_errno = ENOSPC;
}
/* Handle the AOF write error. */
if (server.aof_fsync == AOF_FSYNC_ALWAYS) {
// 若redis的文件同步方式为每次写入都需同步，则记录日志并结束redis进程
redisLog(REDIS_WARNING,"Can't recover from AOF write error when the AOF fsync policy is 'always'. Exiting...");
exit(1);
} else {
server.aof_last_write_status = REDIS_ERR;
if (nwritten > 0) {
// 截断不成功则需要更新aof文件大小的记录，及删除aof_buf中已写入的部分
server.aof_current_size += nwritten;
sdsrange(server.aof_buf,nwritten,-1);
}
return; /* We'll try again on the next call... */
}
} else {
// 写入成功
if (server.aof_last_write_status == REDIS_ERR) {
// 若前一次出现了写入异常，而此次回复了，则进行日志记录
redisLog(REDIS_WARNING,
"AOF write error looks solved, Redis can write again.");
server.aof_last_write_status = REDIS_OK;
}
}
// 运行到此处说明aof写入正常
server.aof_current_size += nwritten;
// 若aof_buf缓冲的总大小小于4000字节，则只是清空aof_buf
// 否则说明aof_buf缓冲过大，则释放aof_buf缓存，重新分配一个空的缓存空间
if ((sdslen(server.aof_buf)+sdsavail(server.aof_buf)) < 4000) {
sdsclear(server.aof_buf);
} else {
sdsfree(server.aof_buf);
server.aof_buf = sdsempty();
}
/* Don't fsync if no-appendfsync-on-rewrite is set to yes and there are
* children doing I/O in the background. */
/*如果 no-appendfsync-on-rewrite 选项为开启状态，
* 并且有 BGSAVE 或者 BGREWRITEAOF 正在进行的话，
* 那么不执行 fsync
*/
if (server.aof_no_fsync_on_rewrite &&
(server.aof_child_pid != -1 || server.rdb_child_pid != -1))
return;
// 若同步策略为AOF_FSYNC_ALWAYS则在服务器主线程进行同步
// 若同步策略为AOF_FSYNC_EVERYSEC则由一个线程专门负责
if (server.aof_fsync == AOF_FSYNC_ALWAYS) {
latencyStartMonitor(latency);
aof_fsync(server.aof_fd); /* Let's try to get this data on the disk */
latencyEndMonitor(latency);
latencyAddSampleIfNeeded("aof-fsync-always",latency);
server.aof_last_fsync = server.unixtime;
} else if ((server.aof_fsync == AOF_FSYNC_EVERYSEC &&
server.unixtime > server.aof_last_fsync)) {
if (!sync_in_progress) aof_background_fsync(server.aof_fd);
server.aof_last_fsync = server.unixtime;
}
}
3.AOF重写
AOF重写的总体示意图如下：
在定期执行的serverCron函数中将会判断aof文件是否需要重写，当以下两个条件同时满足时便会进行aof重写：1.aof文件大小超过了最小重写阈值。2.与上次重写之后的aof文件大小相比若增长率超过了增长阈值。其判断代码如下所述：
void serverCron()
{
...
// server.aof_rewrite_base_size记录了上一次重写之后的aof文件大小
// server.aof_rewrite_perc记录了aof文件的增长率阈值
// 若aof文件大小超过了最小aof重写阈值,并超过了增长阈值，则进行aof重写
if (server.rdb_child_pid == -1 &&
server.aof_child_pid == -1 &&
server.aof_rewrite_perc &&
server.aof_current_size > server.aof_rewrite_min_size)
{
long long base = server.aof_rewrite_base_size ? server.aof_rewrite_base_size : 1;
// 计算与上一次重写后aof文件增长率
long long growth = (server.aof_current_size*100/base) - 100;
if (growth >= server.aof_rewrite_perc) { // 判断增长率是否超过了aof文件增长阈值
redisLog(REDIS_NOTICE,"Starting automatic rewriting of AOF on %lld%% growth",growth);
// 执行aof重写
rewriteAppendOnlyFileBackground();
}
}
...
}
在rewriteAppendOnlyFileBackgroung()函数中首先会创建3个管道用于服务器进程与aof重写子进程间的通信，关于管道的介绍可参博文《进程间通信（IPC）》。其创建函数如下所示：
// 服务器端的管道可读回调函数
void aofChildPipeReadable(aeEventLoop *el, int fd, void *privdata, int mask) {
char byte;
REDIS_NOTUSED(el);
REDIS_NOTUSED(privdata);
REDIS_NOTUSED(mask);
// 读取数据，并验证其是否为'!'字符
// 若是说明正确接收到aof持久化进程发送来的停止发送aof差异数据请求
if (read(fd,&byte,1) == 1 && byte == '!') {
redisLog(REDIS_NOTICE,"AOF rewrite child asks to stop sending diffs.");
server.aof_stop_sending_diff = 1;
if (write(server.aof_pipe_write_ack_to_child,"!",1) != 1) {
/* If we can't send the ack, inform the user, but don't try again
* since in the other side the children will use a timeout if the
* kernel can't buffer our write, or, the children was
* terminated. */
redisLog(REDIS_WARNING,"Can't send ACK to AOF child: %s",
strerror(errno));
}
}
aeDeleteFileEvent(server.el,server.aof_pipe_read_ack_from_child,AE_READABLE);
}
// 为aof文件重写创建用于父子进程间通信的3个无名管道
int aofCreatePipes(void) {
int fds[6] = {-1, -1, -1, -1, -1, -1};
int j;
// 每个管道需要两个文件描述符，一个用于读，一个用于写
if (pipe(fds) == -1) goto error; /* parent -> children data. */
if (pipe(fds+2) == -1) goto error; /* children -> parent ack. */
if (pipe(fds+4) == -1) goto error; /* children -> parent ack. */
// 将从父进程向子进程传递数据的管道设置为非阻塞的
if (anetNonBlock(NULL,fds[0]) != ANET_OK) goto error;
if (anetNonBlock(NULL,fds[1]) != ANET_OK) goto error;
// 将fds[2]添加到事件循环的监听，关注该文件描述符上发生的可读事件，读回调函数为aofChildPipeReadable。
// 当aof重写进程希望服务器进程停止发送aof差异数据时，会像服务器进程发送'!',此时会调用aofChildPipeReadable函数
if (aeCreateFileEvent(server.el, fds[2], AE_READABLE, aofChildPipeReadable, NULL) == AE_ERR) goto error;
// 父进程使用fd[1]写数据到子进程的fd[0]
server.aof_pipe_write_data_to_child = fds[1];
server.aof_pipe_read_data_from_parent = fds[0];
// 子进程使用fd[3]写确认到父进程的fd[2]
server.aof_pipe_write_ack_to_parent = fds[3];
server.aof_pipe_read_ack_from_child = fds[2];
// 父进程使用fd[5]写确认到子进程的fd[4]
server.aof_pipe_write_ack_to_child = fds[5];
server.aof_pipe_read_ack_from_parent = fds[4];
server.aof_stop_sending_diff = 0;
return REDIS_OK;
error:
redisLog(REDIS_WARNING,"Error opening /setting AOF rewrite IPC pipes: %s",
strerror(errno));
for (j = 0; j < 6; j++) if(fds[j] != -1) close(fds[j]);
return REDIS_ERR;
}每当执行写命令时，都会调用feedAppendOnlyFile()函数将命令追加到aof_buf，若正在进行aof重写，该函数还会额外添加到aof重写缓存中一份。aof重写缓存是一个由一个个缓存单元组成的链表（server.aof_rewrite_buf_blocks）（类似于TCP/IP协议中的mbuf）。当进行aof重写的过程中，服务器进程会通过管道将aof重写缓存中的数据发送给aof重写进程，这样可以减少aof重写进程结束后服务器进程要进行的合并数据，从而减少了服务器失去响应的时间。feedAppendOnlyFile函数及aof重写缓存的实现如下所示：
// 添加命令到aof缓存，并且若正在进行aof重写，则还要追加到aof重写缓存中
void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) {
sds buf = sdsempty();
robj *tmpargv[3];
// 若当前操作的数据库与AOF文件中当前选中的数据库不同，则向AOF文件中添加一条选择数据库命令
if (dictid != server.aof_selected_db) {
char seldb[64];
snprintf(seldb,sizeof(seldb),"%d",dictid);
buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n",
(unsigned long)strlen(seldb),seldb);
server.aof_selected_db = dictid;
}
// 判断命令类型
if (cmd->proc == expireCommand || cmd->proc == pexpireCommand ||
cmd->proc == expireatCommand) {
// 超时命令
buf = catAppendOnlyExpireAtCommand(buf,cmd,argv[1],argv[2]);
} else if (cmd->proc == setexCommand || cmd->proc == psetexCommand) {
/* Translate SETEX/PSETEX to SET and PEXPIREAT */
tmpargv[0] = createStringObject("SET",3);
tmpargv[1] = argv[1];
tmpargv[2] = argv[3];
buf = catAppendOnlyGenericCommand(buf,3,tmpargv);
decrRefCount(tmpargv[0]);
buf = catAppendOnlyExpireAtCommand(buf,cmd,argv[1],argv[2]);
} else {
// 所有其它命令采用相同的存储方式
buf = catAppendOnlyGenericCommand(buf,argc,argv);
}
// 添加到aof_buf
if (server.aof_state == REDIS_AOF_ON)
server.aof_buf = sdscatlen(server.aof_buf,buf,sdslen(buf));
// 若正在进行aof重写，则将aof数据添加到aof重写缓存
if (server.aof_child_pid != -1)
aofRewriteBufferAppend((unsigned char*)buf,sdslen(buf));
sdsfree(buf);
}aof重写缓存如下所示：
#define AOF_RW_BUF_BLOCK_SIZE (1024*1024*10) /* 10 MB per block */
// 用于存储aof重写数据的缓存单元
typedef struct aofrwblock {
unsigned long used, free; // 已用空间和可用空间
char buf[AOF_RW_BUF_BLOCK_SIZE];
} aofrwblock;
// 获取当前aof重写缓存的总大小
//（即server.aof_rewrite_buf_blocks链表中各个节点的已用空间之和）
unsigned long aofRewriteBufferSize(void) {
listNode *ln;
listIter li;
unsigned long size = 0;
listRewind(server.aof_rewrite_buf_blocks,&li);
while((ln = listNext(&li))) {
aofrwblock *block = listNodeValue(ln);
size += block->used;
}
return size;
}
//添加新的数据到aof重写缓存，若需要则开辟新的缓存单元aofrwblock
void aofRewriteBufferAppend(unsigned char *s, unsigned long len) {
listNode *ln = listLast(server.aof_rewrite_buf_blocks);
aofrwblock *block = ln ? ln->value : NULL;
while(len) {
// 将数据添加到最后一个缓存单元
if (block) {
unsigned long thislen = (block->free < len) ? block->free : len;
if (thislen) { /* The current block is not already full. */
memcpy(block->buf+block->used, s, thislen);
block->used += thislen;
block->free -= thislen;
s += thislen;
len -= thislen;
}
}
// 若现有缓存单元不足以存储，则开辟一个新的缓存单元
if (len) { /* First block to allocate, or need another block. */
int numblocks;
block = zmalloc(sizeof(*block)); // 开辟新的缓存单元
block->free = AOF_RW_BUF_BLOCK_SIZE;
block->used = 0;
// 将新的缓存单元添加到aof重写缓存链表的末尾
listAddNodeTail(server.aof_rewrite_buf_blocks,block);
/* Log every time we cross more 10 or 100 blocks, respectively
* as a notice or warning. */
numblocks = listLength(server.aof_rewrite_buf_blocks);
// 若缓存列表中的缓存单元个数超过10个则进行警告级别的日志记录，
// 若超过100个则进行NOTICE级别的日志记录
if (((numblocks+1) % 10) == 0) {
int level = ((numblocks+1) % 100) == 0 ? REDIS_WARNING :
REDIS_NOTICE;
redisLog(level,"Background AOF buffer size: %lu MB",
aofRewriteBufferSize()/(1024*1024));
}
}
}
// 若当前还未将数据管道的写端添加到事件循环中（文件事件）
// 则通过aeCreateFileEvent()函数将管道写端添加到事件循环
// 监听的文件描述符中，并将aofChildWriteDiffData做为可写
// 事件回调。（【注】：类似于muduo）
if (aeGetFileEvents(server.el,server.aof_pipe_write_data_to_child) == 0) {
aeCreateFileEvent(server.el, server.aof_pipe_write_data_to_child,
AE_WRITABLE, aofChildWriteDiffData, NULL);
}
}
// 将aof重写缓存中的数据写入文件描述符位fd的文件
// 【注】：用于aof重写进程结束胡，服务器进程将剩余aof差异数据写入新的aof文件
ssize_t aofRewriteBufferWrite(int fd) {
listNode *ln;
listIter li;
ssize_t count = 0;
// 遍历aof重写缓存链表
listRewind(server.aof_rewrite_buf_blocks,&li);
while((ln = listNext(&li))) {
aofrwblock *block = listNodeValue(ln);
ssize_t nwritten;
if (block->used) {
nwritten = write(fd,block->buf,block->used);
if (nwritten != (ssize_t)block->used) {
if (nwritten == 0) errno = EIO;
return -1;
}
count += nwritten;
}
}
return count;
}
// 使用该函数将启动aof重写后，服务器随后产生的aof指令通过管道发送至子进程
// 以此减少子进程执行完aof重写后，服务器要进行合并的数量，从而减少了服务器
// 阻塞在合并上的时间
void aofChildWriteDiffData(aeEventLoop *el, int fd, void *privdata, int mask) {
listNode *ln;
aofrwblock *block;
ssize_t nwritten;
REDIS_NOTUSED(el);
REDIS_NOTUSED(fd);
REDIS_NOTUSED(privdata);
REDIS_NOTUSED(mask);
while(1) {
ln = listFirst(server.aof_rewrite_buf_blocks);
block = ln ? ln->value : NULL;
if (server.aof_stop_sending_diff || !block) {
aeDeleteFileEvent(server.el,server.aof_pipe_write_data_to_child,
AE_WRITABLE);
return;
}
if (block->used > 0) {
nwritten = write(server.aof_pipe_write_data_to_child,
block->buf,block->used);
if (nwritten <= 0) return;
// 将未写数据迁移，并更新缓存单元的已用大小
memmove(block->buf,block->buf+nwritten,block->used-nwritten);
block->used -= nwritten;
}
// 若该缓存单元已发送完毕，则释放该缓存单元
if (block->used == 0) listDelNode(server.aof_rewrite_buf_blocks,ln);
}
}创建子进程调用重写函数的实现如下所示：
// 创建一个子进程进行aof文件重写
int rewriteAppendOnlyFileBackground(void) {
pid_t childpid;
long long start;
if (server.aof_child_pid != -1) return REDIS_ERR;
// 调用aofCreatePipes创建用于父子进程间通信的管道
if (aofCreatePipes() != REDIS_OK) return REDIS_ERR;
// 记录aof文件重写的开始时间
start = ustime();
// 创建子进程进行aof重写，以放至阻塞服务器进程提供服务
if ((childpid = fork()) == 0) {
char tmpfile[256];
/* Child */
// 关闭从父进程继承而来的套接字描述符
closeListeningSockets(0);
redisSetProcTitle("redis-aof-rewrite");
// 将子进程的进程id写入tmpfile，做为新aof文件的文件名
snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) getpid());
// 子进程调用rewriteAppendOnlyFile函数完成aof重写，依据是否成功，子进程有不同的退出码0或1
if (rewriteAppendOnlyFile(tmpfile) == REDIS_OK) {
size_t private_dirty = zmalloc_get_private_dirty();
if (private_dirty) {
redisLog(REDIS_NOTICE,
"AOF rewrite: %zu MB of memory used by copy-on-write",
private_dirty/(1024*1024));
}
exitFromChild(0);
} else {
exitFromChild(1);
}
} else {
/* Parent */
// server.stat_fork_time保存了fork调用时间
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) { // fork失败
redisLog(REDIS_WARNING,
"Can't rewrite append only file in background: fork: %s",
strerror(errno));
return REDIS_ERR;
}
redisLog(REDIS_NOTICE,
"Background append only file rewriting started by pid %d",childpid);
server.aof_rewrite_scheduled = 0;
server.aof_rewrite_time_start = time(NULL);
server.aof_child_pid = childpid; // 记录子进程的id
// 当存在正在进行持久化的子进程时不允许调整数据库中字典的大小
updateDictResizePolicy();
// 将server.aof_selected_db设置为-1是为了保证下一次调用feedAppendOnlyFile()函数添加命令到
// aof文件之前会先添加一条select db的命令，这样进行合并将会是安全的，因为在重写时是遍历
// 每个数据库来实现aof重写的，在重写每个数据库时都会在开头加上select db的命令
server.aof_selected_db = -1;
// 【注】：该函数暂不了解，似乎和主从服务器之类的有关，之后在进行补注
replicationScriptCacheFlush();
return REDIS_OK;
}
return REDIS_OK; /* unreached */
}子进程中调用的rewriteAppendOnlyFile函数执行真正的aof重写操作，其过程如下所示：
// 从服务器读取aof数据，将其添加到server.aof_child_diff缓存中
// aof_child_diff存储着启动aof重写后，服务器增加并通过管道告
// 知客户端的aof数据（指令集）
ssize_t aofReadDiffFromParent(void) {
char buf[65536]; /* Default pipe buffer size on most Linux systems. */
ssize_t nread, total = 0;
while ((nread =
read(server.aof_pipe_read_data_from_parent,buf,sizeof(buf))) > 0) {
server.aof_child_diff = sdscatlen(server.aof_child_diff,buf,nread);
total += nread;
}
return total;
}
// 在子进程中进行aof文件重写
int rewriteAppendOnlyFile(char *filename) {
dictIterator *di = NULL;
dictEntry *de;
rio aof;
FILE *fp;
char tmpfile[256];
int j;
long long now = mstime();
char byte;
size_t processed = 0;
// 创建新的aof文件
snprintf(tmpfile,256,"temp-rewriteaof-%d.aof", (int) getpid());
fp = fopen(tmpfile,"w");
if (!fp) {
redisLog(REDIS_WARNING, "Opening the temp file for AOF rewrite in rewriteAppendOnlyFile(): %s", strerror(errno));
return REDIS_ERR;
}
server.aof_child_diff = sdsempty();
// 保存新的文件信息到aof结构体中，比如：读写函数，文件描述符等
rioInitWithFile(&aof,fp);
// server.aof_rewrite_incremental_fsync用于标示在rewrite过程中是否增量进行fsync操作，
// 便于均摊磁盘IO压力，增量每次写入自动进行fsync
if (server.aof_rewrite_incremental_fsync)
rioSetAutoSync(&aof,REDIS_AOF_AUTOSYNC_BYTES);
// 循环遍历每个数据库，并进行aof持久化
for (j = 0; j < server.dbnum; j++) {
// 重写每个数据库前都会先写入select db的命令
char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n";
redisDb *db = server.db+j;
dict *d = db->dict;
if (dictSize(d) == 0) continue;
// 获取遍历该字典的迭代器di
di = dictGetSafeIterator(d);
if (!di) {
fclose(fp);
return REDIS_ERR;
}
if (rioWrite(&aof,selectcmd,sizeof(selectcmd)-1) == 0) goto werr;
if (rioWriteBulkLongLong(&aof,j) == 0) goto werr;
// 遍历整个字典已完成指令简化，即aof重写
while((de = dictNext(di)) != NULL) {
sds keystr;
robj key, *o;
long long expiretime;
keystr = dictGetKey(de);// 获取字典的键（必为字符串对象）
o = dictGetVal(de); // 获取字典的值
initStaticStringObject(key,keystr);
// 检查该键是否设置了过期时间
expiretime = getExpire(db,&key);
// 若该键已过期，则不存入AOF重写文件
if (expiretime != -1 && expiretime < now) continue;
// 根据值类型的不同，将其转化为对应的命令进行存储
if (o->type == REDIS_STRING) {
char cmd[]="*3\r\n$3\r\nSET\r\n";
// 存储命令
if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
// 存储键和值
if (rioWriteBulkObject(&aof,&key) == 0) goto werr;
if (rioWriteBulkObject(&aof,o) == 0) goto werr;
} else if (o->type == REDIS_LIST) {
if (rewriteListObject(&aof,&key,o) == 0) goto werr;
} else if (o->type == REDIS_SET) {
if (rewriteSetObject(&aof,&key,o) == 0) goto werr;
} else if (o->type == REDIS_ZSET) {
if (rewriteSortedSetObject(&aof,&key,o) == 0) goto werr;
} else if (o->type == REDIS_HASH) {
if (rewriteHashObject(&aof,&key,o) == 0) goto werr;
} else {
redisPanic("Unknown object type");
}
// 若设置了过期时间则还要存储过期键的设置命令
if (expiretime != -1) {
char cmd[]="*3\r\n$9\r\nPEXPIREAT\r\n";
if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
// 存储键和值（值为过期时间）
if (rioWriteBulkObject(&aof,&key) == 0) goto werr;
if (rioWriteBulkLongLong(&aof,expiretime) == 0) goto werr;
}
// aof.processed_bytes记录了该管道io中读入了多少字节的数据
// 若从管道中读出的数据（来自父进程的aof重写数据）大于10K则将其
// 写入aof差异缓存
if (aof.processed_bytes > processed+1024*10) {
processed = aof.processed_bytes;
aofReadDiffFromParent();
}
}
dictReleaseIterator(di);
di = NULL;
}
if (fflush(fp) == EOF) goto werr; // 冲刷数据到内核的缓冲
if (fsync(fileno(fp)) == -1) goto werr; // 进行文件同步（将内核缓冲区中的数据同步到磁盘上）
int nodata = 0;
mstime_t start = mstime();
// 在读aof数据的管道上等待1000次1ms，且连续无数据的次数不超过20次
while(mstime()-start < 1000 && nodata < 20) {
// aeWait函数调用poll在管道描述符server.aof_pipe_read_data_from_parent上等待1ms，以期待
// 可读事件的到来
if (aeWait(server.aof_pipe_read_data_from_parent, AE_READABLE, 1) <= 0)
{
nodata++;
continue;
}
nodata = 0;
// 将服务器之后写入的aof数据追加到aof差异缓存server.aof_child_diff中
aofReadDiffFromParent();
}
// 写一个"!"给父进程，告知其停止发送aof差异数据
if (write(server.aof_pipe_write_ack_to_parent,"!",1) != 1) goto werr;
// 调用fcntl函数将aof进程读确认管道设置为非阻塞
if (anetNonBlock(NULL,server.aof_pipe_read_ack_from_parent) != ANET_OK)
goto werr;
// 调用syncRead从服务器进程读取回复，若读取数据不为'!'，则说明出现异常
if (syncRead(server.aof_pipe_read_ack_from_parent,&byte,1,5000) != 1 ||
byte != '!') goto werr;
redisLog(REDIS_NOTICE,"Parent agreed to stop sending diffs. Finalizing AOF...");
// 最后一次读取aof差异数据，因为在向服务器请求停止发送的过程中，服务器可能仍发送了部分数据
aofReadDiffFromParent();
redisLog(REDIS_NOTICE,
"Concatenating %.2f MB of AOF diff received from parent.",
(double) sdslen(server.aof_child_diff) / (1024*1024));
// 将aof差异数据写入aof文件
if (rioWrite(&aof,server.aof_child_diff,sdslen(server.aof_child_diff)) == 0)
goto werr;
if (fflush(fp) == EOF) goto werr; // 调用fflush函数将数据冲洗到操作系统的缓存中
if (fsync(fileno(fp)) == -1) goto werr; // 将数据从操作系统的缓存同步到磁盘
if (fclose(fp) == EOF) goto werr; // 关闭文件
if (rename(tmpfile,filename) == -1) {
redisLog(REDIS_WARNING,"Error moving temp append only file on the final destination: %s", strerror(errno));
unlink(tmpfile);
return REDIS_ERR;
}
redisLog(REDIS_NOTICE,"SYNC append only file rewrite performed");
return REDIS_OK;
werr:
redisLog(REDIS_WARNING,"Write error writing append only file on disk: %s", strerror(errno));
fclose(fp);
unlink(tmpfile);
if (di) dictReleaseIterator(di);
return REDIS_ERR;
}服务器进程会在serverCron函数中非阻塞的调用wait3函数，若aof重写进程结束后，服务器进程会获取aof重写进程的退出码，并将剩余aof差异数据（aof重写缓存中的数据）写入新的aof文件。其代码如下所示：
void serverCron()
{
if (server.rdb_child_pid != -1 || server.aof_child_pid != -1) {
int statloc;
pid_t pid;
// 调用wait3函数判断子进程是否结束，当返回值>0则说明进程以终止，若 == 0则未终止， 若<0则出错
// statloc: 用于保存进程的终止状态
// WNOHANG：若由pid指定的子进程的结束状态不可立刻获得(子进程还未结束)，则不阻塞,(参 APUE p193)
if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
// 获取子进程传送给exit或_exit参数的低8位
int exitcode = WEXITSTATUS(statloc);
int bysignal = 0;
// WIFSIGNALED宏：当statloc为异常终止的返回状态，则返回true,此时可使用WTERMSIG获取使子进程终止的信号编号
if (WIFSIGNALED(statloc)) bysignal = WTERMSIG(statloc);
if (pid == -1) { // wait调用出错（如：无子进程调用了wait）
redisLog(LOG_WARNING,"wait3() returned an error: %s. "
"rdb_child_pid = %d, aof_child_pid = %d",
strerror(errno),
(int) server.rdb_child_pid,
(int) server.aof_child_pid);
} else if (pid == server.rdb_child_pid) { // 若是rdb持久化子进程结束
backgroundSaveDoneHandler(exitcode,bysignal);
} else if (pid == server.aof_child_pid) { // 若是aof重写进程结束
backgroundRewriteDoneHandler(exitcode,bysignal);
} else {
redisLog(REDIS_WARNING,
"Warning, detected child with unmatched pid: %ld",
(long)pid);
}
updateDictResizePolicy();
}
}
}
// 在服务器进程中进行aof重写最后的合并操作
void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
if (!bysignal && exitcode == 0) {
int newfd, oldfd;
char tmpfile[256];
long long now = ustime();
mstime_t latency;
redisLog(REDIS_NOTICE,
"Background AOF rewrite terminated with success");
latencyStartMonitor(latency); // 检测写入aof重写缓存数据到aof文件的耗时
snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof",
(int)server.aof_child_pid);
// 以追加方式打开新的aof文件
newfd = open(tmpfile,O_WRONLY|O_APPEND);
if (newfd == -1) {
redisLog(REDIS_WARNING,
"Unable to open the temporary AOF produced by the child: %s", strerror(errno));
goto cleanup;
}
// 将aof重写缓存中的剩余数据写入新的aof文件
if (aofRewriteBufferWrite(newfd) == -1) {
redisLog(REDIS_WARNING,
"Error trying to flush the parent diff to the rewritten AOF: %s", strerror(errno));
close(newfd);
goto cleanup;
}
latencyEndMonitor(latency); // 计算耗时
latencyAddSampleIfNeeded("aof-rewrite-diff-write",latency);
redisLog(REDIS_NOTICE,
"Residual parent diff successfully flushed to the rewritten AOF (%.2f MB)", (double) aofRewriteBufferSize() / (1024*1024));
/* 现在仅剩的问题是将新aof的文件名从临时名变为配置的文件名，并关闭旧的aof文件。
* 我们不想调用close(2)函数或rename(2)函数，因为它们并非非阻塞的，可能会造成服
* 务器进程的阻塞。
*
* 它们可能会造成以下两种情况：
*
* 1）若旧aof文件已被关闭并且这是一次aof重写操作，那么新aof文件将会从临时文件名
* 变更为配置的aof文件名。若已存在一个旧aof文件，那么会造成删除该目录项节点（
* 此处说的目录项并非平常意义中的目录，而是linux文件系统中的一个环节，其指向了
* 索引节点），而这会减少索引节点中的引用计数，当引用计数为0时将删除该文件（但若
* 此时有进程打开了该文件也不会立刻删除，索引节点的i_count记录了使用该节点的进程数
* ，i_nlink记录了硬链接数目，在关闭一个文件时会检查这两个计数，只要有一个不为0，
* 则索引节点都不会被删除），而删除文件会耗费时间。参APUE p94 - p95
*
* 2）若旧aof文件仍处于打开状态，则会关闭该文件，并对新aof进行重命名，那么此时
* 又会造成1）中的情况。
*
* 为了缓和unlink造成的阻塞影响（耗时），我们使用线程去处理这件事
*/
if (server.aof_fd == -1) {
// 若旧的aof文件已关闭，则我们先将其打开，因为有进程打开该文件时，该文件进行unlink不会被删除
// 以便之后在任务线程中进行关闭
oldfd = open(server.aof_filename,O_RDONLY|O_NONBLOCK);
} else {
oldfd = -1; /* We'll set this to the current AOF filedes later. */
}
latencyStartMonitor(latency);
if (rename(tmpfile,server.aof_filename) == -1) { // 重命名失败
redisLog(REDIS_WARNING,
"Error trying to rename the temporary AOF file: %s", strerror(errno));
close(newfd);
if (oldfd != -1) close(oldfd);
goto cleanup;
}
latencyEndMonitor(latency);
latencyAddSampleIfNeeded("aof-rename",latency);
if (server.aof_fd == -1) {
// 若aof文件描述符本就为-1（即无打开的aof文件，那么也不必打开新的aof文件）
close(newfd);
} else {
/* 若旧的aof文件是打开的，那么我们将其文件描述符记录在oldfd中，
* 以便之后将其做为参数传入任务线程将其关闭。*/
oldfd = server.aof_fd;
// 将新的aof文件的文件描述符保存在服务器中
server.aof_fd = newfd;
// 根据同步策略进行同步
if (server.aof_fsync == AOF_FSYNC_ALWAYS)
aof_fsync(newfd);
else if (server.aof_fsync == AOF_FSYNC_EVERYSEC)
aof_background_fsync(newfd);
server.aof_selected_db = -1; /* Make sure SELECT is re-issued */
aofUpdateCurrentSize();
server.aof_rewrite_base_size = server.aof_current_size;
sdsfree(server.aof_buf);
server.aof_buf = sdsempty();
}
server.aof_lastbgrewrite_status = REDIS_OK;
redisLog(REDIS_NOTICE, "Background AOF rewrite finished successfully");
if (server.aof_state == REDIS_AOF_WAIT_REWRITE)
server.aof_state = REDIS_AOF_ON;
// 在任务线程中关闭旧的aof文件
if (oldfd != -1) bioCreateBackgroundJob(REDIS_BIO_CLOSE_FILE,(void*)(long)oldfd,NULL,NULL);
redisLog(REDIS_VERBOSE,
"Background AOF rewrite signal handler took %lldus", ustime()-now);
} else if (!bysignal && exitcode != 0) {
server.aof_lastbgrewrite_status = REDIS_ERR;
redisLog(REDIS_WARNING,
"Background AOF rewrite terminated with error");
} else {
server.aof_lastbgrewrite_status = REDIS_ERR;
redisLog(REDIS_WARNING,
"Background AOF rewrite terminated by signal %d", bysignal);
}
cleanup:
aofClosePipes();
aofRewriteBufferReset();
aofRemoveTempFile(server.aof_child_pid);
server.aof_child_pid = -1;
server.aof_rewrite_time_last = time(NULL)-server.aof_rewrite_time_start;
server.aof_rewrite_time_start = -1;
/* Schedule a new rewrite if we are waiting for it to switch the AOF ON. */
if (server.aof_state == REDIS_AOF_WAIT_REWRITE)
server.aof_rewrite_scheduled = 1;
}【注】：当调用rename函数且newname已存在时，会调用unlink减少索引节点的硬连接数，当硬链接数减至0且无进程打开该文件（索引节点的引用计数i_count为0）则删除文件，若仍有进程打开该文件，则不会立刻删除。
【注】：当关闭一个文件时，操作系统会检查该文件的硬链接数与引用计数（即是否有进程打开），若二者都为0则删除文件。
【注】：正式因为以上原因，redis为了避免在主线程中删除文件而造成阻塞，从而先保证旧的AOF文件在rename之前处于被打开状态，之后在任务线程中关闭文件。
662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
