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