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