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