1.initServerConfig

众所周知,C语言的入口函数是main(),因此我从main函数开始学习.下面贴代码:

int main(int argc, char **argv) 
{
    struct timeval tv;//C语言用来记录时间的结构体,struct timeval { __time_t tv_sec; /* 秒 */ __suseconds_t tv_usec; /* 毫秒 */ };
	#ifdef INIT_SETPROCTITLE_REPLACEMENT
	    spt_init(argc, argv);
	#endif
    setlocale(LC_COLLATE,"");//设定local语言环境
    zmalloc_enable_thread_safeness();//zmalloc_thread_safe = 1,开启线程安全
    zmalloc_set_oom_handler(redisOutOfMemoryHandler);//设置oom内存溢出的处理函数
    srand(time(NULL)^getpid());//给rand()函数提供随机种子
    gettimeofday(&tv,NULL);//gettimeofday()可以返回当前时间,精度微秒
    dictSetHashFunctionSeed(tv.tv_sec^tv.tv_usec^getpid());//为dict结构hash函数提供种子
    server.sentinel_mode = checkForSentinelMode(argc,argv);//检查服务器是否以Sentinel模式启动

    initServerConfig();//初始化服务器
    .
    .
    .
}

本节的重点是initServerConfig(),它的内部实现是:

void initServerConfig()
{
    int j;

    getRandomHexChars(server.runid,REDIS_RUN_ID_SIZE);//生成server的runid,是一个随机数
    server.configfile = NULL;//默认的conf文件路径为NULL
    server.hz = REDIS_DEFAULT_HZ;//#define REDIS_DEFAULT_HZ 10,默认的中断频率是每秒10次
    server.runid[REDIS_RUN_ID_SIZE] = '\0';//C语言的string,都是以\0结尾,所以这里要补上
    server.arch_bits = (sizeof(long) == 8) ? 64 : 32;//设置服务器的运行环境,是32bit还是64bit
    server.port = REDIS_SERVERPORT;//#define REDIS_SERVERPORT 6379,默认的监听端口是6379
    server.tcp_backlog = REDIS_TCP_BACKLOG;//backlog规定了内核应该为相应的套接字排队的最大连接个数
    server.bindaddr_count = 0;
    server.unixsocket = NULL;
    server.unixsocketperm = REDIS_DEFAULT_UNIX_SOCKET_PERM;
    server.ipfd_count = 0;
    server.sofd = -1;
    server.dbnum = REDIS_DEFAULT_DBNUM;//#define REDIS_DEFAULT_DBNUM 16,默认有16个库
    server.verbosity = REDIS_DEFAULT_VERBOSITY;
    server.maxidletime = REDIS_MAXIDLETIME;
    server.tcpkeepalive = REDIS_DEFAULT_TCP_KEEPALIVE;
    server.active_expire_enabled = 1;
    server.client_max_querybuf_len = REDIS_MAX_QUERYBUF_LEN;
    server.saveparams = NULL;
    server.loading = 0;
    server.logfile = zstrdup(REDIS_DEFAULT_LOGFILE);
    server.syslog_enabled = REDIS_DEFAULT_SYSLOG_ENABLED;
    server.syslog_ident = zstrdup(REDIS_DEFAULT_SYSLOG_IDENT);
    server.syslog_facility = LOG_LOCAL0;
    server.daemonize = REDIS_DEFAULT_DAEMONIZE;//#define REDIS_DEFAULT_DAEMONIZE 0,默认并非守护进程
    server.aof_state = REDIS_AOF_OFF;//#define REDIS_AOF_OFF 0,默认关闭了AOF存储功能
    server.aof_fsync = REDIS_DEFAULT_AOF_FSYNC;//#define REDIS_DEFAULT_AOF_FSYNC 2
    server.aof_no_fsync_on_rewrite = REDIS_DEFAULT_AOF_NO_FSYNC_ON_REWRITE;//#define REDIS_DEFAULT_AOF_NO_FSYNC_ON_REWRITE 0,默认,rewrite的时候,不允许aof
    server.aof_rewrite_perc = REDIS_AOF_REWRITE_PERC;
    server.aof_rewrite_min_size = REDIS_AOF_REWRITE_MIN_SIZE;//#define REDIS_AOF_REWRITE_MIN_SIZE (64*1024*1024),默认64M
    server.aof_rewrite_base_size = 0;
    server.aof_rewrite_scheduled = 0;
    server.aof_last_fsync = time(NULL);
    server.aof_rewrite_time_last = -1;
    server.aof_rewrite_time_start = -1;
    server.aof_lastbgrewrite_status = REDIS_OK;
    server.aof_delayed_fsync = 0;
    server.aof_fd = -1;
    server.aof_selected_db = -1;//其实db是从0开始数的,这里给-1的默认值是为了确保aof功能现在不能用
    server.aof_flush_postponed_start = 0;
    server.aof_rewrite_incremental_fsync = REDIS_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC;
    server.pidfile = zstrdup(REDIS_DEFAULT_PID_FILE);//#define REDIS_DEFAULT_PID_FILE "/var/run/redis.pid"	
    server.rdb_filename = zstrdup(REDIS_DEFAULT_RDB_FILENAME);//#define REDIS_DEFAULT_RDB_FILENAME "dump.rdb"
    server.aof_filename = zstrdup(REDIS_DEFAULT_AOF_FILENAME);//#define REDIS_DEFAULT_AOF_FILENAME "appendonly.aof"
    server.requirepass = NULL;//默认不需要密码
    server.rdb_compression = REDIS_DEFAULT_RDB_COMPRESSION;//#define REDIS_DEFAULT_RDB_COMPRESSION 1,rdb存储文件默认是要压缩的
    server.rdb_checksum = REDIS_DEFAULT_RDB_CHECKSUM;//#define REDIS_DEFAULT_RDB_CHECKSUM 1,rdb存储文件默认是要校验的
    server.stop_writes_on_bgsave_err = REDIS_DEFAULT_STOP_WRITES_ON_BGSAVE_ERROR;
    server.activerehashing = REDIS_DEFAULT_ACTIVE_REHASHING;
    server.notify_keyspace_events = 0;
    server.maxclients = REDIS_MAX_CLIENTS;//#define REDIS_MAX_CLIENTS 10000,默认最大允许10000个clients连接
    server.bpop_blocked_clients = 0;
    server.maxmemory = REDIS_DEFAULT_MAXMEMORY;//#define REDIS_DEFAULT_MAXMEMORY 0
    server.maxmemory_policy = REDIS_DEFAULT_MAXMEMORY_POLICY;//#define REDIS_DEFAULT_MAXMEMORY_POLICY REDIS_MAXMEMORY_NO_EVICTION,默认的LRU策略是不淘汰任何数据
    server.maxmemory_samples = REDIS_DEFAULT_MAXMEMORY_SAMPLES;
    server.hash_max_ziplist_entries = REDIS_HASH_MAX_ZIPLIST_ENTRIES;
    server.hash_max_ziplist_value = REDIS_HASH_MAX_ZIPLIST_VALUE;
    server.list_max_ziplist_entries = REDIS_LIST_MAX_ZIPLIST_ENTRIES;
    server.list_max_ziplist_value = REDIS_LIST_MAX_ZIPLIST_VALUE;
    server.set_max_intset_entries = REDIS_SET_MAX_INTSET_ENTRIES;
    server.zset_max_ziplist_entries = REDIS_ZSET_MAX_ZIPLIST_ENTRIES;
    server.zset_max_ziplist_value = REDIS_ZSET_MAX_ZIPLIST_VALUE;
    server.hll_sparse_max_bytes = REDIS_DEFAULT_HLL_SPARSE_MAX_BYTES;
    server.shutdown_asap = 0;
    server.repl_ping_slave_period = REDIS_REPL_PING_SLAVE_PERIOD;
    server.repl_timeout = REDIS_REPL_TIMEOUT;
    server.repl_min_slaves_to_write = REDIS_DEFAULT_MIN_SLAVES_TO_WRITE;
    server.repl_min_slaves_max_lag = REDIS_DEFAULT_MIN_SLAVES_MAX_LAG;
    server.cluster_enabled = 0;
    server.cluster_node_timeout = REDIS_CLUSTER_DEFAULT_NODE_TIMEOUT;
    server.cluster_migration_barrier = REDIS_CLUSTER_DEFAULT_MIGRATION_BARRIER;
    server.cluster_configfile = zstrdup(REDIS_DEFAULT_CLUSTER_CONFIG_FILE);
    server.lua_caller = NULL;
    server.lua_time_limit = REDIS_LUA_TIME_LIMIT;
    server.lua_client = NULL;
    server.lua_timedout = 0;
    server.migrate_cached_sockets = dictCreate(&migrateCacheDictType,NULL);
    server.loading_process_events_interval_bytes = (1024*1024*2);

    server.lruclock = getLRUClock();//初始化LRU时间
    resetServerSaveParams();//server.saveparams=NULL;server.saveparamslen=0;
    appendServerSaveParams(60*60,1);/* save after 1 hour and 1 change */
    appendServerSaveParams(300,100);/* save after 5 minutes and 100 changes */
    appendServerSaveParams(60,10000);/* save after 1 minute and 10000 changes */

    /* Replication有关的默认值 */
    server.masterauth = NULL;
    server.masterhost = NULL;
    server.masterport = 6379;
    server.master = NULL;
    server.cached_master = NULL;
    server.repl_master_initial_offset = -1;
    server.repl_state = REDIS_REPL_NONE;
    server.repl_syncio_timeout = REDIS_REPL_SYNCIO_TIMEOUT;
    server.repl_serve_stale_data = REDIS_DEFAULT_SLAVE_SERVE_STALE_DATA;
    server.repl_slave_ro = REDIS_DEFAULT_SLAVE_READ_ONLY;
    server.repl_down_since = 0;/* Never connected, repl is down since EVER. */
    server.repl_disable_tcp_nodelay = REDIS_DEFAULT_REPL_DISABLE_TCP_NODELAY;
    server.slave_priority = REDIS_DEFAULT_SLAVE_PRIORITY;
    server.master_repl_offset = 0;

    /* 初始化 PSYNC 命令所使用的 backlog */
    server.repl_backlog = NULL;
    server.repl_backlog_size = REDIS_DEFAULT_REPL_BACKLOG_SIZE;
    server.repl_backlog_histlen = 0;
    server.repl_backlog_idx = 0;
    server.repl_backlog_off = 0;
    server.repl_backlog_time_limit = REDIS_DEFAULT_REPL_BACKLOG_TIME_LIMIT;
    server.repl_no_slaves_since = time(NULL);

    /* 设置client客户端的输出缓冲区限制 */
    for (j = 0; j < REDIS_CLIENT_LIMIT_NUM_CLASSES; j++)
        server.client_obuf_limits[j] = clientBufferLimitsDefaults[j];

    /* 初始化浮点常量 */
    R_Zero = 0.0;
    R_PosInf = 1.0/R_Zero;
    R_NegInf = -1.0/R_Zero;
    R_Nan = R_Zero/R_Zero;

    /* Command table -- we initiialize it here as it is part of the
     * initial configuration, since command names may be changed via
     * redis.conf using the rename-command directive. */
    // 初始化命令表
    // 在这里初始化是因为接下来读取 .conf 文件时可能会用到这些命令
    server.commands = dictCreate(&commandTableDictType,NULL);
    server.orig_commands = dictCreate(&commandTableDictType,NULL);
    populateCommandTable();
    server.delCommand = lookupCommandByCString("del");
    server.multiCommand = lookupCommandByCString("multi");
    server.lpushCommand = lookupCommandByCString("lpush");
    server.lpopCommand = lookupCommandByCString("lpop");
    server.rpopCommand = lookupCommandByCString("rpop");
    
    /* 慢查询相关的默认值 */
    server.slowlog_log_slower_than = REDIS_SLOWLOG_LOG_SLOWER_THAN;
    server.slowlog_max_len = REDIS_SLOWLOG_MAX_LEN;

    /* debug调试相关的默认值 */
    server.assert_failed = "";
    server.assert_file = "";
    server.assert_line = 0;
    server.bug_report_start = 0;
    server.watchdog_period = 0;
}

initServerConfig()函数,是进程启动后实际的第一个函数,它没做实际操作,只是为server结构体赋各种初始值. 初始值一般都为null,后面读取conf文件的时候,会覆盖这些初始值.

server结构体,存储了该进程几乎全部的属性.

下面把完整server结构体也贴一下:

struct redisServer {
    /* General */
    // 配置文件的绝对路径
    char *configfile;/* Absolute config file path, or NULL */
    // serverCron() 每秒调用的次数
    int hz;/* serverCron() calls frequency in hertz */
    // 数据库
    redisDb *db;
    // 命令表（受到 rename 配置选项的作用）
    dict *commands;/* Command table */
    // 命令表（无 rename 配置选项的作用）
    dict *orig_commands;/* Command table before command renaming. */
    // 事件状态
    aeEventLoop *el;
    // 最近一次使用时钟
    unsigned lruclock:REDIS_LRU_BITS;/* Clock for LRU eviction */
    // 关闭服务器的标识
    int shutdown_asap;/* SHUTDOWN needed ASAP */
    // 在执行 serverCron() 时进行渐进式 rehash
    int activerehashing;/* Incremental rehash in serverCron() */
    // 是否设置了密码
    char *requirepass;/* Pass for AUTH command, or NULL */
    // PID 文件
    char *pidfile;/* PID file path */
    // 架构类型
    int arch_bits;/* 32 or 64 depending on sizeof(long) */
    // serverCron() 函数的运行次数计数器
    int cronloops;/* Number of times the cron function run */
    // 本服务器的 RUN ID
    char runid[REDIS_RUN_ID_SIZE+1];/* ID always different at every exec. */
    // 服务器是否运行在 SENTINEL 模式
    int sentinel_mode;/* True if this instance is a Sentinel. */

    /* Networking */
    // TCP 监听端口
    int port;/* TCP listening port */
    int tcp_backlog;/* TCP listen() backlog */
    // 地址
    char *bindaddr[REDIS_BINDADDR_MAX];/* Addresses we should bind to */
    // 地址数量
    int bindaddr_count;/* Number of addresses in server.bindaddr[] */
    // UNIX 套接字
    char *unixsocket;/* UNIX socket path */
    mode_t unixsocketperm;/* UNIX socket permission */
    // 描述符
    int ipfd[REDIS_BINDADDR_MAX];/* TCP socket file descriptors */
    // 描述符数量
    int ipfd_count;/* Used slots in ipfd[] */
    // UNIX 套接字文件描述符
    int sofd;/* Unix socket file descriptor */
    int cfd[REDIS_BINDADDR_MAX];/* Cluster bus listening socket */
    int cfd_count;/* Used slots in cfd[] */
    // 一个链表，保存了所有客户端状态结构
    list *clients;/* List of active clients */
    // 链表，保存了所有待关闭的客户端
    list *clients_to_close;/* Clients to close asynchronously */
    // 链表，保存了所有从服务器，以及所有监视器
    list *slaves, *monitors;/* List of slaves and MONITORs */
    // 服务器的当前客户端，仅用于崩溃报告
    redisClient *current_client;/* Current client, only used on crash report */
    int clients_paused;/* True if clients are currently paused */
    mstime_t clients_pause_end_time;/* Time when we undo clients_paused */
    // 网络错误
    char neterr[ANET_ERR_LEN];/* Error buffer for anet.c */
    // MIGRATE 缓存
    dict *migrate_cached_sockets;/* MIGRATE cached sockets */

    /* RDB / AOF loading information */
    // 这个值为真时，表示服务器正在进行载入
    int loading;/* We are loading data from disk if true */
    // 正在载入的数据的大小
    off_t loading_total_bytes;
    // 已载入数据的大小
    off_t loading_loaded_bytes;
    // 开始进行载入的时间
    time_t loading_start_time;
    off_t loading_process_events_interval_bytes;

    /* Fast pointers to often looked up command */
    // 常用命令的快捷连接
    struct redisCommand *delCommand, *multiCommand, *lpushCommand, *lpopCommand,
                        *rpopCommand;

    /* Fields used only for stats */
    // 服务器启动时间
    time_t stat_starttime;/* Server start time */
    // 已处理命令的数量
    long long stat_numcommands;/* Number of processed commands */
    // 服务器接到的连接请求数量
    long long stat_numconnections;/* Number of connections received */
    // 已过期的键数量
    long long stat_expiredkeys;/* Number of expired keys */
    // 因为回收内存而被释放的过期键的数量
    long long stat_evictedkeys;/* Number of evicted keys (maxmemory) */
    // 成功查找键的次数
    long long stat_keyspace_hits;/* Number of successful lookups of keys */
    // 查找键失败的次数
    long long stat_keyspace_misses;/* Number of failed lookups of keys */
    // 已使用内存峰值
    size_t stat_peak_memory;/* Max used memory record */
    // 最后一次执行 fork() 时消耗的时间
    long long stat_fork_time;/* Time needed to perform latest fork() */
    // 服务器因为客户端数量过多而拒绝客户端连接的次数
    long long stat_rejected_conn;/* Clients rejected because of maxclients */
    // 执行 full sync 的次数
    long long stat_sync_full;/* Number of full resyncs with slaves. */
    // PSYNC 成功执行的次数
    long long stat_sync_partial_ok;/* Number of accepted PSYNC requests. */
    // PSYNC 执行失败的次数
    long long stat_sync_partial_err;/* Number of unaccepted PSYNC requests. */

    /* slowlog */
    // 保存了所有慢查询日志的链表
    list *slowlog;/* SLOWLOG list of commands */
    // 下一条慢查询日志的 ID
    long long slowlog_entry_id;/* SLOWLOG current entry ID */
    // 服务器配置 slowlog-log-slower-than 选项的值
    long long slowlog_log_slower_than;/* SLOWLOG time limit (to get logged) */
    // 服务器配置 slowlog-max-len 选项的值
    unsigned long slowlog_max_len;/* SLOWLOG max number of items logged */
    size_t resident_set_size;/* RSS sampled in serverCron(). */
    /* The following two are used to track instantaneous "load" in terms
     * of operations per second. */
    // 最后一次进行抽样的时间
    long long ops_sec_last_sample_time;/* Timestamp of last sample (in ms) */
    // 最后一次抽样时，服务器已执行命令的数量
    long long ops_sec_last_sample_ops;/* numcommands in last sample */
    // 抽样结果
    long long ops_sec_samples[REDIS_OPS_SEC_SAMPLES];
    // 数组索引，用于保存抽样结果，并在需要时回绕到 0
    int ops_sec_idx;

    /* Configuration */
    // 日志可见性
    int verbosity;/* Loglevel in redis.conf */
    // 客户端最大空转时间
    int maxidletime;/* Client timeout in seconds */
    // 是否开启 SO_KEEPALIVE 选项
    int tcpkeepalive;/* Set SO_KEEPALIVE if non-zero. */
    int active_expire_enabled;/* Can be disabled for testing purposes. */
    size_t client_max_querybuf_len;/* Limit for client query buffer length */
    int dbnum;/* Total number of configured DBs */
    int daemonize;/* True if running as a daemon */
    // 客户端输出缓冲区大小限制
    // 数组的元素有 REDIS_CLIENT_LIMIT_NUM_CLASSES 个
    // 每个代表一类客户端：普通、从服务器、pubsub，诸如此类
    clientBufferLimitsConfig client_obuf_limits[REDIS_CLIENT_LIMIT_NUM_CLASSES];

    /* AOF persistence */
    // AOF 状态（开启/关闭/可写）
    int aof_state;/* REDIS_AOF_(ON|OFF|WAIT_REWRITE) */
    // 所使用的 fsync 策略（每个写入/每秒/从不）
    int aof_fsync;/* Kind of fsync() policy */
    char *aof_filename;/* Name of the AOF file */
    int aof_no_fsync_on_rewrite;/* Don't fsync if a rewrite is in prog. */
    int aof_rewrite_perc;/* Rewrite AOF if % growth is > M and... */
    off_t aof_rewrite_min_size;/* the AOF file is at least N bytes. */
    // 最后一次执行 BGREWRITEAOF 时， AOF 文件的大小
    off_t aof_rewrite_base_size;/* AOF size on latest startup or rewrite. */
    // AOF 文件的当前字节大小
    off_t aof_current_size;/* AOF current size. */
    int aof_rewrite_scheduled;/* Rewrite once BGSAVE terminates. */
    // 负责进行 AOF 重写的子进程 ID
    pid_t aof_child_pid;/* PID if rewriting process */
    // AOF 重写缓存链表，链接着多个缓存块
    list *aof_rewrite_buf_blocks;/* Hold changes during an AOF rewrite. */
    // AOF 缓冲区
    sds aof_buf;/* AOF buffer, written before entering the event loop */
    // AOF 文件的描述符
    int aof_fd;/* File descriptor of currently selected AOF file */
    // AOF 的当前目标数据库
    int aof_selected_db;/* Currently selected DB in AOF */
    // 推迟 write 操作的时间
    time_t aof_flush_postponed_start;/* UNIX time of postponed AOF flush */
    // 最后一直执行 fsync 的时间
    time_t aof_last_fsync;/* UNIX time of last fsync() */
    time_t aof_rewrite_time_last;/* Time used by last AOF rewrite run. */
    // AOF 重写的开始时间
    time_t aof_rewrite_time_start;/* Current AOF rewrite start time. */
    // 最后一次执行 BGREWRITEAOF 的结果
    int aof_lastbgrewrite_status;/* REDIS_OK or REDIS_ERR */
    // 记录 AOF 的 write 操作被推迟了多少次
    unsigned long aof_delayed_fsync;/* delayed AOF fsync() counter */
    // 指示是否需要每写入一定量的数据，就主动执行一次 fsync()
    int aof_rewrite_incremental_fsync;/* fsync incrementally while rewriting? */
    int aof_last_write_status;/* REDIS_OK or REDIS_ERR */
    int aof_last_write_errno;/* Valid if aof_last_write_status is ERR */

    /* RDB persistence */
    // 自从上次 SAVE 执行以来，数据库被修改的次数
    long long dirty;/* Changes to DB from the last save */
    // BGSAVE 执行前的数据库被修改次数
    long long dirty_before_bgsave;/* Used to restore dirty on failed BGSAVE */
    // 负责执行 BGSAVE 的子进程的 ID
    // 没在执行 BGSAVE 时，设为 -1
    pid_t rdb_child_pid;/* PID of RDB saving child */
    struct saveparam *saveparams;/* Save points array for RDB */
    int saveparamslen;/* Number of saving points */
    char *rdb_filename;/* Name of RDB file */
    int rdb_compression;/* Use compression in RDB? */
    int rdb_checksum;/* Use RDB checksum? */
    // 最后一次完成 SAVE 的时间
    time_t lastsave;/* Unix time of last successful save */
    // 最后一次尝试执行 BGSAVE 的时间
    time_t lastbgsave_try;/* Unix time of last attempted bgsave */
    // 最近一次 BGSAVE 执行耗费的时间
    time_t rdb_save_time_last;/* Time used by last RDB save run. */
    // 数据库最近一次开始执行 BGSAVE 的时间
    time_t rdb_save_time_start;/* Current RDB save start time. */
    // 最后一次执行 SAVE 的状态
    int lastbgsave_status;/* REDIS_OK or REDIS_ERR */
    int stop_writes_on_bgsave_err;/* Don't allow writes if can't BGSAVE */

    /* Propagation of commands in AOF / replication */
    redisOpArray also_propagate;/* Additional command to propagate. */

    /* Logging */
    char *logfile;/* Path of log file */
    int syslog_enabled;/* Is syslog enabled? */
    char *syslog_ident;/* Syslog ident */
    int syslog_facility;/* Syslog facility */

    /* Replication (master) */
    int slaveseldb;/* Last SELECTed DB in replication output */
    // 全局复制偏移量（一个累计值）
    long long master_repl_offset;/* Global replication offset */
    // 主服务器发送 PING 的频率
    int repl_ping_slave_period;/* Master pings the slave every N seconds */
    // backlog 本身
    char *repl_backlog;/* Replication backlog for partial syncs */
    // backlog 的长度
    long long repl_backlog_size;/* Backlog circular buffer size */
    // backlog 中数据的长度
    long long repl_backlog_histlen;/* Backlog actual data length */
    // backlog 的当前索引
    long long repl_backlog_idx;/* Backlog circular buffer current offset */
    // backlog 中可以被还原的第一个字节的偏移量
    long long repl_backlog_off;/* Replication offset of first byte in thebacklog buffer. */
    // backlog 的过期时间
    time_t repl_backlog_time_limit;/* Time without slaves after the backloggets released. */
    // 距离上一次有从服务器的时间
    time_t repl_no_slaves_since;/* We have no slaves since that time.Only valid if server.slaves len is 0. */
    // 是否开启最小数量从服务器写入功能
    int repl_min_slaves_to_write;/* Min number of slaves to write. */
    // 定义最小数量从服务器的最大延迟值
    int repl_min_slaves_max_lag;/* Max lag of  slaves to write. */
    // 延迟良好的从服务器的数量
    int repl_good_slaves_count;/* Number of slaves with lag <= max_lag. */

    /* Replication (slave) */
    // 主服务器的验证密码
    char *masterauth;/* AUTH with this password with master */
    // 主服务器的地址
    char *masterhost;/* Hostname of master */
    // 主服务器的端口
    int masterport;/* Port of master */
    // 超时时间
    int repl_timeout;/* Timeout after N seconds of master idle */
    // 主服务器所对应的客户端
    redisClient *master;/* Client that is master for this slave */
    // 被缓存的主服务器，PSYNC 时使用
    redisClient *cached_master;/* Cached master to be reused for PSYNC. */
    int repl_syncio_timeout;/* Timeout for synchronous I/O calls */
    // 复制的状态（服务器是从服务器时使用）
    int repl_state;/* Replication status if the instance is a slave */
    // RDB 文件的大小
    off_t repl_transfer_size;/* Size of RDB to read from master during sync. */
    // 已读 RDB 文件内容的字节数
    off_t repl_transfer_read;/* Amount of RDB read from master during sync. */
    // 最近一次执行 fsync 时的偏移量
    // 用于 sync_file_range 函数
    off_t repl_transfer_last_fsync_off;/* Offset when we fsync-ed last time. */
    // 主服务器的套接字
    int repl_transfer_s;/* Slave -> Master SYNC socket */
    // 保存 RDB 文件的临时文件的描述符
    int repl_transfer_fd;/* Slave -> Master SYNC temp file descriptor */
    // 保存 RDB 文件的临时文件名字
    char *repl_transfer_tmpfile;/* Slave-> master SYNC temp file name */
    // 最近一次读入 RDB 内容的时间
    time_t repl_transfer_lastio;/* Unix time of the latest read, for timeout */
    int repl_serve_stale_data;/* Serve stale data when link is down? */
    // 是否只读从服务器？
    int repl_slave_ro;/* Slave is read only? */
    // 连接断开的时长
    time_t repl_down_since;/* Unix time at which link with master went down */
    // 是否要在 SYNC 之后关闭 NODELAY ？
    int repl_disable_tcp_nodelay;/* Disable TCP_NODELAY after SYNC? */
    // 从服务器优先级
    int slave_priority;/* Reported in INFO and used by Sentinel. */
    // 本服务器（从服务器）当前主服务器的 RUN ID
    char repl_master_runid[REDIS_RUN_ID_SIZE+1];/* Master run id for PSYNC. */
    // 初始化偏移量
    long long repl_master_initial_offset;/* Master PSYNC offset. */

    /* Replication script cache. */
    // 复制脚本缓存
    // 字典
    dict *repl_scriptcache_dict;/* SHA1 all slaves are aware of. */
    // FIFO 队列
    list *repl_scriptcache_fifo;/* First in, first out LRU eviction. */
    // 缓存的大小
    int repl_scriptcache_size;/* Max number of elements. */

    /* Synchronous replication. */
    list *clients_waiting_acks;/* Clients waiting in WAIT command. */
    int get_ack_from_slaves;/* If true we send REPLCONF GETACK. */

    /* Limits */
    int maxclients;/* Max number of simultaneous clients */
    unsigned long long maxmemory;/* Max number of memory bytes to use */
    int maxmemory_policy;/* Policy for key eviction */
    int maxmemory_samples;/* Pricision of random sampling */

    /* Blocked clients */
    unsigned int bpop_blocked_clients;/* Number of clients blocked by lists */
    list *unblocked_clients;/* list of clients to unblock before next loop */
    list *ready_keys;/* List of readyList structures for BLPOP & co */

    /* Sort parameters - qsort_r() is only available under BSD so we
     * have to take this state global, in order to pass it to sortCompare() */
    int sort_desc;
    int sort_alpha;
    int sort_bypattern;
    int sort_store;/* Zip structure config, see redis.conf for more information  */
    size_t hash_max_ziplist_entries;
    size_t hash_max_ziplist_value;
    size_t list_max_ziplist_entries;
    size_t list_max_ziplist_value;
    size_t set_max_intset_entries;
    size_t zset_max_ziplist_entries;
    size_t zset_max_ziplist_value;
    size_t hll_sparse_max_bytes;
    time_t unixtime;/* Unix time sampled every cron cycle. */
    long long mstime;/* Like 'unixtime' but with milliseconds resolution. */

    /* Pubsub */
    // 字典，键为频道，值为链表
    // 链表中保存了所有订阅某个频道的客户端
    // 新客户端总是被添加到链表的表尾
    dict *pubsub_channels;/* Map channels to list of subscribed clients */

    // 这个链表记录了客户端订阅的所有模式的名字
    list *pubsub_patterns;/* A list of pubsub_patterns */

    int notify_keyspace_events;/* Events to propagate via Pub/Sub. This is anxor of REDIS_NOTIFY... flags. */


    /* Cluster */
    int cluster_enabled;/* Is cluster enabled? */
    mstime_t cluster_node_timeout;/* Cluster node timeout. */
    char *cluster_configfile;/* Cluster auto-generated config file name. */
    struct clusterState *cluster;/* State of the cluster */
    int cluster_migration_barrier;/* Cluster replicas migration barrier. */

    /* Scripting */
    // Lua 环境
    lua_State *lua;/* The Lua interpreter. We use just one for all clients */
    // 复制执行 Lua 脚本中的 Redis 命令的伪客户端
    redisClient *lua_client;/* The "fake client" to query Redis from Lua */
    // 当前正在执行 EVAL 命令的客户端，如果没有就是 NULL
    redisClient *lua_caller;/* The client running EVAL right now, or NULL */
    // 一个字典，值为 Lua 脚本，键为脚本的 SHA1 校验和
    dict *lua_scripts;/* A dictionary of SHA1 -> Lua scripts */
    // Lua 脚本的执行时限
    mstime_t lua_time_limit;/* Script timeout in milliseconds */
    // 脚本开始执行的时间
    mstime_t lua_time_start;/* Start time of script, milliseconds time */
    // 脚本是否执行过写命令
    int lua_write_dirty;/* True if a write command was called during theexecution of the current script. */
    // 脚本是否执行过带有随机性质的命令
    int lua_random_dirty;/* True if a random command was called during theexecution of the current script. */
    // 脚本是否超时
    int lua_timedout;/* True if we reached the time limit for scriptexecution. */
    // 是否要杀死脚本
    int lua_kill;/* Kill the script if true. */

    /* Assert & bug reporting */
    char *assert_failed;
    char *assert_file;
    int assert_line;
    int bug_report_start;/* True if bug report header was already logged. */
    int watchdog_period;/* Software watchdog period in ms. 0 = off */
}

转载于:https://my.oschina.net/u/3474060/blog/899253