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