Cơ Chế Persistence Của Redis: RDB và AOF Hoạt Động Như Thế Nào

git clone https://github.com/redis/redis.git
cd redis/src

struct redisServer {
    // Trạng thái RDB
    pid_t rdb_child_pid;          // PID của process save nền (-1 nếu không có)
    int rdb_bgsave_scheduled;     // BGSAVE được yêu cầu nhưng bị chặn bởi AOF rewrite
    time_t rdb_last_save;         // Unix timestamp của lần save thành công gần nhất
    int rdb_last_bgsave_status;   // C_OK hoặc C_ERR
    long long dirty;              // Số thay đổi kể từ lần RDB save gần nhất
    long long dirty_before_bgsave;// Số dirty khi BGSAVE bắt đầu
 
    // Trạng thái AOF
    int aof_state;                // AOF_OFF, AOF_ON hoặc AOF_WAIT_REWRITE
    int aof_fd;                   // File descriptor của AOF file
    pid_t aof_child_pid;          // PID của process background rewrite
    sds aof_buf;                  // Buffer in-memory: lệnh chờ flush
    sds aof_rewrite_buf_blocks;   // Buffer phụ: lệnh trong khi rewrite
    off_t aof_current_size;       // Kích thước AOF file hiện tại tính bằng byte
};

SAVE      # Đồng bộ — block Redis cho đến khi xong (tránh dùng ở production)
BGSAVE    # Không đồng bộ — fork child process, trả về ngay lập tức

# Save nếu ít nhất 1 key thay đổi trong 900 giây qua
save 900 1
# Save nếu ít nhất 10 key thay đổi trong 300 giây qua
save 300 10
# Save nếu ít nhất 10000 key thay đổi trong 60 giây qua
save 60 10000

int rdbSaveBackground(int req, char *filename,
                      rdbSaveInfo *rsi, int rdbflags) {
    pid_t childpid;
 
    // Không thể chạy hai background save đồng thời
    if (hasActiveChildProcess()) return C_ERR;
 
    server.dirty_before_bgsave = server.dirty;
    server.lastbgsave_try = time(NULL);
 
    // *** THAO TÁC CHÍNH ***
    if ((childpid = redisFork(CHILD_TYPE_RDB)) == 0) {
        // === Child process ===
        int retval;
        redisSetProcTitle("redis-rdb-bgsave");
        redisSetCpuAffinity(server.bgsave_cpulist);
        retval = rdbSave(req, filename, rsi, rdbflags);
        if (retval == C_OK) {
            sendChildCowInfo(CHILD_INFO_TYPE_RDB_COW_SIZE,
                             "RDB");
        }
        exitFromChild((retval == C_OK) ? 0 : 1);
    } else {
        // === Parent process (Redis server chính) ===
        if (childpid == -1) {
            // fork() thất bại
            server.lastbgsave_status = C_ERR;
            return C_ERR;
        }
        serverLog(LL_NOTICE,
            "Background saving started by pid %ld",
            (long) childpid);
        server.rdb_save_time_start = time(NULL);
        server.rdb_child_pid = childpid;
        return C_OK;
    }
    return C_OK; // không đến được ở parent
}

int rdbSave(int req, char *filename,
            rdbSaveInfo *rsi, int rdbflags) {
    // Ghi vào temp file trước, sau đó rename atomic
    snprintf(tmpfile, 256, "temp-%d.rdb", (int) getpid());
    fp = fopen(tmpfile, "w");
    rioInitWithFile(&rdb, fp);
 
    if (rdbSaveRio(req, &rdb, &error, rdbflags, rsi) == C_ERR) {
        // Xử lý lỗi...
    }
 
    // Flush OS buffer ra đĩa
    if (fflush(fp) == EOF) goto werr;
    if (fsync(fileno(fp)) == -1) goto werr;
    if (fclose(fp) == EOF) goto werr;
 
    // Rename atomic: dump.rdb cũ được thay thế bằng một syscall
    if (rename(tmpfile, filename) == -1) goto werr;
 
    return C_OK;
}

[REDIS][version][aux fields]
  Với mỗi database:
    [SELECTDB][db number]
    [RESIZE_DB][key count][expire count]
    Với mỗi key:
      [tùy chọn: EXPIRETIME ms][unix timestamp]
      [type byte]
      [encoded key]
      [encoded value]
[EOF]
[8-byte CRC64 checksum]

// Trong server.c, serverCron():
if (pid == server.rdb_child_pid) {
    backgroundSaveDoneHandler(exitcode, bysignal);
}

// Đơn giản hóa từ aof.c
void feedAppendOnlyFile(int dictid, robj **argv, int argc) {
    sds buf = sdsempty();
 
    // Nếu client đang ở database khác, emit SELECT trước
    if (server.aof_selected_db != dictid) {
        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;
    }
 
    // Chuyển đổi expiry tương đối thành timestamp tuyệt đối
    // (cùng lý do như trong replication: tránh drift)
    if (argc == 3 && !strcasecmp(argv[0]->ptr, "set")) {
        // Viết lại SET key value EX 60
        // thành:   SET key value PXAT <absolute_ms>
    }
 
    // Encode lệnh theo định dạng RESP và append vào buffer
    buf = catAppendOnlyGenericCommand(buf, argc, argv);
    server.aof_buf = sdscatlen(server.aof_buf, buf, sdslen(buf));
    sdsfree(buf);
}

void flushAppendOnlyFile(int force) {
    ssize_t nwritten;
 
    if (sdslen(server.aof_buf) == 0) {
        // Không có gì để flush, nhưng có thể vẫn fsync theo timer
        if (server.aof_fsync == AOF_FSYNC_EVERYSEC && ...) {
            goto try_fsync;
        }
        return;
    }
 
    // Ghi buffer vào file descriptor
    nwritten = aofWrite(server.aof_fd,
                        server.aof_buf,
                        sdslen(server.aof_buf));
 
    // Xóa buffer (dữ liệu bây giờ trong OS page cache)
    sdsclear(server.aof_buf);
 
try_fsync:
    if (server.aof_fsync == AOF_FSYNC_ALWAYS) {
        // Flush OS page cache ra đĩa vật lý NGAY BÂY
        // Đảm bảo durability: tối đa 1 lệnh mất khi crash
        // Chi phí: một fsync mỗi lệnh (rất chậm trên ổ cứng quay)
        redis_fsync(server.aof_fd);
 
    } else if (server.aof_fsync == AOF_FSYNC_EVERYSEC) {
        // Ủy quyền fsync cho background thread, mỗi giây một lần
        // Tối đa 1 giây dữ liệu mất khi crash
        // Chi phí: ~1 fsync mỗi giây (mặc định thực tế)
        if (server.aof_last_fsync < now) {
            aof_background_fsync(server.aof_fd);
        }
 
    } else {
        // AOF_FSYNC_NO: không bao giờ gọi fsync tường minh
        // OS quyết định khi nào flush (thường mỗi 30 giây)
        // Tối đa ~30 giây dữ liệu mất khi crash
        // Chi phí: nhanh nhất, nhưng đảm bảo durability thấp nhất
    }
}

BGREWRITEAOF   # Kích hoạt thủ công
# Redis cũng làm điều này tự động dựa trên giá trị config
# aof-rewrite-min-size và aof-rewrite-percentage

int aofRewriteBackground(void) {
    pid_t childpid;
 
    if (hasActiveChildProcess()) return C_ERR;
 
    if ((childpid = redisFork(CHILD_TYPE_AOF)) == 0) {
        // === Child process ===
        char tmpfile[256];
        snprintf(tmpfile, 256, "temp-rewriteaof-bg-%d.aof",
                 (int) getpid());
        if (rewriteAppendOnlyFile(tmpfile) == C_OK) {
            sendChildCowInfo(CHILD_INFO_TYPE_AOF_COW_SIZE, "AOF rewrite");
            exitFromChild(0);
        } else {
            exitFromChild(1);
        }
    } else {
        // === Parent process ===
        server.aof_child_pid = childpid;
        // Bắt đầu tích lũy lệnh vào buffer phụ
        aofRewriteBufferReset();
        server.aof_rewrite_buf_blocks = listCreate();
        return C_OK;
    }
}

void feedAppendOnlyFile(int dictid, robj **argv, int argc) {
    // ... encode lệnh thành buf ...
 
    // Luôn append vào main AOF buffer
    server.aof_buf = sdscatlen(server.aof_buf, buf, sdslen(buf));
 
    // CŨNG append vào rewrite buffer nếu rewrite đang chạy
    if (server.aof_child_pid != -1)
        aofRewriteBufferAppend((unsigned char*)buf, sdslen(buf));
}

void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
    if (!bysignal && exitcode == 0) {
        // 1. Mở AOF nhỏ gọn mới
        newfd = open(tmpfile, O_WRONLY|O_APPEND);
 
        // 2. Append toàn bộ buffer phụ tích lũy vào đó
        //    (tất cả lệnh ghi đến trong quá trình rewrite)
        if (aofRewriteBufferWrite(newfd) == -1) { ... }
 
        // 3. Rename atomic: file mới thay thế file cũ
        rename(tmpfile, server.aof_filename);
 
        // 4. Chuyển file descriptor sang file mới
        oldfd = server.aof_fd;
        server.aof_fd = newfd;
        close(oldfd);  // Có thể chậm, nhưng xảy ra sau rename
    }
}

void loadDataFromDisk(void) {
    long long start = ustime();
 
    if (server.aof_state == AOF_ON) {
        // AOF được ưu tiên — nó đầy đủ hơn
        if (loadAppendOnlyFiles(server.aof_manifest) == AOF_FAILED) {
            exit(1);
        }
    } else {
        // Không có AOF, thử RDB
        rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
        errno = 0;
        int rdb_flags = RDBFLAGS_MAIN_FILE;
        if (rdbLoad(server.rdb_filename, &rsi, rdb_flags) == C_OK) {
            serverLog(LL_NOTICE, "DB loaded from disk: %.3f seconds",
                      (float)(ustime()-start)/1000000);
        } else if (errno != ENOENT) {
            serverLog(LL_WARNING, "Fatal error loading RDB file: %s. Exiting.",
                      server.rdb_filename);
            exit(1);
        }
    }
}

# redis.conf
aof-use-rdb-preamble yes

[Dữ liệu binary RDB — nhỏ gọn, load nhanh]
[Lệnh AOF — chỉ những gì thay đổi kể từ RDB preamble]

# Các hàm chính cần đọc theo thứ tự:
grep -n "rdbSaveBackground" src/rdb.c     # Entry point BGSAVE
grep -n "rdbSave\b" src/rdb.c             # Công việc của child
grep -n "feedAppendOnlyFile" src/aof.c    # Nơi lệnh được log
grep -n "flushAppendOnlyFile" src/aof.c   # Quyết định fsync
grep -n "aofRewriteBackground" src/aof.c  # Entry point BGREWRITEAOF
grep -n "backgroundRewriteDoneHandler" src/aof.c  # Ghép buffer phụ
grep -n "loadDataFromDisk" src/server.c   # Logic load khi khởi động

# Redis có sẵn công cụ này
src/redis-check-rdb dump.rdb
 
# Hoặc dùng redis-cli
redis-cli --rdb /path/to/dump.rdb

cat appendonly.aof | head -50
# Bạn sẽ thấy:
# *3
# $3
# SET
# $6
# mykey
# $5
# hello