/*

* Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* * Redistributions of source code must retain the above copyright notice,

* this list of conditions and the following disclaimer.

* * Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* * Neither the name of Redis nor the names of its contributors may be used

* to endorse or promote products derived from this software without

* specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

*/

#ifndef __REDIS_H

#define __REDIS_H

#include "fmacros.h"

#include "config.h"

#if defined(__sun)

#include "solarisfixes.h"

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <limits.h>

#include <unistd.h>

#include <errno.h>

#include <inttypes.h>

#include <pthread.h>

#include <syslog.h>

#include <netinet/in.h>

#include <lua.h>

#include <signal.h>

#include "ae.h" /* Event driven programming library */

#include "sds.h" /* Dynamic safe strings */

#include "dict.h" /* Hash tables */

#include "adlist.h" /* Linked lists */

#include "zmalloc.h" /* total memory usage aware version of malloc/free */

#include "anet.h" /* Networking the easy way */

#include "ziplist.h" /* Compact list data structure */

#include "intset.h" /* Compact integer set structure */

#include "version.h" /* Version macro */

#include "util.h" /* Misc functions useful in many places */

/* Error codes */

#define REDIS_OK 0

#define REDIS_ERR -1

/* Static server configuration */

/* 默认的服务器配置值 */

#define REDIS_DEFAULT_HZ 10 /* Time interrupt calls/sec. */

#define REDIS_MIN_HZ 1

#define REDIS_MAX_HZ 500

#define REDIS_SERVERPORT 6379 /* TCP port */

#define REDIS_TCP_BACKLOG 511 /* TCP listen backlog */

#define REDIS_MAXIDLETIME 0 /* default client timeout: infinite */

#define REDIS_DEFAULT_DBNUM 16

#define REDIS_CONFIGLINE_MAX 1024

#define REDIS_DBCRON_DBS_PER_CALL 16

#define REDIS_MAX_WRITE_PER_EVENT (1024*64)

#define REDIS_SHARED_SELECT_CMDS 10

#define REDIS_SHARED_INTEGERS 10000

#define REDIS_SHARED_BULKHDR_LEN 32

#define REDIS_MAX_LOGMSG_LEN 1024 /* Default maximum length of syslog messages */

#define REDIS_AOF_REWRITE_PERC 100

#define REDIS_AOF_REWRITE_MIN_SIZE (64*1024*1024)

#define REDIS_AOF_REWRITE_ITEMS_PER_CMD 64

#define REDIS_SLOWLOG_LOG_SLOWER_THAN 10000

#define REDIS_SLOWLOG_MAX_LEN 128

#define REDIS_MAX_CLIENTS 10000

#define REDIS_AUTHPASS_MAX_LEN 512

#define REDIS_DEFAULT_SLAVE_PRIORITY 100

#define REDIS_REPL_TIMEOUT 60

#define REDIS_REPL_PING_SLAVE_PERIOD 10

#define REDIS_RUN_ID_SIZE 40

#define REDIS_OPS_SEC_SAMPLES 16

#define REDIS_DEFAULT_REPL_BACKLOG_SIZE (1024*1024) /* 1mb */

#define REDIS_DEFAULT_REPL_BACKLOG_TIME_LIMIT (60*60) /* 1 hour */

#define REDIS_REPL_BACKLOG_MIN_SIZE (1024*16) /* 16k */

#define REDIS_BGSAVE_RETRY_DELAY 5 /* Wait a few secs before trying again. */

#define REDIS_DEFAULT_PID_FILE "/var/run/redis.pid"

#define REDIS_DEFAULT_SYSLOG_IDENT "redis"

#define REDIS_DEFAULT_CLUSTER_CONFIG_FILE "nodes.conf"

#define REDIS_DEFAULT_DAEMONIZE 0

#define REDIS_DEFAULT_UNIX_SOCKET_PERM 0

#define REDIS_DEFAULT_TCP_KEEPALIVE 0

#define REDIS_DEFAULT_LOGFILE ""

#define REDIS_DEFAULT_SYSLOG_ENABLED 0

#define REDIS_DEFAULT_STOP_WRITES_ON_BGSAVE_ERROR 1

#define REDIS_DEFAULT_RDB_COMPRESSION 1

#define REDIS_DEFAULT_RDB_CHECKSUM 1

#define REDIS_DEFAULT_RDB_FILENAME "dump.rdb"

#define REDIS_DEFAULT_SLAVE_SERVE_STALE_DATA 1

#define REDIS_DEFAULT_SLAVE_READ_ONLY 1

#define REDIS_DEFAULT_REPL_DISABLE_TCP_NODELAY 0

#define REDIS_DEFAULT_MAXMEMORY 0

#define REDIS_DEFAULT_MAXMEMORY_SAMPLES 5

#define REDIS_DEFAULT_AOF_FILENAME "appendonly.aof"

#define REDIS_DEFAULT_AOF_NO_FSYNC_ON_REWRITE 0

#define REDIS_DEFAULT_ACTIVE_REHASHING 1

#define REDIS_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC 1

#define REDIS_DEFAULT_MIN_SLAVES_TO_WRITE 0

#define REDIS_DEFAULT_MIN_SLAVES_MAX_LAG 10

#define REDIS_IP_STR_LEN INET6_ADDRSTRLEN

#define REDIS_PEER_ID_LEN (REDIS_IP_STR_LEN+32) /* Must be enough for ip:port */

#define REDIS_BINDADDR_MAX 16

#define REDIS_MIN_RESERVED_FDS 32

#define ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP 20 /* Loopkups per loop. */

#define ACTIVE_EXPIRE_CYCLE_FAST_DURATION 1000 /* Microseconds */

#define ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 /* CPU max % for keys collection */

#define ACTIVE_EXPIRE_CYCLE_SLOW 0

#define ACTIVE_EXPIRE_CYCLE_FAST 1

/* Protocol and I/O related defines */

#define REDIS_MAX_QUERYBUF_LEN (1024*1024*1024) /* 1GB max query buffer. */

#define REDIS_IOBUF_LEN (1024*16) /* Generic I/O buffer size */

#define REDIS_REPLY_CHUNK_BYTES (16*1024) /* 16k output buffer */

#define REDIS_INLINE_MAX_SIZE (1024*64) /* Max size of inline reads */

#define REDIS_MBULK_BIG_ARG (1024*32)

#define REDIS_LONGSTR_SIZE 21 /* Bytes needed for long -> str */

// 指示 AOF 程序每累积这个量的写入数据

// 就执行一次显式的 fsync

#define REDIS_AOF_AUTOSYNC_BYTES (1024*1024*32) /* fdatasync every 32MB */

/* When configuring the Redis eventloop, we setup it so that the total number

* of file descriptors we can handle are server.maxclients + RESERVED_FDS + FDSET_INCR

* that is our safety margin. */

#define REDIS_EVENTLOOP_FDSET_INCR (REDIS_MIN_RESERVED_FDS+96)

/* Hash table parameters */

#define REDIS_HT_MINFILL 10 /* Minimal hash table fill 10% */

/* Command flags. Please check the command table defined in the redis.c file

* for more information about the meaning of every flag. */

// 命令标志

#define REDIS_CMD_WRITE 1 /* "w" flag */

#define REDIS_CMD_READONLY 2 /* "r" flag */

#define REDIS_CMD_DENYOOM 4 /* "m" flag */

#define REDIS_CMD_NOT_USED_1 8 /* no longer used flag */

#define REDIS_CMD_ADMIN 16 /* "a" flag */

#define REDIS_CMD_PUBSUB 32 /* "p" flag */

#define REDIS_CMD_NOSCRIPT 64 /* "s" flag */

#define REDIS_CMD_RANDOM 128 /* "R" flag */

#define REDIS_CMD_SORT_FOR_SCRIPT 256 /* "S" flag */

#define REDIS_CMD_LOADING 512 /* "l" flag */

#define REDIS_CMD_STALE 1024 /* "t" flag */

#define REDIS_CMD_SKIP_MONITOR 2048 /* "M" flag */

#define REDIS_CMD_ASKING 4096 /* "k" flag */

/* Object types */

// 对象类型

#define REDIS_STRING 0

#define REDIS_LIST 1

#define REDIS_SET 2

#define REDIS_ZSET 3

#define REDIS_HASH 4

/* Objects encoding. Some kind of objects like Strings and Hashes can be

* internally represented in multiple ways. The 'encoding' field of the object

* is set to one of this fields for this object. */

// 对象编码

#define REDIS_ENCODING_RAW 0 /* Raw representation */

#define REDIS_ENCODING_INT 1 /* Encoded as integer */

#define REDIS_ENCODING_HT 2 /* Encoded as hash table */

#define REDIS_ENCODING_ZIPMAP 3 /* Encoded as zipmap */

#define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */

#define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */

#define REDIS_ENCODING_INTSET 6 /* Encoded as intset */

#define REDIS_ENCODING_SKIPLIST 7 /* Encoded as skiplist */

#define REDIS_ENCODING_EMBSTR 8 /* Embedded sds string encoding */

/* Defines related to the dump file format. To store 32 bits lengths for short

* keys requires a lot of space, so we check the most significant 2 bits of

* the first byte to interpreter the length:

*

* 00|000000 => if the two MSB are 00 the len is the 6 bits of this byte

* 01|000000 00000000 => 01, the len is 14 byes, 6 bits + 8 bits of next byte

* 10|000000 [32 bit integer] => if it's 10, a full 32 bit len will follow

* 11|000000 this means: specially encoded object will follow. The six bits

* number specify the kind of object that follows.

* See the REDIS_RDB_ENC_* defines.

*

* Lengths up to 63 are stored using a single byte, most DB keys, and may

* values, will fit inside. */

#define REDIS_RDB_6BITLEN 0

#define REDIS_RDB_14BITLEN 1

#define REDIS_RDB_32BITLEN 2

#define REDIS_RDB_ENCVAL 3

#define REDIS_RDB_LENERR UINT_MAX

/* When a length of a string object stored on disk has the first two bits

* set, the remaining two bits specify a special encoding for the object

* accordingly to the following defines: */

#define REDIS_RDB_ENC_INT8 0 /* 8 bit signed integer */

#define REDIS_RDB_ENC_INT16 1 /* 16 bit signed integer */

#define REDIS_RDB_ENC_INT32 2 /* 32 bit signed integer */

#define REDIS_RDB_ENC_LZF 3 /* string compressed with FASTLZ */

/* AOF states */

#define REDIS_AOF_OFF 0 /* AOF is off */

#define REDIS_AOF_ON 1 /* AOF is on */

#define REDIS_AOF_WAIT_REWRITE 2 /* AOF waits rewrite to start appending */

/* Client flags */

#define REDIS_SLAVE (1<<0) /* This client is a slave server */

#define REDIS_MASTER (1<<1) /* This client is a master server */

#define REDIS_MONITOR (1<<2) /* This client is a slave monitor, see MONITOR */

#define REDIS_MULTI (1<<3) /* This client is in a MULTI context */

#define REDIS_BLOCKED (1<<4) /* The client is waiting in a blocking operation */

#define REDIS_DIRTY_CAS (1<<5) /* Watched keys modified. EXEC will fail. */

#define REDIS_CLOSE_AFTER_REPLY (1<<6) /* Close after writing entire reply. */

#define REDIS_UNBLOCKED (1<<7) /* This client was unblocked and is stored in

server.unblocked_clients */

#define REDIS_LUA_CLIENT (1<<8) /* This is a non connected client used by Lua */

#define REDIS_ASKING (1<<9) /* Client issued the ASKING command */

#define REDIS_CLOSE_ASAP (1<<10)/* Close this client ASAP */

#define REDIS_UNIX_SOCKET (1<<11) /* Client connected via Unix domain socket */

#define REDIS_DIRTY_EXEC (1<<12) /* EXEC will fail for errors while queueing */

#define REDIS_MASTER_FORCE_REPLY (1<<13) /* Queue replies even if is master */

#define REDIS_FORCE_AOF (1<<14) /* Force AOF propagation of current cmd. */

#define REDIS_FORCE_REPL (1<<15) /* Force replication of current cmd. */

#define REDIS_PRE_PSYNC (1<<16) /* Instance don't understand PSYNC. */

#define REDIS_READONLY (1<<17) /* Cluster client is in read-only state. */

/* Client block type (btype field in client structure)

* if REDIS_BLOCKED flag is set. */

#define REDIS_BLOCKED_NONE 0 /* Not blocked, no REDIS_BLOCKED flag set. */

#define REDIS_BLOCKED_LIST 1 /* BLPOP & co. */

#define REDIS_BLOCKED_WAIT 2 /* WAIT for synchronous replication. */

/* Client request types */

#define REDIS_REQ_INLINE 1

#define REDIS_REQ_MULTIBULK 2

/* Client classes for client limits, currently used only for

* the max-client-output-buffer limit implementation. */

#define REDIS_CLIENT_LIMIT_CLASS_NORMAL 0

#define REDIS_CLIENT_LIMIT_CLASS_SLAVE 1

#define REDIS_CLIENT_LIMIT_CLASS_PUBSUB 2

#define REDIS_CLIENT_LIMIT_NUM_CLASSES 3

/* Slave replication state - from the point of view of the slave. */

#define REDIS_REPL_NONE 0 /* No active replication */

#define REDIS_REPL_CONNECT 1 /* Must connect to master */

#define REDIS_REPL_CONNECTING 2 /* Connecting to master */

#define REDIS_REPL_RECEIVE_PONG 3 /* Wait for PING reply */

#define REDIS_REPL_TRANSFER 4 /* Receiving .rdb from master */

#define REDIS_REPL_CONNECTED 5 /* Connected to master */

/* Slave replication state - from the point of view of the master.

* In SEND_BULK and ONLINE state the slave receives new updates

* in its output queue. In the WAIT_BGSAVE state instead the server is waiting

* to start the next background saving in order to send updates to it. */

#define REDIS_REPL_WAIT_BGSAVE_START 6 /* We need to produce a new RDB file. */

#define REDIS_REPL_WAIT_BGSAVE_END 7 /* Waiting RDB file creation to finish. */

#define REDIS_REPL_SEND_BULK 8 /* Sending RDB file to slave. */

#define REDIS_REPL_ONLINE 9 /* RDB file transmitted, sending just updates. */

/* Synchronous read timeout - slave side */

#define REDIS_REPL_SYNCIO_TIMEOUT 5

/* List related stuff */

#define REDIS_HEAD 0

#define REDIS_TAIL 1

/* Sort operations */

#define REDIS_SORT_GET 0

#define REDIS_SORT_ASC 1

#define REDIS_SORT_DESC 2

#define REDIS_SORTKEY_MAX 1024

/* Log levels */

#define REDIS_DEBUG 0

#define REDIS_VERBOSE 1

#define REDIS_NOTICE 2

#define REDIS_WARNING 3

#define REDIS_LOG_RAW (1<<10) /* Modifier to log without timestamp */

#define REDIS_DEFAULT_VERBOSITY REDIS_NOTICE

/* Anti-warning macro... */

#define REDIS_NOTUSED(V) ((void) V)

#define ZSKIPLIST_MAXLEVEL 32 /* Should be enough for 2^32 elements */

#define ZSKIPLIST_P 0.25 /* Skiplist P = 1/4 */

/* Append only defines */

#define AOF_FSYNC_NO 0

#define AOF_FSYNC_ALWAYS 1

#define AOF_FSYNC_EVERYSEC 2

#define REDIS_DEFAULT_AOF_FSYNC AOF_FSYNC_EVERYSEC

/* Zip structure related defaults */

#define REDIS_HASH_MAX_ZIPLIST_ENTRIES 512

#define REDIS_HASH_MAX_ZIPLIST_VALUE 64

#define REDIS_LIST_MAX_ZIPLIST_ENTRIES 512

#define REDIS_LIST_MAX_ZIPLIST_VALUE 64

#define REDIS_SET_MAX_INTSET_ENTRIES 512

#define REDIS_ZSET_MAX_ZIPLIST_ENTRIES 128

#define REDIS_ZSET_MAX_ZIPLIST_VALUE 64

/* HyperLogLog defines */

#define REDIS_DEFAULT_HLL_SPARSE_MAX_BYTES 3000

/* Sets operations codes */

#define REDIS_OP_UNION 0

#define REDIS_OP_DIFF 1

#define REDIS_OP_INTER 2

/* Redis maxmemory strategies */

#define REDIS_MAXMEMORY_VOLATILE_LRU 0

#define REDIS_MAXMEMORY_VOLATILE_TTL 1

#define REDIS_MAXMEMORY_VOLATILE_RANDOM 2

#define REDIS_MAXMEMORY_ALLKEYS_LRU 3

#define REDIS_MAXMEMORY_ALLKEYS_RANDOM 4

#define REDIS_MAXMEMORY_NO_EVICTION 5

#define REDIS_DEFAULT_MAXMEMORY_POLICY REDIS_MAXMEMORY_NO_EVICTION

/* Scripting */

#define REDIS_LUA_TIME_LIMIT 5000 /* milliseconds */

/* Units */

#define UNIT_SECONDS 0

#define UNIT_MILLISECONDS 1

/* SHUTDOWN flags */

#define REDIS_SHUTDOWN_SAVE 1 /* Force SAVE on SHUTDOWN even if no save

points are configured. */

#define REDIS_SHUTDOWN_NOSAVE 2 /* Don't SAVE on SHUTDOWN. */

/* Command call flags, see call() function */

#define REDIS_CALL_NONE 0

#define REDIS_CALL_SLOWLOG 1

#define REDIS_CALL_STATS 2

#define REDIS_CALL_PROPAGATE 4

#define REDIS_CALL_FULL (REDIS_CALL_SLOWLOG | REDIS_CALL_STATS | REDIS_CALL_PROPAGATE)

/* Command propagation flags, see propagate() function */

#define REDIS_PROPAGATE_NONE 0

#define REDIS_PROPAGATE_AOF 1

#define REDIS_PROPAGATE_REPL 2

/* Keyspace changes notification classes. Every class is associated with a

* character for configuration purposes. */

#define REDIS_NOTIFY_KEYSPACE (1<<0) /* K */

#define REDIS_NOTIFY_KEYEVENT (1<<1) /* E */

#define REDIS_NOTIFY_GENERIC (1<<2) /* g */

#define REDIS_NOTIFY_STRING (1<<3) /* $ */

#define REDIS_NOTIFY_LIST (1<<4) /* l */

#define REDIS_NOTIFY_SET (1<<5) /* s */

#define REDIS_NOTIFY_HASH (1<<6) /* h */

#define REDIS_NOTIFY_ZSET (1<<7) /* z */

#define REDIS_NOTIFY_EXPIRED (1<<8) /* x */

#define REDIS_NOTIFY_EVICTED (1<<9) /* e */

#define REDIS_NOTIFY_ALL (REDIS_NOTIFY_GENERIC | REDIS_NOTIFY_STRING | REDIS_NOTIFY_LIST | REDIS_NOTIFY_SET | REDIS_NOTIFY_HASH | REDIS_NOTIFY_ZSET | REDIS_NOTIFY_EXPIRED | REDIS_NOTIFY_EVICTED) /* A */

/* Using the following macro you can run code inside serverCron() with the

* specified period, specified in milliseconds.

* The actual resolution depends on server.hz. */

#define run_with_period(_ms_) if ((_ms_ <= 1000/server.hz) || !(server.cronloops%((_ms_)/(1000/server.hz))))

/* We can print the stacktrace, so our assert is defined this way: */

#define redisAssertWithInfo(_c,_o,_e) ((_e)?(void)0 : (_redisAssertWithInfo(_c,_o,#_e,__FILE__,__LINE__),_exit(1)))

#define redisAssert(_e) ((_e)?(void)0 : (_redisAssert(#_e,__FILE__,__LINE__),_exit(1)))

#define redisPanic(_e) _redisPanic(#_e,__FILE__,__LINE__),_exit(1)

/*-----------------------------------------------------------------------------

* Data types

*----------------------------------------------------------------------------*/

typedef long long mstime_t; /* millisecond time type. */

/* A redis object, that is a type able to hold a string / list / set */

/* The actual Redis Object */

/*

* Redis 对象

*/

#define REDIS_LRU_BITS 24

#define REDIS_LRU_CLOCK_MAX ((1<<REDIS_LRU_BITS)-1) /* Max value of obj->lru */

#define REDIS_LRU_CLOCK_RESOLUTION 1000 /* LRU clock resolution in ms */

typedef struct redisObject {

} robj;

/* Macro used to obtain the current LRU clock.

* If the current resolution is lower than the frequency we refresh the

* LRU clock (as it should be in production servers) we return the

* precomputed value, otherwise we need to resort to a function call. */

#define LRU_CLOCK() ((1000/server.hz <= REDIS_LRU_CLOCK_RESOLUTION) ? server.lruclock : getLRUClock())

/* Macro used to initialize a Redis object allocated on the stack.

* Note that this macro is taken near the structure definition to make sure

* we'll update it when the structure is changed, to avoid bugs like

* bug #85 introduced exactly in this way. */

#define initStaticStringObject(_var,_ptr) do { \

_var.refcount = 1; \

_var.type = REDIS_STRING; \

_var.encoding = REDIS_ENCODING_RAW; \

_var.ptr = _ptr; \

} while(0);

/* To improve the quality of the LRU approximation we take a set of keys

* that are good candidate for eviction across freeMemoryIfNeeded() calls.

*

* Entries inside the eviciton pool are taken ordered by idle time, putting

* greater idle times to the right (ascending order).

*

* Empty entries have the key pointer set to NULL. */

#define REDIS_EVICTION_POOL_SIZE 16

struct evictionPoolEntry {

unsigned long long idle; /* Object idle time. */

sds key; /* Key name. */

};

/* Redis database representation. There are multiple databases identified

* by integers from 0 (the default database) up to the max configured

* database. The database number is the 'id' field in the structure. */

typedef struct redisDb {

} redisDb;

/* Client MULTI/EXEC state */

/*

* 事务命令

*/

typedef struct multiCmd {

} multiCmd;

/*

* 事务状态

*/

typedef struct multiState {

} multiState;

/* This structure holds the blocking operation state for a client.

* The fields used depend on client->btype. */

// 阻塞状态

typedef struct blockingState {

} blockingState;

/* The following structure represents a node in the server.ready_keys list,

* where we accumulate all the keys that had clients blocked with a blocking

* operation such as B[LR]POP, but received new data in the context of the

* last executed command.

*

* After the execution of every command or script, we run this list to check

* if as a result we should serve data to clients blocked, unblocking them.

* Note that server.ready_keys will not have duplicates as there dictionary

* also called ready_keys in every structure representing a Redis database,

* where we make sure to remember if a given key was already added in the

* server.ready_keys list. */

// 记录解除了客户端的阻塞状态的键，以及键所在的数据库。

typedef struct readyList {

redisDb *db;

robj *key;

} readyList;

/* With multiplexing we need to take per-client state.

* Clients are taken in a liked list.

*

* 因为 I/O 复用的缘故，需要为每个客户端维持一个状态。

*

* 多个客户端状态被服务器用链表连接起来。

*/

typedef struct redisClient {

} redisClient;

// 服务器的保存条件（BGSAVE 自动执行的条件）

struct saveparam {

};

// 通过复用来减少内存碎片，以及减少操作耗时的共享对象

struct sharedObjectsStruct {

};

/* ZSETs use a specialized version of Skiplists */

/*

* 跳跃表节点

*/

typedef struct zskiplistNode {

} zskiplistNode;

/*

* 跳跃表

*/

typedef struct zskiplist {

} zskiplist;

/*

* 有序集合

*/

typedef struct zset {

} zset;

// 客户端缓冲区限制

typedef struct clientBufferLimitsConfig {

} clientBufferLimitsConfig;

// 限制可以有多个

extern clientBufferLimitsConfig clientBufferLimitsDefaults[REDIS_CLIENT_LIMIT_NUM_CLASSES];

/* The redisOp structure defines a Redis Operation, that is an instance of

* a command with an argument vector, database ID, propagation target

* (REDIS_PROPAGATE_*), and command pointer.

*

* redisOp 结构定义了一个 Redis 操作，

* 它包含指向被执行命令的指针、命令的参数、数据库 ID 、传播目标（REDIS_PROPAGATE_*）。

*

* Currently only used to additionally propagate more commands to AOF/Replication

* after the propagation of the executed command.

*

* 目前只用于在传播被执行命令之后，传播附加的其他命令到 AOF 或 Replication 中。

*/

typedef struct redisOp {

} redisOp;

/* Defines an array of Redis operations. There is an API to add to this

* structure in a easy way.

*

* redisOpArrayInit();

* redisOpArrayAppend();

* redisOpArrayFree();

*/

typedef struct redisOpArray {

redisOp *ops;

int numops;

} redisOpArray;

/*-----------------------------------------------------------------------------

* Global server state

*----------------------------------------------------------------------------*/

struct clusterState;

struct redisServer {