src/redis.h

   1 #ifndef __REDIS_H
   2 #define __REDIS_H
   3
   4 #include "fmacros.h"
   5 #include "config.h"
   6
   7 #if defined(__sun)
   8 #include "solarisfixes.h"
   9 #endif
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <time.h>
  15 #include <limits.h>
  16 #include <unistd.h>
  17 #include <errno.h>
  18 #include <inttypes.h>
  19 #include <pthread.h>
  20
  21 #include "ae.h"     /* Event driven programming library */
  22 #include "sds.h"    /* Dynamic safe strings */
  23 #include "dict.h"   /* Hash tables */
  24 #include "adlist.h" /* Linked lists */
  25 #include "zmalloc.h" /* total memory usage aware version of malloc/free */
  26 #include "anet.h"   /* Networking the easy way */
  27 #include "zipmap.h" /* Compact string -> string data structure */
  28 #include "ziplist.h" /* Compact list data structure */
  29 #include "intset.h" /* Compact integer set structure */
  30 #include "version.h"
  31
  32 /* Error codes */
  33 #define REDIS_OK                0
  34 #define REDIS_ERR               -1
  35
  36 /* Static server configuration */
  37 #define REDIS_SERVERPORT        6379    /* TCP port */
  38 #define REDIS_MAXIDLETIME       (60*5)  /* default client timeout */
  39 #define REDIS_IOBUF_LEN         1024
  40 #define REDIS_LOADBUF_LEN       1024
  41 #define REDIS_STATIC_ARGS       8
  42 #define REDIS_DEFAULT_DBNUM     16
  43 #define REDIS_CONFIGLINE_MAX    1024
  44 #define REDIS_OBJFREELIST_MAX   1000000 /* Max number of objects to cache */
  45 #define REDIS_MAX_SYNC_TIME     60      /* Slave can't take more to sync */
  46 #define REDIS_EXPIRELOOKUPS_PER_CRON    10 /* lookup 10 expires per loop */
  47 #define REDIS_MAX_WRITE_PER_EVENT (1024*64)
  48 #define REDIS_REQUEST_MAX_SIZE (1024*1024*256) /* max bytes in inline command */
  49 #define REDIS_SHARED_INTEGERS 10000
  50 #define REDIS_REPLY_CHUNK_BYTES (5*1500) /* 5 TCP packets with default MTU */
  51
  52 /* If more then REDIS_WRITEV_THRESHOLD write packets are pending use writev */
  53 #define REDIS_WRITEV_THRESHOLD      3
  54 /* Max number of iovecs used for each writev call */
  55 #define REDIS_WRITEV_IOVEC_COUNT    256
  56
  57 /* Hash table parameters */
  58 #define REDIS_HT_MINFILL        10      /* Minimal hash table fill 10% */
  59
  60 /* Command flags */
  61 #define REDIS_CMD_BULK          1       /* Bulk write command */
  62 #define REDIS_CMD_INLINE        2       /* Inline command */
  63 /* REDIS_CMD_DENYOOM reserves a longer comment: all the commands marked with
  64    this flags will return an error when the 'maxmemory' option is set in the
  65    config file and the server is using more than maxmemory bytes of memory.
  66    In short this commands are denied on low memory conditions. */
  67 #define REDIS_CMD_DENYOOM       4
  68 #define REDIS_CMD_FORCE_REPLICATION 8 /* Force replication even if dirty is 0 */
  69
  70 /* Object types */
  71 #define REDIS_STRING 0
  72 #define REDIS_LIST 1
  73 #define REDIS_SET 2
  74 #define REDIS_ZSET 3
  75 #define REDIS_HASH 4
  76 #define REDIS_VMPOINTER 8
  77
  78 /* Objects encoding. Some kind of objects like Strings and Hashes can be
  79  * internally represented in multiple ways. The 'encoding' field of the object
  80  * is set to one of this fields for this object. */
  81 #define REDIS_ENCODING_RAW 0     /* Raw representation */
  82 #define REDIS_ENCODING_INT 1     /* Encoded as integer */
  83 #define REDIS_ENCODING_HT 2      /* Encoded as hash table */
  84 #define REDIS_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
  85 #define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
  86 #define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
  87 #define REDIS_ENCODING_INTSET 6  /* Encoded as intset */
  88
  89 /* Object types only used for dumping to disk */
  90 #define REDIS_EXPIRETIME 253
  91 #define REDIS_SELECTDB 254
  92 #define REDIS_EOF 255
  93
  94 /* Defines related to the dump file format. To store 32 bits lengths for short
  95  * keys requires a lot of space, so we check the most significant 2 bits of
  96  * the first byte to interpreter the length:
  97  *
  98  * 00|000000 => if the two MSB are 00 the len is the 6 bits of this byte
  99  * 01|000000 00000000 =>  01, the len is 14 byes, 6 bits + 8 bits of next byte
 100  * 10|000000 [32 bit integer] => if it's 01, a full 32 bit len will follow
 101  * 11|000000 this means: specially encoded object will follow. The six bits
 102  *           number specify the kind of object that follows.
 103  *           See the REDIS_RDB_ENC_* defines.
 104  *
 105  * Lenghts up to 63 are stored using a single byte, most DB keys, and may
 106  * values, will fit inside. */
 107 #define REDIS_RDB_6BITLEN 0
 108 #define REDIS_RDB_14BITLEN 1
 109 #define REDIS_RDB_32BITLEN 2
 110 #define REDIS_RDB_ENCVAL 3
 111 #define REDIS_RDB_LENERR UINT_MAX
 112
 113 /* When a length of a string object stored on disk has the first two bits
 114  * set, the remaining two bits specify a special encoding for the object
 115  * accordingly to the following defines: */
 116 #define REDIS_RDB_ENC_INT8 0        /* 8 bit signed integer */
 117 #define REDIS_RDB_ENC_INT16 1       /* 16 bit signed integer */
 118 #define REDIS_RDB_ENC_INT32 2       /* 32 bit signed integer */
 119 #define REDIS_RDB_ENC_LZF 3         /* string compressed with FASTLZ */
 120
 121 /* Virtual memory object->where field. */
 122 #define REDIS_VM_MEMORY 0       /* The object is on memory */
 123 #define REDIS_VM_SWAPPED 1      /* The object is on disk */
 124 #define REDIS_VM_SWAPPING 2     /* Redis is swapping this object on disk */
 125 #define REDIS_VM_LOADING 3      /* Redis is loading this object from disk */
 126
 127 /* Virtual memory static configuration stuff.
 128  * Check vmFindContiguousPages() to know more about this magic numbers. */
 129 #define REDIS_VM_MAX_NEAR_PAGES 65536
 130 #define REDIS_VM_MAX_RANDOM_JUMP 4096
 131 #define REDIS_VM_MAX_THREADS 32
 132 #define REDIS_THREAD_STACK_SIZE (1024*1024*4)
 133 /* The following is the *percentage* of completed I/O jobs to process when the
 134  * handelr is called. While Virtual Memory I/O operations are performed by
 135  * threads, this operations must be processed by the main thread when completed
 136  * in order to take effect. */
 137 #define REDIS_MAX_COMPLETED_JOBS_PROCESSED 1
 138
 139 /* Client flags */
 140 #define REDIS_SLAVE 1       /* This client is a slave server */
 141 #define REDIS_MASTER 2      /* This client is a master server */
 142 #define REDIS_MONITOR 4     /* This client is a slave monitor, see MONITOR */
 143 #define REDIS_MULTI 8       /* This client is in a MULTI context */
 144 #define REDIS_BLOCKED 16    /* The client is waiting in a blocking operation */
 145 #define REDIS_IO_WAIT 32    /* The client is waiting for Virtual Memory I/O */
 146 #define REDIS_DIRTY_CAS 64  /* Watched keys modified. EXEC will fail. */
 147
 148 /* Slave replication state - slave side */
 149 #define REDIS_REPL_NONE 0   /* No active replication */
 150 #define REDIS_REPL_CONNECT 1    /* Must connect to master */
 151 #define REDIS_REPL_CONNECTED 2  /* Connected to master */
 152
 153 /* Slave replication state - from the point of view of master
 154  * Note that in SEND_BULK and ONLINE state the slave receives new updates
 155  * in its output queue. In the WAIT_BGSAVE state instead the server is waiting
 156  * to start the next background saving in order to send updates to it. */
 157 #define REDIS_REPL_WAIT_BGSAVE_START 3 /* master waits bgsave to start feeding it */
 158 #define REDIS_REPL_WAIT_BGSAVE_END 4 /* master waits bgsave to start bulk DB transmission */
 159 #define REDIS_REPL_SEND_BULK 5 /* master is sending the bulk DB */
 160 #define REDIS_REPL_ONLINE 6 /* bulk DB already transmitted, receive updates */
 161
 162 /* List related stuff */
 163 #define REDIS_HEAD 0
 164 #define REDIS_TAIL 1
 165
 166 /* Sort operations */
 167 #define REDIS_SORT_GET 0
 168 #define REDIS_SORT_ASC 1
 169 #define REDIS_SORT_DESC 2
 170 #define REDIS_SORTKEY_MAX 1024
 171
 172 /* Log levels */
 173 #define REDIS_DEBUG 0
 174 #define REDIS_VERBOSE 1
 175 #define REDIS_NOTICE 2
 176 #define REDIS_WARNING 3
 177
 178 /* Anti-warning macro... */
 179 #define REDIS_NOTUSED(V) ((void) V)
 180
 181 #define ZSKIPLIST_MAXLEVEL 32 /* Should be enough for 2^32 elements */
 182 #define ZSKIPLIST_P 0.25      /* Skiplist P = 1/4 */
 183
 184 /* Append only defines */
 185 #define APPENDFSYNC_NO 0
 186 #define APPENDFSYNC_ALWAYS 1
 187 #define APPENDFSYNC_EVERYSEC 2
 188
 189 /* Zip structure related defaults */
 190 #define REDIS_HASH_MAX_ZIPMAP_ENTRIES 64
 191 #define REDIS_HASH_MAX_ZIPMAP_VALUE 512
 192 #define REDIS_LIST_MAX_ZIPLIST_ENTRIES 1024
 193 #define REDIS_LIST_MAX_ZIPLIST_VALUE 32
 194 #define REDIS_SET_MAX_INTSET_ENTRIES 4096
 195
 196 /* Sets operations codes */
 197 #define REDIS_OP_UNION 0
 198 #define REDIS_OP_DIFF 1
 199 #define REDIS_OP_INTER 2
 200
 201 /* We can print the stacktrace, so our assert is defined this way: */
 202 #define redisAssert(_e) ((_e)?(void)0 : (_redisAssert(#_e,__FILE__,__LINE__),_exit(1)))
 203 #define redisPanic(_e) _redisPanic(#_e,__FILE__,__LINE__),_exit(1)
 204 void _redisAssert(char *estr, char *file, int line);
 205 void _redisPanic(char *msg, char *file, int line);
 206
 207 /*-----------------------------------------------------------------------------
 208  * Data types
 209  *----------------------------------------------------------------------------*/
 210
 211 /* A redis object, that is a type able to hold a string / list / set */
 212
 213 /* The actual Redis Object */
 214 typedef struct redisObject {
 215     unsigned type:4;
 216     unsigned storage:2;     /* REDIS_VM_MEMORY or REDIS_VM_SWAPPING */
 217     unsigned encoding:4;
 218     unsigned lru:22;        /* lru time (relative to server.lruclock) */
 219     int refcount;
 220     void *ptr;
 221     /* VM fields are only allocated if VM is active, otherwise the
 222      * object allocation function will just allocate
 223      * sizeof(redisObjct) minus sizeof(redisObjectVM), so using
 224      * Redis without VM active will not have any overhead. */
 225 } robj;
 226
 227 /* The VM pointer structure - identifies an object in the swap file.
 228  *
 229  * This object is stored in place of the value
 230  * object in the main key->value hash table representing a database.
 231  * Note that the first fields (type, storage) are the same as the redisObject
 232  * structure so that vmPointer strucuters can be accessed even when casted
 233  * as redisObject structures.
 234  *
 235  * This is useful as we don't know if a value object is or not on disk, but we
 236  * are always able to read obj->storage to check this. For vmPointer
 237  * structures "type" is set to REDIS_VMPOINTER (even if without this field
 238  * is still possible to check the kind of object from the value of 'storage').*/
 239 typedef struct vmPointer {
 240     unsigned type:4;
 241     unsigned storage:2; /* REDIS_VM_SWAPPED or REDIS_VM_LOADING */
 242     unsigned notused:26;
 243     unsigned int vtype; /* type of the object stored in the swap file */
 244     off_t page;         /* the page at witch the object is stored on disk */
 245     off_t usedpages;    /* number of pages used on disk */
 246 } vmpointer;
 247
 248 /* Macro used to initalize a Redis object allocated on the stack.
 249  * Note that this macro is taken near the structure definition to make sure
 250  * we'll update it when the structure is changed, to avoid bugs like
 251  * bug #85 introduced exactly in this way. */
 252 #define initStaticStringObject(_var,_ptr) do { \
 253     _var.refcount = 1; \
 254     _var.type = REDIS_STRING; \
 255     _var.encoding = REDIS_ENCODING_RAW; \
 256     _var.ptr = _ptr; \
 257     _var.storage = REDIS_VM_MEMORY; \
 258 } while(0);
 259
 260 typedef struct redisDb {
 261     dict *dict;                 /* The keyspace for this DB */
 262     dict *expires;              /* Timeout of keys with a timeout set */
 263     dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP) */
 264     dict *io_keys;              /* Keys with clients waiting for VM I/O */
 265     dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
 266     int id;
 267 } redisDb;
 268
 269 /* Client MULTI/EXEC state */
 270 typedef struct multiCmd {
 271     robj **argv;
 272     int argc;
 273     struct redisCommand *cmd;
 274 } multiCmd;
 275
 276 typedef struct multiState {
 277     multiCmd *commands;     /* Array of MULTI commands */
 278     int count;              /* Total number of MULTI commands */
 279 } multiState;
 280
 281 /* With multiplexing we need to take per-clinet state.
 282  * Clients are taken in a liked list. */
 283 typedef struct redisClient {
 284     int fd;
 285     redisDb *db;
 286     int dictid;
 287     sds querybuf;
 288     robj **argv, **mbargv;
 289     int argc, mbargc;
 290     long bulklen;            /* bulk read len. -1 if not in bulk read mode */
 291     int multibulk;          /* multi bulk command format active */
 292     list *reply;
 293     int sentlen;
 294     time_t lastinteraction; /* time of the last interaction, used for timeout */
 295     int flags;              /* REDIS_SLAVE | REDIS_MONITOR | REDIS_MULTI ... */
 296     int slaveseldb;         /* slave selected db, if this client is a slave */
 297     int authenticated;      /* when requirepass is non-NULL */
 298     int replstate;          /* replication state if this is a slave */
 299     int repldbfd;           /* replication DB file descriptor */
 300     long repldboff;         /* replication DB file offset */
 301     off_t repldbsize;       /* replication DB file size */
 302     multiState mstate;      /* MULTI/EXEC state */
 303     robj **blocking_keys;   /* The key we are waiting to terminate a blocking
 304                              * operation such as BLPOP. Otherwise NULL. */
 305     int blocking_keys_num;  /* Number of blocking keys */
 306     time_t blockingto;      /* Blocking operation timeout. If UNIX current time
 307                              * is >= blockingto then the operation timed out. */
 308     list *io_keys;          /* Keys this client is waiting to be loaded from the
 309                              * swap file in order to continue. */
 310     list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */
 311     dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */
 312     list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */
 313
 314     /* Response buffer */
 315     int bufpos;
 316     char buf[REDIS_REPLY_CHUNK_BYTES];
 317 } redisClient;
 318
 319 struct saveparam {
 320     time_t seconds;
 321     int changes;
 322 };
 323
 324 struct sharedObjectsStruct {
 325     robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *cnegone, *pong, *space,
 326     *colon, *nullbulk, *nullmultibulk, *queued,
 327     *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
 328     *outofrangeerr, *plus,
 329     *select0, *select1, *select2, *select3, *select4,
 330     *select5, *select6, *select7, *select8, *select9,
 331     *messagebulk, *pmessagebulk, *subscribebulk, *unsubscribebulk, *mbulk3,
 332     *mbulk4, *psubscribebulk, *punsubscribebulk,
 333     *integers[REDIS_SHARED_INTEGERS];
 334 };
 335
 336 /* Global server state structure */
 337 struct redisServer {
 338     pthread_t mainthread;
 339     int port;
 340     int fd;
 341     redisDb *db;
 342     long long dirty;            /* changes to DB from the last save */
 343     long long dirty_before_bgsave; /* used to restore dirty on failed BGSAVE */
 344     list *clients;
 345     list *slaves, *monitors;
 346     char neterr[ANET_ERR_LEN];
 347     aeEventLoop *el;
 348     int cronloops;              /* number of times the cron function run */
 349     list *objfreelist;          /* A list of freed objects to avoid malloc() */
 350     time_t lastsave;            /* Unix time of last save succeeede */
 351     /* Fields used only for stats */
 352     time_t stat_starttime;         /* server start time */
 353     long long stat_numcommands;    /* number of processed commands */
 354     long long stat_numconnections; /* number of connections received */
 355     long long stat_expiredkeys;   /* number of expired keys */
 356     /* Configuration */
 357     int verbosity;
 358     int glueoutputbuf;
 359     int maxidletime;
 360     int dbnum;
 361     int daemonize;
 362     int appendonly;
 363     int appendfsync;
 364     int no_appendfsync_on_rewrite;
 365     int shutdown_asap;
 366     time_t lastfsync;
 367     int appendfd;
 368     int appendseldb;
 369     char *pidfile;
 370     pid_t bgsavechildpid;
 371     pid_t bgrewritechildpid;
 372     sds bgrewritebuf; /* buffer taken by parent during oppend only rewrite */
 373     sds aofbuf;       /* AOF buffer, written before entering the event loop */
 374     struct saveparam *saveparams;
 375     int saveparamslen;
 376     char *logfile;
 377     char *bindaddr;
 378     char *dbfilename;
 379     char *appendfilename;
 380     char *requirepass;
 381     int rdbcompression;
 382     int activerehashing;
 383     /* Replication related */
 384     int isslave;
 385     char *masterauth;
 386     char *masterhost;
 387     int masterport;
 388     redisClient *master;    /* client that is master for this slave */
 389     int replstate;
 390     unsigned int maxclients;
 391     unsigned long long maxmemory;
 392     unsigned int blpop_blocked_clients;
 393     unsigned int vm_blocked_clients;
 394     /* Sort parameters - qsort_r() is only available under BSD so we
 395      * have to take this state global, in order to pass it to sortCompare() */
 396     int sort_desc;
 397     int sort_alpha;
 398     int sort_bypattern;
 399     /* Virtual memory configuration */
 400     int vm_enabled;
 401     char *vm_swap_file;
 402     off_t vm_page_size;
 403     off_t vm_pages;
 404     unsigned long long vm_max_memory;
 405     /* Zip structure config */
 406     size_t hash_max_zipmap_entries;
 407     size_t hash_max_zipmap_value;
 408     size_t list_max_ziplist_entries;
 409     size_t list_max_ziplist_value;
 410     size_t set_max_intset_entries;
 411     /* Virtual memory state */
 412     FILE *vm_fp;
 413     int vm_fd;
 414     off_t vm_next_page; /* Next probably empty page */
 415     off_t vm_near_pages; /* Number of pages allocated sequentially */
 416     unsigned char *vm_bitmap; /* Bitmap of free/used pages */
 417     time_t unixtime;    /* Unix time sampled every second. */
 418     /* Virtual memory I/O threads stuff */
 419     /* An I/O thread process an element taken from the io_jobs queue and
 420      * put the result of the operation in the io_done list. While the
 421      * job is being processed, it's put on io_processing queue. */
 422     list *io_newjobs; /* List of VM I/O jobs yet to be processed */
 423     list *io_processing; /* List of VM I/O jobs being processed */
 424     list *io_processed; /* List of VM I/O jobs already processed */
 425     list *io_ready_clients; /* Clients ready to be unblocked. All keys loaded */
 426     pthread_mutex_t io_mutex; /* lock to access io_jobs/io_done/io_thread_job */
 427     pthread_mutex_t obj_freelist_mutex; /* safe redis objects creation/free */
 428     pthread_mutex_t io_swapfile_mutex; /* So we can lseek + write */
 429     pthread_attr_t io_threads_attr; /* attributes for threads creation */
 430     int io_active_threads; /* Number of running I/O threads */
 431     int vm_max_threads; /* Max number of I/O threads running at the same time */
 432     /* Our main thread is blocked on the event loop, locking for sockets ready
 433      * to be read or written, so when a threaded I/O operation is ready to be
 434      * processed by the main thread, the I/O thread will use a unix pipe to
 435      * awake the main thread. The followings are the two pipe FDs. */
 436     int io_ready_pipe_read;
 437     int io_ready_pipe_write;
 438     /* Virtual memory stats */
 439     unsigned long long vm_stats_used_pages;
 440     unsigned long long vm_stats_swapped_objects;
 441     unsigned long long vm_stats_swapouts;
 442     unsigned long long vm_stats_swapins;
 443     /* Pubsub */
 444     dict *pubsub_channels; /* Map channels to list of subscribed clients */
 445     list *pubsub_patterns; /* A list of pubsub_patterns */
 446     /* Misc */
 447     FILE *devnull;
 448     unsigned lruclock:22;        /* clock incrementing every minute, for LRU */
 449     unsigned lruclock_padding:10;
 450 };
 451
 452 typedef struct pubsubPattern {
 453     redisClient *client;
 454     robj *pattern;
 455 } pubsubPattern;
 456
 457 typedef void redisCommandProc(redisClient *c);
 458 typedef void redisVmPreloadProc(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
 459 struct redisCommand {
 460     char *name;
 461     redisCommandProc *proc;
 462     int arity;
 463     int flags;
 464     /* Use a function to determine which keys need to be loaded
 465      * in the background prior to executing this command. Takes precedence
 466      * over vm_firstkey and others, ignored when NULL */
 467     redisVmPreloadProc *vm_preload_proc;
 468     /* What keys should be loaded in background when calling this command? */
 469     int vm_firstkey; /* The first argument that's a key (0 = no keys) */
 470     int vm_lastkey;  /* THe last argument that's a key */
 471     int vm_keystep;  /* The step between first and last key */
 472 };
 473
 474 struct redisFunctionSym {
 475     char *name;
 476     unsigned long pointer;
 477 };
 478
 479 typedef struct _redisSortObject {
 480     robj *obj;
 481     union {
 482         double score;
 483         robj *cmpobj;
 484     } u;
 485 } redisSortObject;
 486
 487 typedef struct _redisSortOperation {
 488     int type;
 489     robj *pattern;
 490 } redisSortOperation;
 491
 492 /* ZSETs use a specialized version of Skiplists */
 493
 494 typedef struct zskiplistNode {
 495     struct zskiplistNode **forward;
 496     struct zskiplistNode *backward;
 497     unsigned int *span;
 498     double score;
 499     robj *obj;
 500 } zskiplistNode;
 501
 502 typedef struct zskiplist {
 503     struct zskiplistNode *header, *tail;
 504     unsigned long length;
 505     int level;
 506 } zskiplist;
 507
 508 typedef struct zset {
 509     dict *dict;
 510     zskiplist *zsl;
 511 } zset;
 512
 513 /* VM threaded I/O request message */
 514 #define REDIS_IOJOB_LOAD 0          /* Load from disk to memory */
 515 #define REDIS_IOJOB_PREPARE_SWAP 1  /* Compute needed pages */
 516 #define REDIS_IOJOB_DO_SWAP 2       /* Swap from memory to disk */
 517 typedef struct iojob {
 518     int type;   /* Request type, REDIS_IOJOB_* */
 519     redisDb *db;/* Redis database */
 520     robj *key;  /* This I/O request is about swapping this key */
 521     robj *id;   /* Unique identifier of this job:
 522                    this is the object to swap for REDIS_IOREQ_*_SWAP, or the
 523                    vmpointer objct for REDIS_IOREQ_LOAD. */
 524     robj *val;  /* the value to swap for REDIS_IOREQ_*_SWAP, otherwise this
 525                  * field is populated by the I/O thread for REDIS_IOREQ_LOAD. */
 526     off_t page; /* Swap page where to read/write the object */
 527     off_t pages; /* Swap pages needed to save object. PREPARE_SWAP return val */
 528     int canceled; /* True if this command was canceled by blocking side of VM */
 529     pthread_t thread; /* ID of the thread processing this entry */
 530 } iojob;
 531
 532 /* Structure to hold list iteration abstraction. */
 533 typedef struct {
 534     robj *subject;
 535     unsigned char encoding;
 536     unsigned char direction; /* Iteration direction */
 537     unsigned char *zi;
 538     listNode *ln;
 539 } listTypeIterator;
 540
 541 /* Structure for an entry while iterating over a list. */
 542 typedef struct {
 543     listTypeIterator *li;
 544     unsigned char *zi;  /* Entry in ziplist */
 545     listNode *ln;       /* Entry in linked list */
 546 } listTypeEntry;
 547
 548 /* Structure to hold set iteration abstraction. */
 549 typedef struct {
 550     robj *subject;
 551     int encoding;
 552     int ii; /* intset iterator */
 553     dictIterator *di;
 554 } setTypeIterator;
 555
 556 /* Structure to hold hash iteration abstration. Note that iteration over
 557  * hashes involves both fields and values. Because it is possible that
 558  * not both are required, store pointers in the iterator to avoid
 559  * unnecessary memory allocation for fields/values. */
 560 typedef struct {
 561     int encoding;
 562     unsigned char *zi;
 563     unsigned char *zk, *zv;
 564     unsigned int zklen, zvlen;
 565
 566     dictIterator *di;
 567     dictEntry *de;
 568 } hashTypeIterator;
 569
 570 #define REDIS_HASH_KEY 1
 571 #define REDIS_HASH_VALUE 2
 572
 573 /*-----------------------------------------------------------------------------
 574  * Extern declarations
 575  *----------------------------------------------------------------------------*/
 576
 577 extern struct redisServer server;
 578 extern struct sharedObjectsStruct shared;
 579 extern dictType setDictType;
 580 extern dictType zsetDictType;
 581 extern double R_Zero, R_PosInf, R_NegInf, R_Nan;
 582 dictType hashDictType;
 583
 584 /*-----------------------------------------------------------------------------
 585  * Functions prototypes
 586  *----------------------------------------------------------------------------*/
 587
 588 /* networking.c -- Networking and Client related operations */
 589 redisClient *createClient(int fd);
 590 void closeTimedoutClients(void);
 591 void freeClient(redisClient *c);
 592 void resetClient(redisClient *c);
 593 void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask);
 594 void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask);
 595 void addReply(redisClient *c, robj *obj);
 596 void *addDeferredMultiBulkLength(redisClient *c);
 597 void setDeferredMultiBulkLength(redisClient *c, void *node, long length);
 598 void addReplySds(redisClient *c, sds s);
 599 void processInputBuffer(redisClient *c);
 600 void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 601 void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask);
 602 void addReplyBulk(redisClient *c, robj *obj);
 603 void addReplyBulkCString(redisClient *c, char *s);
 604 void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 605 void addReply(redisClient *c, robj *obj);
 606 void addReplySds(redisClient *c, sds s);
 607 void addReplyError(redisClient *c, char *err);
 608 void addReplyStatus(redisClient *c, char *status);
 609 void addReplyDouble(redisClient *c, double d);
 610 void addReplyLongLong(redisClient *c, long long ll);
 611 void addReplyMultiBulkLen(redisClient *c, long length);
 612 void *dupClientReplyValue(void *o);
 613
 614 #ifdef __GNUC__
 615 void addReplyErrorFormat(redisClient *c, const char *fmt, ...)
 616     __attribute__((format(printf, 2, 3)));
 617 void addReplyStatusFormat(redisClient *c, const char *fmt, ...)
 618     __attribute__((format(printf, 2, 3)));
 619 #else
 620 void addReplyErrorFormat(redisClient *c, const char *fmt, ...);
 621 void addReplyStatusFormat(redisClient *c, const char *fmt, ...);
 622 #endif
 623
 624 /* List data type */
 625 void listTypeTryConversion(robj *subject, robj *value);
 626 void listTypePush(robj *subject, robj *value, int where);
 627 robj *listTypePop(robj *subject, int where);
 628 unsigned long listTypeLength(robj *subject);
 629 listTypeIterator *listTypeInitIterator(robj *subject, int index, unsigned char direction);
 630 void listTypeReleaseIterator(listTypeIterator *li);
 631 int listTypeNext(listTypeIterator *li, listTypeEntry *entry);
 632 robj *listTypeGet(listTypeEntry *entry);
 633 void listTypeInsert(listTypeEntry *entry, robj *value, int where);
 634 int listTypeEqual(listTypeEntry *entry, robj *o);
 635 void listTypeDelete(listTypeEntry *entry);
 636 void listTypeConvert(robj *subject, int enc);
 637 void unblockClientWaitingData(redisClient *c);
 638 int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele);
 639 void popGenericCommand(redisClient *c, int where);
 640
 641 /* MULTI/EXEC/WATCH... */
 642 void unwatchAllKeys(redisClient *c);
 643 void initClientMultiState(redisClient *c);
 644 void freeClientMultiState(redisClient *c);
 645 void queueMultiCommand(redisClient *c, struct redisCommand *cmd);
 646 void touchWatchedKey(redisDb *db, robj *key);
 647 void touchWatchedKeysOnFlush(int dbid);
 648
 649 /* Redis object implementation */
 650 void decrRefCount(void *o);
 651 void incrRefCount(robj *o);
 652 void freeStringObject(robj *o);
 653 void freeListObject(robj *o);
 654 void freeSetObject(robj *o);
 655 void freeZsetObject(robj *o);
 656 void freeHashObject(robj *o);
 657 robj *createObject(int type, void *ptr);
 658 robj *createStringObject(char *ptr, size_t len);
 659 robj *dupStringObject(robj *o);
 660 robj *tryObjectEncoding(robj *o);
 661 robj *getDecodedObject(robj *o);
 662 size_t stringObjectLen(robj *o);
 663 int tryFreeOneObjectFromFreelist(void);
 664 robj *createStringObjectFromLongLong(long long value);
 665 robj *createListObject(void);
 666 robj *createZiplistObject(void);
 667 robj *createSetObject(void);
 668 robj *createIntsetObject(void);
 669 robj *createHashObject(void);
 670 robj *createZsetObject(void);
 671 int getLongFromObjectOrReply(redisClient *c, robj *o, long *target, const char *msg);
 672 int checkType(redisClient *c, robj *o, int type);
 673 int getLongLongFromObjectOrReply(redisClient *c, robj *o, long long *target, const char *msg);
 674 int getDoubleFromObjectOrReply(redisClient *c, robj *o, double *target, const char *msg);
 675 int getLongLongFromObject(robj *o, long long *target);
 676 char *strEncoding(int encoding);
 677 int compareStringObjects(robj *a, robj *b);
 678 int equalStringObjects(robj *a, robj *b);
 679
 680 /* Replication */
 681 void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc);
 682 void replicationFeedMonitors(list *monitors, int dictid, robj **argv, int argc);
 683 int syncWithMaster(void);
 684 void updateSlavesWaitingBgsave(int bgsaveerr);
 685
 686 /* RDB persistence */
 687 int rdbLoad(char *filename);
 688 int rdbSaveBackground(char *filename);
 689 void rdbRemoveTempFile(pid_t childpid);
 690 int rdbSave(char *filename);
 691 int rdbSaveObject(FILE *fp, robj *o);
 692 off_t rdbSavedObjectPages(robj *o, FILE *fp);
 693 off_t rdbSavedObjectLen(robj *o, FILE *fp);
 694 robj *rdbLoadObject(int type, FILE *fp);
 695 void backgroundSaveDoneHandler(int statloc);
 696
 697 /* AOF persistence */
 698 void flushAppendOnlyFile(void);
 699 void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc);
 700 void aofRemoveTempFile(pid_t childpid);
 701 int rewriteAppendOnlyFileBackground(void);
 702 int loadAppendOnlyFile(char *filename);
 703 void stopAppendOnly(void);
 704 int startAppendOnly(void);
 705 void backgroundRewriteDoneHandler(int statloc);
 706
 707 /* Sorted sets data type */
 708 zskiplist *zslCreate(void);
 709 void zslFree(zskiplist *zsl);
 710 void zslInsert(zskiplist *zsl, double score, robj *obj);
 711
 712 /* Core functions */
 713 void freeMemoryIfNeeded(void);
 714 int processCommand(redisClient *c);
 715 void setupSigSegvAction(void);
 716 struct redisCommand *lookupCommand(char *name);
 717 void call(redisClient *c, struct redisCommand *cmd);
 718 int prepareForShutdown();
 719 void redisLog(int level, const char *fmt, ...);
 720 void usage();
 721 void updateDictResizePolicy(void);
 722 int htNeedsResize(dict *dict);
 723 void oom(const char *msg);
 724
 725 /* Virtual Memory */
 726 void vmInit(void);
 727 void vmMarkPagesFree(off_t page, off_t count);
 728 robj *vmLoadObject(robj *o);
 729 robj *vmPreviewObject(robj *o);
 730 int vmSwapOneObjectBlocking(void);
 731 int vmSwapOneObjectThreaded(void);
 732 int vmCanSwapOut(void);
 733 void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata, int mask);
 734 void vmCancelThreadedIOJob(robj *o);
 735 void lockThreadedIO(void);
 736 void unlockThreadedIO(void);
 737 int vmSwapObjectThreaded(robj *key, robj *val, redisDb *db);
 738 void freeIOJob(iojob *j);
 739 void queueIOJob(iojob *j);
 740 int vmWriteObjectOnSwap(robj *o, off_t page);
 741 robj *vmReadObjectFromSwap(off_t page, int type);
 742 void waitEmptyIOJobsQueue(void);
 743 void vmReopenSwapFile(void);
 744 int vmFreePage(off_t page);
 745 void zunionInterBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
 746 void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
 747 int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd);
 748 int dontWaitForSwappedKey(redisClient *c, robj *key);
 749 void handleClientsBlockedOnSwappedKey(redisDb *db, robj *key);
 750 vmpointer *vmSwapObjectBlocking(robj *val);
 751
 752 /* Set data type */
 753 robj *setTypeCreate(robj *value);
 754 int setTypeAdd(robj *subject, robj *value);
 755 int setTypeRemove(robj *subject, robj *value);
 756 int setTypeIsMember(robj *subject, robj *value);
 757 setTypeIterator *setTypeInitIterator(robj *subject);
 758 void setTypeReleaseIterator(setTypeIterator *si);
 759 robj *setTypeNext(setTypeIterator *si);
 760 robj *setTypeRandomElement(robj *subject);
 761 unsigned long setTypeSize(robj *subject);
 762 void setTypeConvert(robj *subject, int enc);
 763
 764 /* Hash data type */
 765 void convertToRealHash(robj *o);
 766 void hashTypeTryConversion(robj *subject, robj **argv, int start, int end);
 767 void hashTypeTryObjectEncoding(robj *subject, robj **o1, robj **o2);
 768 robj *hashTypeGet(robj *o, robj *key);
 769 int hashTypeExists(robj *o, robj *key);
 770 int hashTypeSet(robj *o, robj *key, robj *value);
 771 int hashTypeDelete(robj *o, robj *key);
 772 unsigned long hashTypeLength(robj *o);
 773 hashTypeIterator *hashTypeInitIterator(robj *subject);
 774 void hashTypeReleaseIterator(hashTypeIterator *hi);
 775 int hashTypeNext(hashTypeIterator *hi);
 776 robj *hashTypeCurrent(hashTypeIterator *hi, int what);
 777 robj *hashTypeLookupWriteOrCreate(redisClient *c, robj *key);
 778
 779 /* Pub / Sub */
 780 int pubsubUnsubscribeAllChannels(redisClient *c, int notify);
 781 int pubsubUnsubscribeAllPatterns(redisClient *c, int notify);
 782 void freePubsubPattern(void *p);
 783 int listMatchPubsubPattern(void *a, void *b);
 784
 785 /* Utility functions */
 786 int stringmatchlen(const char *pattern, int patternLen,
 787         const char *string, int stringLen, int nocase);
 788 int stringmatch(const char *pattern, const char *string, int nocase);
 789 long long memtoll(const char *p, int *err);
 790 int ll2string(char *s, size_t len, long long value);
 791 int isStringRepresentableAsLong(sds s, long *longval);
 792 int isStringRepresentableAsLongLong(sds s, long long *longval);
 793 int isObjectRepresentableAsLongLong(robj *o, long long *llongval);
 794
 795 /* Configuration */
 796 void loadServerConfig(char *filename);
 797 void appendServerSaveParams(time_t seconds, int changes);
 798 void resetServerSaveParams();
 799
 800 /* db.c -- Keyspace access API */
 801 int removeExpire(redisDb *db, robj *key);
 802 void propagateExpire(redisDb *db, robj *key);
 803 int expireIfNeeded(redisDb *db, robj *key);
 804 time_t getExpire(redisDb *db, robj *key);
 805 void setExpire(redisDb *db, robj *key, time_t when);
 806 robj *lookupKey(redisDb *db, robj *key);
 807 robj *lookupKeyRead(redisDb *db, robj *key);
 808 robj *lookupKeyWrite(redisDb *db, robj *key);
 809 robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply);
 810 robj *lookupKeyWriteOrReply(redisClient *c, robj *key, robj *reply);
 811 int dbAdd(redisDb *db, robj *key, robj *val);
 812 int dbReplace(redisDb *db, robj *key, robj *val);
 813 int dbExists(redisDb *db, robj *key);
 814 robj *dbRandomKey(redisDb *db);
 815 int dbDelete(redisDb *db, robj *key);
 816 long long emptyDb();
 817 int selectDb(redisClient *c, int id);
 818
 819 /* Git SHA1 */
 820 char *redisGitSHA1(void);
 821 char *redisGitDirty(void);
 822
 823 /* Commands prototypes */
 824 void authCommand(redisClient *c);
 825 void pingCommand(redisClient *c);
 826 void echoCommand(redisClient *c);
 827 void setCommand(redisClient *c);
 828 void setnxCommand(redisClient *c);
 829 void setexCommand(redisClient *c);
 830 void getCommand(redisClient *c);
 831 void delCommand(redisClient *c);
 832 void existsCommand(redisClient *c);
 833 void incrCommand(redisClient *c);
 834 void decrCommand(redisClient *c);
 835 void incrbyCommand(redisClient *c);
 836 void decrbyCommand(redisClient *c);
 837 void selectCommand(redisClient *c);
 838 void randomkeyCommand(redisClient *c);
 839 void keysCommand(redisClient *c);
 840 void dbsizeCommand(redisClient *c);
 841 void lastsaveCommand(redisClient *c);
 842 void saveCommand(redisClient *c);
 843 void bgsaveCommand(redisClient *c);
 844 void bgrewriteaofCommand(redisClient *c);
 845 void shutdownCommand(redisClient *c);
 846 void moveCommand(redisClient *c);
 847 void renameCommand(redisClient *c);
 848 void renamenxCommand(redisClient *c);
 849 void lpushCommand(redisClient *c);
 850 void rpushCommand(redisClient *c);
 851 void lpushxCommand(redisClient *c);
 852 void rpushxCommand(redisClient *c);
 853 void linsertCommand(redisClient *c);
 854 void lpopCommand(redisClient *c);
 855 void rpopCommand(redisClient *c);
 856 void llenCommand(redisClient *c);
 857 void lindexCommand(redisClient *c);
 858 void lrangeCommand(redisClient *c);
 859 void ltrimCommand(redisClient *c);
 860 void typeCommand(redisClient *c);
 861 void lsetCommand(redisClient *c);
 862 void saddCommand(redisClient *c);
 863 void sremCommand(redisClient *c);
 864 void smoveCommand(redisClient *c);
 865 void sismemberCommand(redisClient *c);
 866 void scardCommand(redisClient *c);
 867 void spopCommand(redisClient *c);
 868 void srandmemberCommand(redisClient *c);
 869 void sinterCommand(redisClient *c);
 870 void sinterstoreCommand(redisClient *c);
 871 void sunionCommand(redisClient *c);
 872 void sunionstoreCommand(redisClient *c);
 873 void sdiffCommand(redisClient *c);
 874 void sdiffstoreCommand(redisClient *c);
 875 void syncCommand(redisClient *c);
 876 void flushdbCommand(redisClient *c);
 877 void flushallCommand(redisClient *c);
 878 void sortCommand(redisClient *c);
 879 void lremCommand(redisClient *c);
 880 void rpoplpushcommand(redisClient *c);
 881 void infoCommand(redisClient *c);
 882 void mgetCommand(redisClient *c);
 883 void monitorCommand(redisClient *c);
 884 void expireCommand(redisClient *c);
 885 void expireatCommand(redisClient *c);
 886 void getsetCommand(redisClient *c);
 887 void ttlCommand(redisClient *c);
 888 void persistCommand(redisClient *c);
 889 void slaveofCommand(redisClient *c);
 890 void debugCommand(redisClient *c);
 891 void msetCommand(redisClient *c);
 892 void msetnxCommand(redisClient *c);
 893 void zaddCommand(redisClient *c);
 894 void zincrbyCommand(redisClient *c);
 895 void zrangeCommand(redisClient *c);
 896 void zrangebyscoreCommand(redisClient *c);
 897 void zcountCommand(redisClient *c);
 898 void zrevrangeCommand(redisClient *c);
 899 void zcardCommand(redisClient *c);
 900 void zremCommand(redisClient *c);
 901 void zscoreCommand(redisClient *c);
 902 void zremrangebyscoreCommand(redisClient *c);
 903 void multiCommand(redisClient *c);
 904 void execCommand(redisClient *c);
 905 void discardCommand(redisClient *c);
 906 void blpopCommand(redisClient *c);
 907 void brpopCommand(redisClient *c);
 908 void appendCommand(redisClient *c);
 909 void substrCommand(redisClient *c);
 910 void strlenCommand(redisClient *c);
 911 void zrankCommand(redisClient *c);
 912 void zrevrankCommand(redisClient *c);
 913 void hsetCommand(redisClient *c);
 914 void hsetnxCommand(redisClient *c);
 915 void hgetCommand(redisClient *c);
 916 void hmsetCommand(redisClient *c);
 917 void hmgetCommand(redisClient *c);
 918 void hdelCommand(redisClient *c);
 919 void hlenCommand(redisClient *c);
 920 void zremrangebyrankCommand(redisClient *c);
 921 void zunionstoreCommand(redisClient *c);
 922 void zinterstoreCommand(redisClient *c);
 923 void hkeysCommand(redisClient *c);
 924 void hvalsCommand(redisClient *c);
 925 void hgetallCommand(redisClient *c);
 926 void hexistsCommand(redisClient *c);
 927 void configCommand(redisClient *c);
 928 void hincrbyCommand(redisClient *c);
 929 void subscribeCommand(redisClient *c);
 930 void unsubscribeCommand(redisClient *c);
 931 void psubscribeCommand(redisClient *c);
 932 void punsubscribeCommand(redisClient *c);
 933 void publishCommand(redisClient *c);
 934 void watchCommand(redisClient *c);
 935 void unwatchCommand(redisClient *c);
 936
 937 #if defined(__GNUC__)
 938 void *calloc(size_t count, size_t size) __attribute__ ((deprecated));
 939 void free(void *ptr) __attribute__ ((deprecated));
 940 void *malloc(size_t size) __attribute__ ((deprecated));
 941 void *realloc(void *ptr, size_t size) __attribute__ ((deprecated));
 942 #endif
 943
 944 #endif