src/redis.h

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