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     char *newline;          /* pointing to the detected newline in querybuf */
 290     int argc, mbargc;
 291     long bulklen;            /* bulk read len. -1 if not in bulk read mode */
 292     int multibulk;          /* multi bulk command format active */
 293     list *reply;
 294     int sentlen;
 295     time_t lastinteraction; /* time of the last interaction, used for timeout */
 296     int flags;              /* REDIS_SLAVE | REDIS_MONITOR | REDIS_MULTI ... */
 297     int slaveseldb;         /* slave selected db, if this client is a slave */
 298     int authenticated;      /* when requirepass is non-NULL */
 299     int replstate;          /* replication state if this is a slave */
 300     int repldbfd;           /* replication DB file descriptor */
 301     long repldboff;         /* replication DB file offset */
 302     off_t repldbsize;       /* replication DB file size */
 303     multiState mstate;      /* MULTI/EXEC state */
 304     robj **blocking_keys;   /* The key we are waiting to terminate a blocking
 305                              * operation such as BLPOP. Otherwise NULL. */
 306     int blocking_keys_num;  /* Number of blocking keys */
 307     time_t blockingto;      /* Blocking operation timeout. If UNIX current time
 308                              * is >= blockingto then the operation timed out. */
 309     list *io_keys;          /* Keys this client is waiting to be loaded from the
 310                              * swap file in order to continue. */
 311     list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */
 312     dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */
 313     list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */
 314
 315     /* Response buffer */
 316     int bufpos;
 317     char buf[REDIS_REPLY_CHUNK_BYTES];
 318 } redisClient;
 319
 320 struct saveparam {
 321     time_t seconds;
 322     int changes;
 323 };
 324
 325 struct sharedObjectsStruct {
 326     robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *cnegone, *pong, *space,
 327     *colon, *nullbulk, *nullmultibulk, *queued,
 328     *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
 329     *outofrangeerr, *plus,
 330     *select0, *select1, *select2, *select3, *select4,
 331     *select5, *select6, *select7, *select8, *select9,
 332     *messagebulk, *pmessagebulk, *subscribebulk, *unsubscribebulk, *mbulk3,
 333     *mbulk4, *psubscribebulk, *punsubscribebulk,
 334     *integers[REDIS_SHARED_INTEGERS];
 335 };
 336
 337 /* Global server state structure */
 338 struct redisServer {
 339     pthread_t mainthread;
 340     int port;
 341     int fd;
 342     redisDb *db;
 343     long long dirty;            /* changes to DB from the last save */
 344     long long dirty_before_bgsave; /* used to restore dirty on failed BGSAVE */
 345     list *clients;
 346     list *slaves, *monitors;
 347     char neterr[ANET_ERR_LEN];
 348     aeEventLoop *el;
 349     int cronloops;              /* number of times the cron function run */
 350     list *objfreelist;          /* A list of freed objects to avoid malloc() */
 351     time_t lastsave;            /* Unix time of last save succeeede */
 352     /* Fields used only for stats */
 353     time_t stat_starttime;         /* server start time */
 354     long long stat_numcommands;    /* number of processed commands */
 355     long long stat_numconnections; /* number of connections received */
 356     long long stat_expiredkeys;   /* number of expired keys */
 357     /* Configuration */
 358     int verbosity;
 359     int glueoutputbuf;
 360     int maxidletime;
 361     int dbnum;
 362     int daemonize;
 363     int appendonly;
 364     int appendfsync;
 365     int no_appendfsync_on_rewrite;
 366     int shutdown_asap;
 367     time_t lastfsync;
 368     int appendfd;
 369     int appendseldb;
 370     char *pidfile;
 371     pid_t bgsavechildpid;
 372     pid_t bgrewritechildpid;
 373     sds bgrewritebuf; /* buffer taken by parent during oppend only rewrite */
 374     sds aofbuf;       /* AOF buffer, written before entering the event loop */
 375     struct saveparam *saveparams;
 376     int saveparamslen;
 377     char *logfile;
 378     char *bindaddr;
 379     char *dbfilename;
 380     char *appendfilename;
 381     char *requirepass;
 382     int rdbcompression;
 383     int activerehashing;
 384     /* Replication related */
 385     int isslave;
 386     char *masterauth;
 387     char *masterhost;
 388     int masterport;
 389     redisClient *master;    /* client that is master for this slave */
 390     int replstate;
 391     unsigned int maxclients;
 392     unsigned long long maxmemory;
 393     unsigned int blpop_blocked_clients;
 394     unsigned int vm_blocked_clients;
 395     /* Sort parameters - qsort_r() is only available under BSD so we
 396      * have to take this state global, in order to pass it to sortCompare() */
 397     int sort_desc;
 398     int sort_alpha;
 399     int sort_bypattern;
 400     /* Virtual memory configuration */
 401     int vm_enabled;
 402     char *vm_swap_file;
 403     off_t vm_page_size;
 404     off_t vm_pages;
 405     unsigned long long vm_max_memory;
 406     /* Zip structure config */
 407     size_t hash_max_zipmap_entries;
 408     size_t hash_max_zipmap_value;
 409     size_t list_max_ziplist_entries;
 410     size_t list_max_ziplist_value;
 411     size_t set_max_intset_entries;
 412     /* Virtual memory state */
 413     FILE *vm_fp;
 414     int vm_fd;
 415     off_t vm_next_page; /* Next probably empty page */
 416     off_t vm_near_pages; /* Number of pages allocated sequentially */
 417     unsigned char *vm_bitmap; /* Bitmap of free/used pages */
 418     time_t unixtime;    /* Unix time sampled every second. */
 419     /* Virtual memory I/O threads stuff */
 420     /* An I/O thread process an element taken from the io_jobs queue and
 421      * put the result of the operation in the io_done list. While the
 422      * job is being processed, it's put on io_processing queue. */
 423     list *io_newjobs; /* List of VM I/O jobs yet to be processed */
 424     list *io_processing; /* List of VM I/O jobs being processed */
 425     list *io_processed; /* List of VM I/O jobs already processed */
 426     list *io_ready_clients; /* Clients ready to be unblocked. All keys loaded */
 427     pthread_mutex_t io_mutex; /* lock to access io_jobs/io_done/io_thread_job */
 428     pthread_mutex_t obj_freelist_mutex; /* safe redis objects creation/free */
 429     pthread_mutex_t io_swapfile_mutex; /* So we can lseek + write */
 430     pthread_attr_t io_threads_attr; /* attributes for threads creation */
 431     int io_active_threads; /* Number of running I/O threads */
 432     int vm_max_threads; /* Max number of I/O threads running at the same time */
 433     /* Our main thread is blocked on the event loop, locking for sockets ready
 434      * to be read or written, so when a threaded I/O operation is ready to be
 435      * processed by the main thread, the I/O thread will use a unix pipe to
 436      * awake the main thread. The followings are the two pipe FDs. */
 437     int io_ready_pipe_read;
 438     int io_ready_pipe_write;
 439     /* Virtual memory stats */
 440     unsigned long long vm_stats_used_pages;
 441     unsigned long long vm_stats_swapped_objects;
 442     unsigned long long vm_stats_swapouts;
 443     unsigned long long vm_stats_swapins;
 444     /* Pubsub */
 445     dict *pubsub_channels; /* Map channels to list of subscribed clients */
 446     list *pubsub_patterns; /* A list of pubsub_patterns */
 447     /* Misc */
 448     FILE *devnull;
 449     unsigned lruclock:22;        /* clock incrementing every minute, for LRU */
 450     unsigned lruclock_padding:10;
 451 };
 452
 453 typedef struct pubsubPattern {
 454     redisClient *client;
 455     robj *pattern;
 456 } pubsubPattern;
 457
 458 typedef void redisCommandProc(redisClient *c);
 459 typedef void redisVmPreloadProc(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
 460 struct redisCommand {
 461     char *name;
 462     redisCommandProc *proc;
 463     int arity;
 464     int flags;
 465     /* Use a function to determine which keys need to be loaded
 466      * in the background prior to executing this command. Takes precedence
 467      * over vm_firstkey and others, ignored when NULL */
 468     redisVmPreloadProc *vm_preload_proc;
 469     /* What keys should be loaded in background when calling this command? */
 470     int vm_firstkey; /* The first argument that's a key (0 = no keys) */
 471     int vm_lastkey;  /* THe last argument that's a key */
 472     int vm_keystep;  /* The step between first and last key */
 473 };
 474
 475 struct redisFunctionSym {
 476     char *name;
 477     unsigned long pointer;
 478 };
 479
 480 typedef struct _redisSortObject {
 481     robj *obj;
 482     union {
 483         double score;
 484         robj *cmpobj;
 485     } u;
 486 } redisSortObject;
 487
 488 typedef struct _redisSortOperation {
 489     int type;
 490     robj *pattern;
 491 } redisSortOperation;
 492
 493 /* ZSETs use a specialized version of Skiplists */
 494 typedef struct zskiplistNode {
 495     robj *obj;
 496     double score;
 497     struct zskiplistNode *backward;
 498     struct zskiplistLevel {
 499         struct zskiplistNode *forward;
 500         unsigned int span;
 501     } level[];
 502 } zskiplistNode;
 503
 504 typedef struct zskiplist {
 505     struct zskiplistNode *header, *tail;
 506     unsigned long length;
 507     int level;
 508 } zskiplist;
 509
 510 typedef struct zset {
 511     dict *dict;
 512     zskiplist *zsl;
 513 } zset;
 514
 515 /* VM threaded I/O request message */
 516 #define REDIS_IOJOB_LOAD 0          /* Load from disk to memory */
 517 #define REDIS_IOJOB_PREPARE_SWAP 1  /* Compute needed pages */
 518 #define REDIS_IOJOB_DO_SWAP 2       /* Swap from memory to disk */
 519 typedef struct iojob {
 520     int type;   /* Request type, REDIS_IOJOB_* */
 521     redisDb *db;/* Redis database */
 522     robj *key;  /* This I/O request is about swapping this key */
 523     robj *id;   /* Unique identifier of this job:
 524                    this is the object to swap for REDIS_IOREQ_*_SWAP, or the
 525                    vmpointer objct for REDIS_IOREQ_LOAD. */
 526     robj *val;  /* the value to swap for REDIS_IOREQ_*_SWAP, otherwise this
 527                  * field is populated by the I/O thread for REDIS_IOREQ_LOAD. */
 528     off_t page; /* Swap page where to read/write the object */
 529     off_t pages; /* Swap pages needed to save object. PREPARE_SWAP return val */
 530     int canceled; /* True if this command was canceled by blocking side of VM */
 531     pthread_t thread; /* ID of the thread processing this entry */
 532 } iojob;
 533
 534 /* Structure to hold list iteration abstraction. */
 535 typedef struct {
 536     robj *subject;
 537     unsigned char encoding;
 538     unsigned char direction; /* Iteration direction */
 539     unsigned char *zi;
 540     listNode *ln;
 541 } listTypeIterator;
 542
 543 /* Structure for an entry while iterating over a list. */
 544 typedef struct {
 545     listTypeIterator *li;
 546     unsigned char *zi;  /* Entry in ziplist */
 547     listNode *ln;       /* Entry in linked list */
 548 } listTypeEntry;
 549
 550 /* Structure to hold set iteration abstraction. */
 551 typedef struct {
 552     robj *subject;
 553     int encoding;
 554     int ii; /* intset iterator */
 555     dictIterator *di;
 556 } setTypeIterator;
 557
 558 /* Structure to hold hash iteration abstration. Note that iteration over
 559  * hashes involves both fields and values. Because it is possible that
 560  * not both are required, store pointers in the iterator to avoid
 561  * unnecessary memory allocation for fields/values. */
 562 typedef struct {
 563     int encoding;
 564     unsigned char *zi;
 565     unsigned char *zk, *zv;
 566     unsigned int zklen, zvlen;
 567
 568     dictIterator *di;
 569     dictEntry *de;
 570 } hashTypeIterator;
 571
 572 #define REDIS_HASH_KEY 1
 573 #define REDIS_HASH_VALUE 2
 574
 575 /*-----------------------------------------------------------------------------
 576  * Extern declarations
 577  *----------------------------------------------------------------------------*/
 578
 579 extern struct redisServer server;
 580 extern struct sharedObjectsStruct shared;
 581 extern dictType setDictType;
 582 extern dictType zsetDictType;
 583 extern double R_Zero, R_PosInf, R_NegInf, R_Nan;
 584 dictType hashDictType;
 585
 586 /*-----------------------------------------------------------------------------
 587  * Functions prototypes
 588  *----------------------------------------------------------------------------*/
 589
 590 /* networking.c -- Networking and Client related operations */
 591 redisClient *createClient(int fd);
 592 void closeTimedoutClients(void);
 593 void freeClient(redisClient *c);
 594 void resetClient(redisClient *c);
 595 void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask);
 596 void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask);
 597 void addReply(redisClient *c, robj *obj);
 598 void *addDeferredMultiBulkLength(redisClient *c);
 599 void setDeferredMultiBulkLength(redisClient *c, void *node, long length);
 600 void addReplySds(redisClient *c, sds s);
 601 void processInputBuffer(redisClient *c);
 602 void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 603 void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask);
 604 void addReplyBulk(redisClient *c, robj *obj);
 605 void addReplyBulkCString(redisClient *c, char *s);
 606 void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 607 void addReply(redisClient *c, robj *obj);
 608 void addReplySds(redisClient *c, sds s);
 609 void addReplyError(redisClient *c, char *err);
 610 void addReplyStatus(redisClient *c, char *status);
 611 void addReplyDouble(redisClient *c, double d);
 612 void addReplyLongLong(redisClient *c, long long ll);
 613 void addReplyMultiBulkLen(redisClient *c, long length);
 614 void *dupClientReplyValue(void *o);
 615
 616 #ifdef __GNUC__
 617 void addReplyErrorFormat(redisClient *c, const char *fmt, ...)
 618     __attribute__((format(printf, 2, 3)));
 619 void addReplyStatusFormat(redisClient *c, const char *fmt, ...)
 620     __attribute__((format(printf, 2, 3)));
 621 #else
 622 void addReplyErrorFormat(redisClient *c, const char *fmt, ...);
 623 void addReplyStatusFormat(redisClient *c, const char *fmt, ...);
 624 #endif
 625
 626 /* List data type */
 627 void listTypeTryConversion(robj *subject, robj *value);
 628 void listTypePush(robj *subject, robj *value, int where);
 629 robj *listTypePop(robj *subject, int where);
 630 unsigned long listTypeLength(robj *subject);
 631 listTypeIterator *listTypeInitIterator(robj *subject, int index, unsigned char direction);
 632 void listTypeReleaseIterator(listTypeIterator *li);
 633 int listTypeNext(listTypeIterator *li, listTypeEntry *entry);
 634 robj *listTypeGet(listTypeEntry *entry);
 635 void listTypeInsert(listTypeEntry *entry, robj *value, int where);
 636 int listTypeEqual(listTypeEntry *entry, robj *o);
 637 void listTypeDelete(listTypeEntry *entry);
 638 void listTypeConvert(robj *subject, int enc);
 639 void unblockClientWaitingData(redisClient *c);
 640 int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele);
 641 void popGenericCommand(redisClient *c, int where);
 642
 643 /* MULTI/EXEC/WATCH... */
 644 void unwatchAllKeys(redisClient *c);
 645 void initClientMultiState(redisClient *c);
 646 void freeClientMultiState(redisClient *c);
 647 void queueMultiCommand(redisClient *c, struct redisCommand *cmd);
 648 void touchWatchedKey(redisDb *db, robj *key);
 649 void touchWatchedKeysOnFlush(int dbid);
 650
 651 /* Redis object implementation */
 652 void decrRefCount(void *o);
 653 void incrRefCount(robj *o);
 654 void freeStringObject(robj *o);
 655 void freeListObject(robj *o);
 656 void freeSetObject(robj *o);
 657 void freeZsetObject(robj *o);
 658 void freeHashObject(robj *o);
 659 robj *createObject(int type, void *ptr);
 660 robj *createStringObject(char *ptr, size_t len);
 661 robj *dupStringObject(robj *o);
 662 robj *tryObjectEncoding(robj *o);
 663 robj *getDecodedObject(robj *o);
 664 size_t stringObjectLen(robj *o);
 665 int tryFreeOneObjectFromFreelist(void);
 666 robj *createStringObjectFromLongLong(long long value);
 667 robj *createListObject(void);
 668 robj *createZiplistObject(void);
 669 robj *createSetObject(void);
 670 robj *createIntsetObject(void);
 671 robj *createHashObject(void);
 672 robj *createZsetObject(void);
 673 int getLongFromObjectOrReply(redisClient *c, robj *o, long *target, const char *msg);
 674 int checkType(redisClient *c, robj *o, int type);
 675 int getLongLongFromObjectOrReply(redisClient *c, robj *o, long long *target, const char *msg);
 676 int getDoubleFromObjectOrReply(redisClient *c, robj *o, double *target, const char *msg);
 677 int getLongLongFromObject(robj *o, long long *target);
 678 char *strEncoding(int encoding);
 679 int compareStringObjects(robj *a, robj *b);
 680 int equalStringObjects(robj *a, robj *b);
 681
 682 /* Replication */
 683 void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc);
 684 void replicationFeedMonitors(list *monitors, int dictid, robj **argv, int argc);
 685 int syncWithMaster(void);
 686 void updateSlavesWaitingBgsave(int bgsaveerr);
 687
 688 /* RDB persistence */
 689 int rdbLoad(char *filename);
 690 int rdbSaveBackground(char *filename);
 691 void rdbRemoveTempFile(pid_t childpid);
 692 int rdbSave(char *filename);
 693 int rdbSaveObject(FILE *fp, robj *o);
 694 off_t rdbSavedObjectPages(robj *o, FILE *fp);
 695 off_t rdbSavedObjectLen(robj *o, FILE *fp);
 696 robj *rdbLoadObject(int type, FILE *fp);
 697 void backgroundSaveDoneHandler(int statloc);
 698
 699 /* AOF persistence */
 700 void flushAppendOnlyFile(void);
 701 void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc);
 702 void aofRemoveTempFile(pid_t childpid);
 703 int rewriteAppendOnlyFileBackground(void);
 704 int loadAppendOnlyFile(char *filename);
 705 void stopAppendOnly(void);
 706 int startAppendOnly(void);
 707 void backgroundRewriteDoneHandler(int statloc);
 708
 709 /* Sorted sets data type */
 710 zskiplist *zslCreate(void);
 711 void zslFree(zskiplist *zsl);
 712 zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj);
 713
 714 /* Core functions */
 715 void freeMemoryIfNeeded(void);
 716 int processCommand(redisClient *c);
 717 void setupSigSegvAction(void);
 718 struct redisCommand *lookupCommand(char *name);
 719 void call(redisClient *c, struct redisCommand *cmd);
 720 int prepareForShutdown();
 721 void redisLog(int level, const char *fmt, ...);
 722 void usage();
 723 void updateDictResizePolicy(void);
 724 int htNeedsResize(dict *dict);
 725 void oom(const char *msg);
 726
 727 /* Virtual Memory */
 728 void vmInit(void);
 729 void vmMarkPagesFree(off_t page, off_t count);
 730 robj *vmLoadObject(robj *o);
 731 robj *vmPreviewObject(robj *o);
 732 int vmSwapOneObjectBlocking(void);
 733 int vmSwapOneObjectThreaded(void);
 734 int vmCanSwapOut(void);
 735 void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata, int mask);
 736 void vmCancelThreadedIOJob(robj *o);
 737 void lockThreadedIO(void);
 738 void unlockThreadedIO(void);
 739 int vmSwapObjectThreaded(robj *key, robj *val, redisDb *db);
 740 void freeIOJob(iojob *j);
 741 void queueIOJob(iojob *j);
 742 int vmWriteObjectOnSwap(robj *o, off_t page);
 743 robj *vmReadObjectFromSwap(off_t page, int type);
 744 void waitEmptyIOJobsQueue(void);
 745 void vmReopenSwapFile(void);
 746 int vmFreePage(off_t page);
 747 void zunionInterBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
 748 void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
 749 int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd);
 750 int dontWaitForSwappedKey(redisClient *c, robj *key);
 751 void handleClientsBlockedOnSwappedKey(redisDb *db, robj *key);
 752 vmpointer *vmSwapObjectBlocking(robj *val);
 753
 754 /* Set data type */
 755 robj *setTypeCreate(robj *value);
 756 int setTypeAdd(robj *subject, robj *value);
 757 int setTypeRemove(robj *subject, robj *value);
 758 int setTypeIsMember(robj *subject, robj *value);
 759 setTypeIterator *setTypeInitIterator(robj *subject);
 760 void setTypeReleaseIterator(setTypeIterator *si);
 761 robj *setTypeNext(setTypeIterator *si);
 762 robj *setTypeRandomElement(robj *subject);
 763 unsigned long setTypeSize(robj *subject);
 764 void setTypeConvert(robj *subject, int enc);
 765
 766 /* Hash data type */
 767 void convertToRealHash(robj *o);
 768 void hashTypeTryConversion(robj *subject, robj **argv, int start, int end);
 769 void hashTypeTryObjectEncoding(robj *subject, robj **o1, robj **o2);
 770 robj *hashTypeGet(robj *o, robj *key);
 771 int hashTypeExists(robj *o, robj *key);
 772 int hashTypeSet(robj *o, robj *key, robj *value);
 773 int hashTypeDelete(robj *o, robj *key);
 774 unsigned long hashTypeLength(robj *o);
 775 hashTypeIterator *hashTypeInitIterator(robj *subject);
 776 void hashTypeReleaseIterator(hashTypeIterator *hi);
 777 int hashTypeNext(hashTypeIterator *hi);
 778 robj *hashTypeCurrent(hashTypeIterator *hi, int what);
 779 robj *hashTypeLookupWriteOrCreate(redisClient *c, robj *key);
 780
 781 /* Pub / Sub */
 782 int pubsubUnsubscribeAllChannels(redisClient *c, int notify);
 783 int pubsubUnsubscribeAllPatterns(redisClient *c, int notify);
 784 void freePubsubPattern(void *p);
 785 int listMatchPubsubPattern(void *a, void *b);
 786
 787 /* Utility functions */
 788 int stringmatchlen(const char *pattern, int patternLen,
 789         const char *string, int stringLen, int nocase);
 790 int stringmatch(const char *pattern, const char *string, int nocase);
 791 long long memtoll(const char *p, int *err);
 792 int ll2string(char *s, size_t len, long long value);
 793 int isStringRepresentableAsLong(sds s, long *longval);
 794 int isStringRepresentableAsLongLong(sds s, long long *longval);
 795 int isObjectRepresentableAsLongLong(robj *o, long long *llongval);
 796
 797 /* Configuration */
 798 void loadServerConfig(char *filename);
 799 void appendServerSaveParams(time_t seconds, int changes);
 800 void resetServerSaveParams();
 801
 802 /* db.c -- Keyspace access API */
 803 int removeExpire(redisDb *db, robj *key);
 804 void propagateExpire(redisDb *db, robj *key);
 805 int expireIfNeeded(redisDb *db, robj *key);
 806 time_t getExpire(redisDb *db, robj *key);
 807 void setExpire(redisDb *db, robj *key, time_t when);
 808 robj *lookupKey(redisDb *db, robj *key);
 809 robj *lookupKeyRead(redisDb *db, robj *key);
 810 robj *lookupKeyWrite(redisDb *db, robj *key);
 811 robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply);
 812 robj *lookupKeyWriteOrReply(redisClient *c, robj *key, robj *reply);
 813 int dbAdd(redisDb *db, robj *key, robj *val);
 814 int dbReplace(redisDb *db, robj *key, robj *val);
 815 int dbExists(redisDb *db, robj *key);
 816 robj *dbRandomKey(redisDb *db);
 817 int dbDelete(redisDb *db, robj *key);
 818 long long emptyDb();
 819 int selectDb(redisClient *c, int id);
 820
 821 /* Git SHA1 */
 822 char *redisGitSHA1(void);
 823 char *redisGitDirty(void);
 824
 825 /* Commands prototypes */
 826 void authCommand(redisClient *c);
 827 void pingCommand(redisClient *c);
 828 void echoCommand(redisClient *c);
 829 void setCommand(redisClient *c);
 830 void setnxCommand(redisClient *c);
 831 void setexCommand(redisClient *c);
 832 void getCommand(redisClient *c);
 833 void delCommand(redisClient *c);
 834 void existsCommand(redisClient *c);
 835 void incrCommand(redisClient *c);
 836 void decrCommand(redisClient *c);
 837 void incrbyCommand(redisClient *c);
 838 void decrbyCommand(redisClient *c);
 839 void selectCommand(redisClient *c);
 840 void randomkeyCommand(redisClient *c);
 841 void keysCommand(redisClient *c);
 842 void dbsizeCommand(redisClient *c);
 843 void lastsaveCommand(redisClient *c);
 844 void saveCommand(redisClient *c);
 845 void bgsaveCommand(redisClient *c);
 846 void bgrewriteaofCommand(redisClient *c);
 847 void shutdownCommand(redisClient *c);
 848 void moveCommand(redisClient *c);
 849 void renameCommand(redisClient *c);
 850 void renamenxCommand(redisClient *c);
 851 void lpushCommand(redisClient *c);
 852 void rpushCommand(redisClient *c);
 853 void lpushxCommand(redisClient *c);
 854 void rpushxCommand(redisClient *c);
 855 void linsertCommand(redisClient *c);
 856 void lpopCommand(redisClient *c);
 857 void rpopCommand(redisClient *c);
 858 void llenCommand(redisClient *c);
 859 void lindexCommand(redisClient *c);
 860 void lrangeCommand(redisClient *c);
 861 void ltrimCommand(redisClient *c);
 862 void typeCommand(redisClient *c);
 863 void lsetCommand(redisClient *c);
 864 void saddCommand(redisClient *c);
 865 void sremCommand(redisClient *c);
 866 void smoveCommand(redisClient *c);
 867 void sismemberCommand(redisClient *c);
 868 void scardCommand(redisClient *c);
 869 void spopCommand(redisClient *c);
 870 void srandmemberCommand(redisClient *c);
 871 void sinterCommand(redisClient *c);
 872 void sinterstoreCommand(redisClient *c);
 873 void sunionCommand(redisClient *c);
 874 void sunionstoreCommand(redisClient *c);
 875 void sdiffCommand(redisClient *c);
 876 void sdiffstoreCommand(redisClient *c);
 877 void syncCommand(redisClient *c);
 878 void flushdbCommand(redisClient *c);
 879 void flushallCommand(redisClient *c);
 880 void sortCommand(redisClient *c);
 881 void lremCommand(redisClient *c);
 882 void rpoplpushcommand(redisClient *c);
 883 void infoCommand(redisClient *c);
 884 void mgetCommand(redisClient *c);
 885 void monitorCommand(redisClient *c);
 886 void expireCommand(redisClient *c);
 887 void expireatCommand(redisClient *c);
 888 void getsetCommand(redisClient *c);
 889 void ttlCommand(redisClient *c);
 890 void persistCommand(redisClient *c);
 891 void slaveofCommand(redisClient *c);
 892 void debugCommand(redisClient *c);
 893 void msetCommand(redisClient *c);
 894 void msetnxCommand(redisClient *c);
 895 void zaddCommand(redisClient *c);
 896 void zincrbyCommand(redisClient *c);
 897 void zrangeCommand(redisClient *c);
 898 void zrangebyscoreCommand(redisClient *c);
 899 void zrevrangebyscoreCommand(redisClient *c);
 900 void zcountCommand(redisClient *c);
 901 void zrevrangeCommand(redisClient *c);
 902 void zcardCommand(redisClient *c);
 903 void zremCommand(redisClient *c);
 904 void zscoreCommand(redisClient *c);
 905 void zremrangebyscoreCommand(redisClient *c);
 906 void multiCommand(redisClient *c);
 907 void execCommand(redisClient *c);
 908 void discardCommand(redisClient *c);
 909 void blpopCommand(redisClient *c);
 910 void brpopCommand(redisClient *c);
 911 void appendCommand(redisClient *c);
 912 void substrCommand(redisClient *c);
 913 void strlenCommand(redisClient *c);
 914 void zrankCommand(redisClient *c);
 915 void zrevrankCommand(redisClient *c);
 916 void hsetCommand(redisClient *c);
 917 void hsetnxCommand(redisClient *c);
 918 void hgetCommand(redisClient *c);
 919 void hmsetCommand(redisClient *c);
 920 void hmgetCommand(redisClient *c);
 921 void hdelCommand(redisClient *c);
 922 void hlenCommand(redisClient *c);
 923 void zremrangebyrankCommand(redisClient *c);
 924 void zunionstoreCommand(redisClient *c);
 925 void zinterstoreCommand(redisClient *c);
 926 void hkeysCommand(redisClient *c);
 927 void hvalsCommand(redisClient *c);
 928 void hgetallCommand(redisClient *c);
 929 void hexistsCommand(redisClient *c);
 930 void configCommand(redisClient *c);
 931 void hincrbyCommand(redisClient *c);
 932 void subscribeCommand(redisClient *c);
 933 void unsubscribeCommand(redisClient *c);
 934 void psubscribeCommand(redisClient *c);
 935 void punsubscribeCommand(redisClient *c);
 936 void publishCommand(redisClient *c);
 937 void watchCommand(redisClient *c);
 938 void unwatchCommand(redisClient *c);
 939
 940 #if defined(__GNUC__)
 941 void *calloc(size_t count, size_t size) __attribute__ ((deprecated));
 942 void free(void *ptr) __attribute__ ((deprecated));
 943 void *malloc(size_t size) __attribute__ ((deprecated));
 944 void *realloc(void *ptr, size_t size) __attribute__ ((deprecated));
 945 #endif
 946
 947 #endif