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