]> git.saurik.com Git - redis.git/blame - src/redis.h
Jemalloc updated to version 3.2.0.
[redis.git] / src / redis.h
CommitLineData
d288ee65 1/*
2 * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * * Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of Redis nor the names of its contributors may be used
14 * to endorse or promote products derived from this software without
15 * specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
e2641e09 30#ifndef __REDIS_H
31#define __REDIS_H
32
33#include "fmacros.h"
34#include "config.h"
35
36#if defined(__sun)
37#include "solarisfixes.h"
38#endif
39
40#include <stdio.h>
41#include <stdlib.h>
42#include <string.h>
43#include <time.h>
44#include <limits.h>
45#include <unistd.h>
46#include <errno.h>
3688d7f3 47#include <inttypes.h>
d06a5b23 48#include <pthread.h>
e1a586ee 49#include <syslog.h>
ecc91094 50#include <netinet/in.h>
7585836e 51#include <lua.h>
eea8c7a4 52#include <signal.h>
e2641e09 53
daa70b17 54#include "ae.h" /* Event driven programming library */
55#include "sds.h" /* Dynamic safe strings */
56#include "dict.h" /* Hash tables */
57#include "adlist.h" /* Linked lists */
e2641e09 58#include "zmalloc.h" /* total memory usage aware version of malloc/free */
daa70b17 59#include "anet.h" /* Networking the easy way */
e2641e09 60#include "ziplist.h" /* Compact list data structure */
daa70b17 61#include "intset.h" /* Compact integer set structure */
62#include "version.h" /* Version macro */
63#include "util.h" /* Misc functions useful in many places */
e2641e09 64
65/* Error codes */
66#define REDIS_OK 0
67#define REDIS_ERR -1
68
69/* Static server configuration */
a8a981a8 70#define REDIS_HZ 100 /* Time interrupt calls/sec. */
e2641e09 71#define REDIS_SERVERPORT 6379 /* TCP port */
3570629f 72#define REDIS_MAXIDLETIME 0 /* default client timeout: infinite */
e2641e09 73#define REDIS_DEFAULT_DBNUM 16
74#define REDIS_CONFIGLINE_MAX 1024
e2641e09 75#define REDIS_EXPIRELOOKUPS_PER_CRON 10 /* lookup 10 expires per loop */
f7f2b261 76#define REDIS_EXPIRELOOKUPS_TIME_PERC 25 /* CPU max % for keys collection */
e2641e09 77#define REDIS_MAX_WRITE_PER_EVENT (1024*64)
ae15f750 78#define REDIS_SHARED_SELECT_CMDS 10
e2641e09 79#define REDIS_SHARED_INTEGERS 10000
355f8591 80#define REDIS_SHARED_BULKHDR_LEN 32
e1a586ee 81#define REDIS_MAX_LOGMSG_LEN 1024 /* Default maximum length of syslog messages */
2c915bcf 82#define REDIS_AOF_REWRITE_PERC 100
83#define REDIS_AOF_REWRITE_MIN_SIZE (1024*1024)
84#define REDIS_AOF_REWRITE_ITEMS_PER_CMD 64
daa70b17 85#define REDIS_SLOWLOG_LOG_SLOWER_THAN 10000
590d55a2 86#define REDIS_SLOWLOG_MAX_LEN 128
58732c23 87#define REDIS_MAX_CLIENTS 10000
4b3865cb 88#define REDIS_AUTHPASS_MAX_LEN 512
48d26a48 89#define REDIS_DEFAULT_SLAVE_PRIORITY 100
8996bf77 90#define REDIS_REPL_TIMEOUT 60
91#define REDIS_REPL_PING_SLAVE_PERIOD 10
44f508f1 92#define REDIS_RUN_ID_SIZE 40
250e7f69 93#define REDIS_OPS_SEC_SAMPLES 16
44f508f1 94
f42e2f1b 95/* Protocol and I/O related defines */
96#define REDIS_MAX_QUERYBUF_LEN (1024*1024*1024) /* 1GB max query buffer. */
97#define REDIS_IOBUF_LEN (1024*16) /* Generic I/O buffer size */
98#define REDIS_REPLY_CHUNK_BYTES (16*1024) /* 16k output buffer */
11e0c4c5 99#define REDIS_INLINE_MAX_SIZE (1024*64) /* Max size of inline reads */
f42e2f1b 100#define REDIS_MBULK_BIG_ARG (1024*32)
8996bf77 101
e2641e09 102/* Hash table parameters */
103#define REDIS_HT_MINFILL 10 /* Minimal hash table fill 10% */
104
5d02b00f 105/* Command flags. Please check the command table defined in the redis.c file
106 * for more information about the meaning of every flag. */
107#define REDIS_CMD_WRITE 1 /* "w" flag */
108#define REDIS_CMD_READONLY 2 /* "r" flag */
109#define REDIS_CMD_DENYOOM 4 /* "m" flag */
110#define REDIS_CMD_FORCE_REPLICATION 8 /* "f" flag */
111#define REDIS_CMD_ADMIN 16 /* "a" flag */
112#define REDIS_CMD_PUBSUB 32 /* "p" flag */
b60ed6e8 113#define REDIS_CMD_NOSCRIPT 64 /* "s" flag */
114#define REDIS_CMD_RANDOM 128 /* "R" flag */
548efd91 115#define REDIS_CMD_SORT_FOR_SCRIPT 256 /* "S" flag */
3bb3f125 116#define REDIS_CMD_LOADING 512 /* "l" flag */
117#define REDIS_CMD_STALE 1024 /* "t" flag */
21645232 118#define REDIS_CMD_SKIP_MONITOR 2048 /* "M" flag */
e2641e09 119
120/* Object types */
121#define REDIS_STRING 0
122#define REDIS_LIST 1
123#define REDIS_SET 2
124#define REDIS_ZSET 3
125#define REDIS_HASH 4
e12b27ac 126
e2641e09 127/* Objects encoding. Some kind of objects like Strings and Hashes can be
128 * internally represented in multiple ways. The 'encoding' field of the object
129 * is set to one of this fields for this object. */
130#define REDIS_ENCODING_RAW 0 /* Raw representation */
131#define REDIS_ENCODING_INT 1 /* Encoded as integer */
132#define REDIS_ENCODING_HT 2 /* Encoded as hash table */
133#define REDIS_ENCODING_ZIPMAP 3 /* Encoded as zipmap */
134#define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
135#define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
96ffb2fe 136#define REDIS_ENCODING_INTSET 6 /* Encoded as intset */
0b7f6d09 137#define REDIS_ENCODING_SKIPLIST 7 /* Encoded as skiplist */
e2641e09 138
e2641e09 139/* Defines related to the dump file format. To store 32 bits lengths for short
140 * keys requires a lot of space, so we check the most significant 2 bits of
141 * the first byte to interpreter the length:
142 *
143 * 00|000000 => if the two MSB are 00 the len is the 6 bits of this byte
144 * 01|000000 00000000 => 01, the len is 14 byes, 6 bits + 8 bits of next byte
145 * 10|000000 [32 bit integer] => if it's 01, a full 32 bit len will follow
146 * 11|000000 this means: specially encoded object will follow. The six bits
147 * number specify the kind of object that follows.
148 * See the REDIS_RDB_ENC_* defines.
149 *
150 * Lenghts up to 63 are stored using a single byte, most DB keys, and may
151 * values, will fit inside. */
152#define REDIS_RDB_6BITLEN 0
153#define REDIS_RDB_14BITLEN 1
154#define REDIS_RDB_32BITLEN 2
155#define REDIS_RDB_ENCVAL 3
156#define REDIS_RDB_LENERR UINT_MAX
157
158/* When a length of a string object stored on disk has the first two bits
159 * set, the remaining two bits specify a special encoding for the object
160 * accordingly to the following defines: */
161#define REDIS_RDB_ENC_INT8 0 /* 8 bit signed integer */
162#define REDIS_RDB_ENC_INT16 1 /* 16 bit signed integer */
163#define REDIS_RDB_ENC_INT32 2 /* 32 bit signed integer */
164#define REDIS_RDB_ENC_LZF 3 /* string compressed with FASTLZ */
165
c6ac7d03 166/* AOF states */
167#define REDIS_AOF_OFF 0 /* AOF is off */
168#define REDIS_AOF_ON 1 /* AOF is on */
169#define REDIS_AOF_WAIT_REWRITE 2 /* AOF waits rewrite to start appending */
170
e2641e09 171/* Client flags */
41f0f927 172#define REDIS_SLAVE (1<<0) /* This client is a slave server */
173#define REDIS_MASTER (1<<1) /* This client is a master server */
174#define REDIS_MONITOR (1<<2) /* This client is a slave monitor, see MONITOR */
175#define REDIS_MULTI (1<<3) /* This client is in a MULTI context */
176#define REDIS_BLOCKED (1<<4) /* The client is waiting in a blocking operation */
177#define REDIS_DIRTY_CAS (1<<5) /* Watched keys modified. EXEC will fail. */
178#define REDIS_CLOSE_AFTER_REPLY (1<<6) /* Close after writing entire reply. */
179#define REDIS_UNBLOCKED (1<<7) /* This client was unblocked and is stored in
180 server.unblocked_clients */
181#define REDIS_LUA_CLIENT (1<<8) /* This is a non connected client used by Lua */
182#define REDIS_ASKING (1<<9) /* Client issued the ASKING command */
183#define REDIS_CLOSE_ASAP (1<<10)/* Close this client ASAP */
184#define REDIS_UNIX_SOCKET (1<<11) /* Client connected via Unix domain socket */
185#define REDIS_DIRTY_EXEC (1<<12) /* EXEC will fail for errors while queueing */
cd8788f2
PN
186
187/* Client request types */
188#define REDIS_REQ_INLINE 1
189#define REDIS_REQ_MULTIBULK 2
e2641e09 190
498dc555 191/* Client classes for client limits, currently used only for
192 * the max-client-output-buffer limit implementation. */
193#define REDIS_CLIENT_LIMIT_CLASS_NORMAL 0
194#define REDIS_CLIENT_LIMIT_CLASS_SLAVE 1
195#define REDIS_CLIENT_LIMIT_CLASS_PUBSUB 2
7eac2a75 196#define REDIS_CLIENT_LIMIT_NUM_CLASSES 3
498dc555 197
e2641e09 198/* Slave replication state - slave side */
a3309139
PN
199#define REDIS_REPL_NONE 0 /* No active replication */
200#define REDIS_REPL_CONNECT 1 /* Must connect to master */
b075621f 201#define REDIS_REPL_CONNECTING 2 /* Connecting to master */
fd2a8951 202#define REDIS_REPL_RECEIVE_PONG 3 /* Wait for PING reply */
203#define REDIS_REPL_TRANSFER 4 /* Receiving .rdb from master */
204#define REDIS_REPL_CONNECTED 5 /* Connected to master */
e2641e09 205
890a2ed9
PN
206/* Synchronous read timeout - slave side */
207#define REDIS_REPL_SYNCIO_TIMEOUT 5
e2641e09 208
209/* Slave replication state - from the point of view of master
210 * Note that in SEND_BULK and ONLINE state the slave receives new updates
211 * in its output queue. In the WAIT_BGSAVE state instead the server is waiting
212 * to start the next background saving in order to send updates to it. */
213#define REDIS_REPL_WAIT_BGSAVE_START 3 /* master waits bgsave to start feeding it */
214#define REDIS_REPL_WAIT_BGSAVE_END 4 /* master waits bgsave to start bulk DB transmission */
215#define REDIS_REPL_SEND_BULK 5 /* master is sending the bulk DB */
216#define REDIS_REPL_ONLINE 6 /* bulk DB already transmitted, receive updates */
217
218/* List related stuff */
219#define REDIS_HEAD 0
220#define REDIS_TAIL 1
221
222/* Sort operations */
223#define REDIS_SORT_GET 0
224#define REDIS_SORT_ASC 1
225#define REDIS_SORT_DESC 2
226#define REDIS_SORTKEY_MAX 1024
227
228/* Log levels */
229#define REDIS_DEBUG 0
230#define REDIS_VERBOSE 1
231#define REDIS_NOTICE 2
232#define REDIS_WARNING 3
996d503d 233#define REDIS_LOG_RAW (1<<10) /* Modifier to log without timestamp */
e2641e09 234
235/* Anti-warning macro... */
236#define REDIS_NOTUSED(V) ((void) V)
237
238#define ZSKIPLIST_MAXLEVEL 32 /* Should be enough for 2^32 elements */
239#define ZSKIPLIST_P 0.25 /* Skiplist P = 1/4 */
240
241/* Append only defines */
2c915bcf 242#define AOF_FSYNC_NO 0
243#define AOF_FSYNC_ALWAYS 1
244#define AOF_FSYNC_EVERYSEC 2
e2641e09 245
246/* Zip structure related defaults */
ebd85e9a
PN
247#define REDIS_HASH_MAX_ZIPLIST_ENTRIES 512
248#define REDIS_HASH_MAX_ZIPLIST_VALUE 64
6a246b1e 249#define REDIS_LIST_MAX_ZIPLIST_ENTRIES 512
250#define REDIS_LIST_MAX_ZIPLIST_VALUE 64
251#define REDIS_SET_MAX_INTSET_ENTRIES 512
3ea204e1
PN
252#define REDIS_ZSET_MAX_ZIPLIST_ENTRIES 128
253#define REDIS_ZSET_MAX_ZIPLIST_VALUE 64
e2641e09 254
255/* Sets operations codes */
256#define REDIS_OP_UNION 0
257#define REDIS_OP_DIFF 1
258#define REDIS_OP_INTER 2
259
165346ca 260/* Redis maxmemory strategies */
261#define REDIS_MAXMEMORY_VOLATILE_LRU 0
262#define REDIS_MAXMEMORY_VOLATILE_TTL 1
263#define REDIS_MAXMEMORY_VOLATILE_RANDOM 2
264#define REDIS_MAXMEMORY_ALLKEYS_LRU 3
265#define REDIS_MAXMEMORY_ALLKEYS_RANDOM 4
5402c426 266#define REDIS_MAXMEMORY_NO_EVICTION 5
165346ca 267
eeffcf38 268/* Scripting */
8cb8d417 269#define REDIS_LUA_TIME_LIMIT 5000 /* milliseconds */
eeffcf38 270
12d293ca 271/* Units */
272#define UNIT_SECONDS 0
273#define UNIT_MILLISECONDS 1
274
4ab8695d 275/* SHUTDOWN flags */
276#define REDIS_SHUTDOWN_SAVE 1 /* Force SAVE on SHUTDOWN even if no save
277 points are configured. */
278#define REDIS_SHUTDOWN_NOSAVE 2 /* Don't SAVE on SHUTDOWN. */
279
ce8b772b 280/* Command call flags, see call() function */
281#define REDIS_CALL_NONE 0
282#define REDIS_CALL_SLOWLOG 1
283#define REDIS_CALL_STATS 2
284#define REDIS_CALL_PROPAGATE 4
285#define REDIS_CALL_FULL (REDIS_CALL_SLOWLOG | REDIS_CALL_STATS | REDIS_CALL_PROPAGATE)
286
ad08d059 287/* Command propagation flags, see propagate() function */
288#define REDIS_PROPAGATE_NONE 0
289#define REDIS_PROPAGATE_AOF 1
290#define REDIS_PROPAGATE_REPL 2
291
120ba392 292/* Using the following macro you can run code inside serverCron() with the
293 * specified period, specified in milliseconds.
294 * The actual resolution depends on REDIS_HZ. */
295#define run_with_period(_ms_) if (!(server.cronloops%((_ms_)/(1000/REDIS_HZ))))
296
e2641e09 297/* We can print the stacktrace, so our assert is defined this way: */
bab205f7 298#define redisAssertWithInfo(_c,_o,_e) ((_e)?(void)0 : (_redisAssertWithInfo(_c,_o,#_e,__FILE__,__LINE__),_exit(1)))
e2641e09 299#define redisAssert(_e) ((_e)?(void)0 : (_redisAssert(#_e,__FILE__,__LINE__),_exit(1)))
300#define redisPanic(_e) _redisPanic(#_e,__FILE__,__LINE__),_exit(1)
e2641e09 301
302/*-----------------------------------------------------------------------------
303 * Data types
304 *----------------------------------------------------------------------------*/
305
306/* A redis object, that is a type able to hold a string / list / set */
307
308/* The actual Redis Object */
ef59a8bc 309#define REDIS_LRU_CLOCK_MAX ((1<<21)-1) /* Max value of obj->lru */
165346ca 310#define REDIS_LRU_CLOCK_RESOLUTION 10 /* LRU clock resolution in seconds */
e2641e09 311typedef struct redisObject {
312 unsigned type:4;
3be00d7e 313 unsigned notused:2; /* Not used */
e2641e09 314 unsigned encoding:4;
315 unsigned lru:22; /* lru time (relative to server.lruclock) */
316 int refcount;
317 void *ptr;
e2641e09 318} robj;
319
e2641e09 320/* Macro used to initalize a Redis object allocated on the stack.
321 * Note that this macro is taken near the structure definition to make sure
322 * we'll update it when the structure is changed, to avoid bugs like
323 * bug #85 introduced exactly in this way. */
324#define initStaticStringObject(_var,_ptr) do { \
325 _var.refcount = 1; \
326 _var.type = REDIS_STRING; \
327 _var.encoding = REDIS_ENCODING_RAW; \
328 _var.ptr = _ptr; \
e2641e09 329} while(0);
330
331typedef struct redisDb {
332 dict *dict; /* The keyspace for this DB */
333 dict *expires; /* Timeout of keys with a timeout set */
334 dict *blocking_keys; /* Keys with clients waiting for data (BLPOP) */
f444e2af 335 dict *ready_keys; /* Blocked keys that received a PUSH */
e2641e09 336 dict *watched_keys; /* WATCHED keys for MULTI/EXEC CAS */
337 int id;
338} redisDb;
339
340/* Client MULTI/EXEC state */
341typedef struct multiCmd {
342 robj **argv;
343 int argc;
344 struct redisCommand *cmd;
345} multiCmd;
346
347typedef struct multiState {
348 multiCmd *commands; /* Array of MULTI commands */
349 int count; /* Total number of MULTI commands */
350} multiState;
351
357a8417
DJMM
352typedef struct blockingState {
353 robj **keys; /* The key we are waiting to terminate a blocking
354 * operation such as BLPOP. Otherwise NULL. */
355 int count; /* Number of blocking keys */
356 time_t timeout; /* Blocking operation timeout. If UNIX current time
357 * is >= timeout then the operation timed out. */
358 robj *target; /* The key that should receive the element,
359 * for BRPOPLPUSH. */
360} blockingState;
361
f444e2af 362/* The following structure represents a node in the server.ready_keys list,
363 * where we accumulate all the keys that had clients blocked with a blocking
364 * operation such as B[LR]POP, but received new data in the context of the
365 * last executed command.
366 *
367 * After the execution of every command or script, we run this list to check
368 * if as a result we should serve data to clients blocked, unblocking them.
369 * Note that server.ready_keys will not have duplicates as there dictionary
370 * also called ready_keys in every structure representing a Redis database,
371 * where we make sure to remember if a given key was already added in the
372 * server.ready_keys list. */
373typedef struct readyList {
374 redisDb *db;
375 robj *key;
376} readyList;
377
e2641e09 378/* With multiplexing we need to take per-clinet state.
379 * Clients are taken in a liked list. */
380typedef struct redisClient {
381 int fd;
382 redisDb *db;
383 int dictid;
384 sds querybuf;
9fa9ccb0 385 size_t querybuf_peak; /* Recent (100ms or more) peak of querybuf size */
cd8788f2
PN
386 int argc;
387 robj **argv;
2c74a9f9 388 struct redisCommand *cmd, *lastcmd;
cd8788f2
PN
389 int reqtype;
390 int multibulklen; /* number of multi bulk arguments left to read */
391 long bulklen; /* length of bulk argument in multi bulk request */
e2641e09 392 list *reply;
3853c168 393 unsigned long reply_bytes; /* Tot bytes of objects in reply list */
e2641e09 394 int sentlen;
41e8e5cb 395 time_t ctime; /* Client creation time */
e2641e09 396 time_t lastinteraction; /* time of the last interaction, used for timeout */
7eac2a75 397 time_t obuf_soft_limit_reached_time;
e2641e09 398 int flags; /* REDIS_SLAVE | REDIS_MONITOR | REDIS_MULTI ... */
399 int slaveseldb; /* slave selected db, if this client is a slave */
400 int authenticated; /* when requirepass is non-NULL */
401 int replstate; /* replication state if this is a slave */
402 int repldbfd; /* replication DB file descriptor */
403 long repldboff; /* replication DB file offset */
404 off_t repldbsize; /* replication DB file size */
dbd8c753 405 int slave_listening_port; /* As configured with: SLAVECONF listening-port */
e2641e09 406 multiState mstate; /* MULTI/EXEC state */
e3c51c4b 407 blockingState bpop; /* blocking state */
e2641e09 408 list *io_keys; /* Keys this client is waiting to be loaded from the
409 * swap file in order to continue. */
410 list *watched_keys; /* Keys WATCHED for MULTI/EXEC CAS */
411 dict *pubsub_channels; /* channels a client is interested in (SUBSCRIBE) */
412 list *pubsub_patterns; /* patterns a client is interested in (SUBSCRIBE) */
834ef78e
PN
413
414 /* Response buffer */
415 int bufpos;
f3357792 416 char buf[REDIS_REPLY_CHUNK_BYTES];
e2641e09 417} redisClient;
418
419struct saveparam {
420 time_t seconds;
421 int changes;
422};
423
424struct sharedObjectsStruct {
425 robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *cnegone, *pong, *space,
426 *colon, *nullbulk, *nullmultibulk, *queued,
427 *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
c25e7eaf 428 *outofrangeerr, *noscripterr, *loadingerr, *slowscripterr, *bgsaveerr,
41f0f927 429 *masterdownerr, *roslaveerr, *execaborterr,
0b08d648 430 *oomerr, *plus, *messagebulk, *pmessagebulk, *subscribebulk,
ae15f750 431 *unsubscribebulk, *psubscribebulk, *punsubscribebulk, *del, *rpop, *lpop,
f444e2af 432 *lpush,
ae15f750 433 *select[REDIS_SHARED_SELECT_CMDS],
355f8591 434 *integers[REDIS_SHARED_INTEGERS],
435 *mbulkhdr[REDIS_SHARED_BULKHDR_LEN], /* "*<value>\r\n" */
436 *bulkhdr[REDIS_SHARED_BULKHDR_LEN]; /* "$<value>\r\n" */
e2641e09 437};
438
c772d9c6 439/* ZSETs use a specialized version of Skiplists */
440typedef struct zskiplistNode {
441 robj *obj;
442 double score;
443 struct zskiplistNode *backward;
444 struct zskiplistLevel {
445 struct zskiplistNode *forward;
446 unsigned int span;
447 } level[];
448} zskiplistNode;
449
450typedef struct zskiplist {
451 struct zskiplistNode *header, *tail;
452 unsigned long length;
453 int level;
454} zskiplist;
455
456typedef struct zset {
457 dict *dict;
458 zskiplist *zsl;
459} zset;
460
7eac2a75 461typedef struct clientBufferLimitsConfig {
7fe8d49a 462 unsigned long long hard_limit_bytes;
463 unsigned long long soft_limit_bytes;
7eac2a75 464 time_t soft_limit_seconds;
465} clientBufferLimitsConfig;
466
78d6a22d 467/* The redisOp structure defines a Redis Operation, that is an instance of
468 * a command with an argument vector, database ID, propagation target
469 * (REDIS_PROPAGATE_*), and command pointer.
470 *
471 * Currently only used to additionally propagate more commands to AOF/Replication
472 * after the propagation of the executed command. */
473typedef struct redisOp {
eeb34eff 474 robj **argv;
475 int argc, dbid, target;
476 struct redisCommand *cmd;
78d6a22d 477} redisOp;
478
479/* Defines an array of Redis operations. There is an API to add to this
480 * structure in a easy way.
481 *
482 * redisOpArrayInit();
483 * redisOpArrayAppend();
484 * redisOpArrayFree();
485 */
486typedef struct redisOpArray {
487 redisOp *ops;
488 int numops;
489} redisOpArray;
eeb34eff 490
ecc91094 491/*-----------------------------------------------------------------------------
492 * Global server state
493 *----------------------------------------------------------------------------*/
494
e2641e09 495struct redisServer {
5b831607 496 /* General */
5b831607 497 redisDb *db;
3f006679 498 dict *commands; /* Command table hash table */
5b831607 499 aeEventLoop *el;
c6ac7d03 500 unsigned lruclock:22; /* Clock incrementing every minute, for LRU */
501 unsigned lruclock_padding:10;
502 int shutdown_asap; /* SHUTDOWN needed ASAP */
503 int activerehashing; /* Incremental rehash in serverCron() */
504 char *requirepass; /* Pass for AUTH command, or NULL */
505 char *pidfile; /* PID file path */
75eaac5c 506 int arch_bits; /* 32 or 64 depending on sizeof(long) */
c25e7eaf 507 int cronloops; /* Number of times the cron function run */
91d664d6 508 char runid[REDIS_RUN_ID_SIZE+1]; /* ID always different at every exec. */
120ba392 509 int sentinel_mode; /* True if this instance is a Sentinel. */
5b831607 510 /* Networking */
c6ac7d03 511 int port; /* TCP listening port */
512 char *bindaddr; /* Bind address or NULL */
513 char *unixsocket; /* UNIX socket path */
514 mode_t unixsocketperm; /* UNIX socket permission */
515 int ipfd; /* TCP socket file descriptor */
516 int sofd; /* Unix socket file descriptor */
c6ac7d03 517 list *clients; /* List of active clients */
7eac2a75 518 list *clients_to_close; /* Clients to close asynchronously */
c6ac7d03 519 list *slaves, *monitors; /* List of slaves and MONITORs */
00010fa9 520 redisClient *current_client; /* Current client, only used on crash report */
c6ac7d03 521 char neterr[ANET_ERR_LEN]; /* Error buffer for anet.c */
97e7f8ae 522 /* RDB / AOF loading information */
c6ac7d03 523 int loading; /* We are loading data from disk if true */
97e7f8ae 524 off_t loading_total_bytes;
525 off_t loading_loaded_bytes;
526 time_t loading_start_time;
4ebfc455 527 /* Fast pointers to often looked up command */
f444e2af 528 struct redisCommand *delCommand, *multiCommand, *lpushCommand, *lpopCommand,
529 *rpopCommand;
e2641e09 530 /* Fields used only for stats */
c6ac7d03 531 time_t stat_starttime; /* Server start time */
532 long long stat_numcommands; /* Number of processed commands */
533 long long stat_numconnections; /* Number of connections received */
534 long long stat_expiredkeys; /* Number of expired keys */
535 long long stat_evictedkeys; /* Number of evicted keys (maxmemory) */
536 long long stat_keyspace_hits; /* Number of successful lookups of keys */
537 long long stat_keyspace_misses; /* Number of failed lookups of keys */
538 size_t stat_peak_memory; /* Max used memory record */
539 long long stat_fork_time; /* Time needed to perform latets fork() */
540 long long stat_rejected_conn; /* Clients rejected because of maxclients */
541 list *slowlog; /* SLOWLOG list of commands */
542 long long slowlog_entry_id; /* SLOWLOG current entry ID */
543 long long slowlog_log_slower_than; /* SLOWLOG time limit (to get logged) */
544 unsigned long slowlog_max_len; /* SLOWLOG max number of items logged */
250e7f69 545 /* The following two are used to track instantaneous "load" in terms
546 * of operations per second. */
547 long long ops_sec_last_sample_time; /* Timestamp of last sample (in ms) */
548 long long ops_sec_last_sample_ops; /* numcommands in last sample */
549 long long ops_sec_samples[REDIS_OPS_SEC_SAMPLES];
550 int ops_sec_idx;
e2641e09 551 /* Configuration */
c6ac7d03 552 int verbosity; /* Loglevel in redis.conf */
553 int maxidletime; /* Client timeout in seconds */
554 size_t client_max_querybuf_len; /* Limit for client query buffer length */
555 int dbnum; /* Total number of configured DBs */
556 int daemonize; /* True if running as a daemon */
7eac2a75 557 clientBufferLimitsConfig client_obuf_limits[REDIS_CLIENT_LIMIT_NUM_CLASSES];
c6ac7d03 558 /* AOF persistence */
559 int aof_state; /* REDIS_AOF_(ON|OFF|WAIT_REWRITE) */
2c915bcf 560 int aof_fsync; /* Kind of fsync() policy */
561 char *aof_filename; /* Name of the AOF file */
562 int aof_no_fsync_on_rewrite; /* Don't fsync if a rewrite is in prog. */
563 int aof_rewrite_perc; /* Rewrite AOF if % growth is > M and... */
564 off_t aof_rewrite_min_size; /* the AOF file is at least N bytes. */
565 off_t aof_rewrite_base_size; /* AOF size on latest startup or rewrite. */
566 off_t aof_current_size; /* AOF current size. */
567 int aof_rewrite_scheduled; /* Rewrite once BGSAVE terminates. */
ff2145ad 568 pid_t aof_child_pid; /* PID if rewriting process */
edb95253 569 list *aof_rewrite_buf_blocks; /* Hold changes during an AOF rewrite. */
ff2145ad 570 sds aof_buf; /* AOF buffer, written before entering the event loop */
571 int aof_fd; /* File descriptor of currently selected AOF file */
572 int aof_selected_db; /* Currently selected DB in AOF */
c6ac7d03 573 time_t aof_flush_postponed_start; /* UNIX time of postponed AOF flush */
ff2145ad 574 time_t aof_last_fsync; /* UNIX time of last fsync() */
6b4d92e2 575 time_t aof_rewrite_time_last; /* Time used by last AOF rewrite run. */
576 time_t aof_rewrite_time_start; /* Current AOF rewrite start time. */
f00b0844 577 int aof_lastbgrewrite_status; /* REDIS_OK or REDIS_ERR */
81f32c7b 578 unsigned long aof_delayed_fsync; /* delayed AOF fsync() counter */
c6ac7d03 579 /* RDB persistence */
580 long long dirty; /* Changes to DB from the last save */
581 long long dirty_before_bgsave; /* Used to restore dirty on failed BGSAVE */
f48cd4b9 582 pid_t rdb_child_pid; /* PID of RDB saving child */
c6ac7d03 583 struct saveparam *saveparams; /* Save points array for RDB */
584 int saveparamslen; /* Number of saving points */
f48cd4b9 585 char *rdb_filename; /* Name of RDB file */
586 int rdb_compression; /* Use compression in RDB? */
39d1e350 587 int rdb_checksum; /* Use RDB checksum? */
c25e7eaf 588 time_t lastsave; /* Unix time of last save succeeede */
6b4d92e2 589 time_t rdb_save_time_last; /* Time used by last RDB save run. */
590 time_t rdb_save_time_start; /* Current RDB save start time. */
c25e7eaf 591 int lastbgsave_status; /* REDIS_OK or REDIS_ERR */
4d3bbf35 592 int stop_writes_on_bgsave_err; /* Don't allow writes if can't BGSAVE */
eeb34eff 593 /* Propagation of commands in AOF / replication */
78d6a22d 594 redisOpArray also_propagate; /* Additional command to propagate. */
36c17a53 595 /* Logging */
c6ac7d03 596 char *logfile; /* Path of log file */
597 int syslog_enabled; /* Is syslog enabled? */
598 char *syslog_ident; /* Syslog ident */
599 int syslog_facility; /* Syslog facility */
f4aa600b 600 /* Slave specific fields */
c6ac7d03 601 char *masterauth; /* AUTH with this password with master */
602 char *masterhost; /* Hostname of master */
603 int masterport; /* Port of master */
0671d88c 604 int repl_ping_slave_period; /* Master pings the slave every N seconds */
c6ac7d03 605 int repl_timeout; /* Timeout after N seconds of master idle */
606 redisClient *master; /* Client that is master for this slave */
607 int repl_syncio_timeout; /* Timeout for synchronous I/O calls */
1844f990 608 int repl_state; /* Replication status if the instance is a slave */
13732168 609 off_t repl_transfer_size; /* Size of RDB to read from master during sync. */
610 off_t repl_transfer_read; /* Amount of RDB read from master during sync. */
611 off_t repl_transfer_last_fsync_off; /* Offset when we fsync-ed last time. */
c6ac7d03 612 int repl_transfer_s; /* Slave -> Master SYNC socket */
613 int repl_transfer_fd; /* Slave -> Master SYNC temp file descriptor */
614 char *repl_transfer_tmpfile; /* Slave-> master SYNC temp file name */
615 time_t repl_transfer_lastio; /* Unix time of the latest read, for timeout */
4ebfc455 616 int repl_serve_stale_data; /* Serve stale data when link is down? */
05406168 617 int repl_slave_ro; /* Slave is read only? */
c6ac7d03 618 time_t repl_down_since; /* Unix time at which link with master went down */
48d26a48 619 int slave_priority; /* Reported in INFO and used by Sentinel. */
f4aa600b 620 /* Limits */
c6ac7d03 621 unsigned int maxclients; /* Max number of simultaneous clients */
622 unsigned long long maxmemory; /* Max number of memory bytes to use */
623 int maxmemory_policy; /* Policy for key evition */
624 int maxmemory_samples; /* Pricision of random sampling */
f4aa600b 625 /* Blocked clients */
c6ac7d03 626 unsigned int bpop_blocked_clients; /* Number of clients blocked by lists */
cea8c5cd 627 list *unblocked_clients; /* list of clients to unblock before next loop */
f444e2af 628 list *ready_keys; /* List of readyList structures for BLPOP & co */
e2641e09 629 /* Sort parameters - qsort_r() is only available under BSD so we
630 * have to take this state global, in order to pass it to sortCompare() */
631 int sort_desc;
632 int sort_alpha;
633 int sort_bypattern;
c6ac7d03 634 /* Zip structure config, see redis.conf for more information */
ebd85e9a
PN
635 size_t hash_max_ziplist_entries;
636 size_t hash_max_ziplist_value;
e2641e09 637 size_t list_max_ziplist_entries;
638 size_t list_max_ziplist_value;
96ffb2fe 639 size_t set_max_intset_entries;
3ea204e1
PN
640 size_t zset_max_ziplist_entries;
641 size_t zset_max_ziplist_value;
c6ac7d03 642 time_t unixtime; /* Unix time sampled every second. */
e2641e09 643 /* Pubsub */
c6ac7d03 644 dict *pubsub_channels; /* Map channels to list of subscribed clients */
645 list *pubsub_patterns; /* A list of pubsub_patterns */
7585836e 646 /* Scripting */
4dd444bb 647 lua_State *lua; /* The Lua interpreter. We use just one for all clients */
c6ac7d03 648 redisClient *lua_client; /* The "fake client" to query Redis from Lua */
649 redisClient *lua_caller; /* The client running EVAL right now, or NULL */
650 dict *lua_scripts; /* A dictionary of SHA1 -> Lua scripts */
651 long long lua_time_limit; /* Script timeout in seconds */
652 long long lua_time_start; /* Start time of script */
4ab8695d 653 int lua_write_dirty; /* True if a write command was called during the
654 execution of the current script. */
9f772cc2 655 int lua_random_dirty; /* True if a random command was called during the
4ab8695d 656 execution of the current script. */
115e3ff3 657 int lua_timedout; /* True if we reached the time limit for script
658 execution. */
4ab8695d 659 int lua_kill; /* Kill the script if true. */
fa5af017 660 /* Assert & bug reportign */
661 char *assert_failed;
662 char *assert_file;
663 int assert_line;
c6ac7d03 664 int bug_report_start; /* True if bug report header was already logged. */
fc030ac7 665 int watchdog_period; /* Software watchdog period in ms. 0 = off */
e2641e09 666};
667
668typedef struct pubsubPattern {
669 redisClient *client;
670 robj *pattern;
671} pubsubPattern;
672
673typedef void redisCommandProc(redisClient *c);
9791f0f8 674typedef int *redisGetKeysProc(struct redisCommand *cmd, robj **argv, int argc, int *numkeys, int flags);
e2641e09 675struct redisCommand {
676 char *name;
677 redisCommandProc *proc;
678 int arity;
5d02b00f 679 char *sflags; /* Flags as string represenation, one char per flag. */
680 int flags; /* The actual flags, obtained from the 'sflags' field. */
571e257d 681 /* Use a function to determine keys arguments in a command line. */
9791f0f8 682 redisGetKeysProc *getkeys_proc;
e2641e09 683 /* What keys should be loaded in background when calling this command? */
9791f0f8 684 int firstkey; /* The first argument that's a key (0 = no keys) */
685 int lastkey; /* THe last argument that's a key */
686 int keystep; /* The step between first and last key */
0d808ef2 687 long long microseconds, calls;
e2641e09 688};
689
690struct redisFunctionSym {
691 char *name;
692 unsigned long pointer;
693};
694
695typedef struct _redisSortObject {
696 robj *obj;
697 union {
698 double score;
699 robj *cmpobj;
700 } u;
701} redisSortObject;
702
703typedef struct _redisSortOperation {
704 int type;
705 robj *pattern;
706} redisSortOperation;
707
e2641e09 708/* Structure to hold list iteration abstraction. */
709typedef struct {
710 robj *subject;
711 unsigned char encoding;
712 unsigned char direction; /* Iteration direction */
713 unsigned char *zi;
714 listNode *ln;
715} listTypeIterator;
716
717/* Structure for an entry while iterating over a list. */
718typedef struct {
719 listTypeIterator *li;
720 unsigned char *zi; /* Entry in ziplist */
721 listNode *ln; /* Entry in linked list */
722} listTypeEntry;
723
96ffb2fe
PN
724/* Structure to hold set iteration abstraction. */
725typedef struct {
726 robj *subject;
727 int encoding;
728 int ii; /* intset iterator */
729 dictIterator *di;
cb72d0f1 730} setTypeIterator;
96ffb2fe 731
e2641e09 732/* Structure to hold hash iteration abstration. Note that iteration over
733 * hashes involves both fields and values. Because it is possible that
734 * not both are required, store pointers in the iterator to avoid
735 * unnecessary memory allocation for fields/values. */
736typedef struct {
ebd85e9a 737 robj *subject;
e2641e09 738 int encoding;
ebd85e9a
PN
739
740 unsigned char *fptr, *vptr;
e2641e09 741
742 dictIterator *di;
743 dictEntry *de;
744} hashTypeIterator;
745
746#define REDIS_HASH_KEY 1
747#define REDIS_HASH_VALUE 2
748
749/*-----------------------------------------------------------------------------
750 * Extern declarations
751 *----------------------------------------------------------------------------*/
752
753extern struct redisServer server;
754extern struct sharedObjectsStruct shared;
755extern dictType setDictType;
756extern dictType zsetDictType;
4dd444bb 757extern dictType dbDictType;
9120275d 758extern dictType shaScriptObjectDictType;
e2641e09 759extern double R_Zero, R_PosInf, R_NegInf, R_Nan;
38d6976c 760extern dictType hashDictType;
e2641e09 761
762/*-----------------------------------------------------------------------------
763 * Functions prototypes
764 *----------------------------------------------------------------------------*/
765
419e1cca 766/* Utils */
767long long ustime(void);
2c2b2085 768long long mstime(void);
44f508f1 769void getRandomHexChars(char *p, unsigned int len);
bb99f425 770uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l);
55951f90 771void exitFromChild(int retcode);
419e1cca 772
e2641e09 773/* networking.c -- Networking and Client related operations */
774redisClient *createClient(int fd);
775void closeTimedoutClients(void);
776void freeClient(redisClient *c);
777void resetClient(redisClient *c);
778void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask);
e2641e09 779void addReply(redisClient *c, robj *obj);
b301c1fc
PN
780void *addDeferredMultiBulkLength(redisClient *c);
781void setDeferredMultiBulkLength(redisClient *c, void *node, long length);
e2641e09 782void addReplySds(redisClient *c, sds s);
783void processInputBuffer(redisClient *c);
ab17b909
PN
784void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask);
785void acceptUnixHandler(aeEventLoop *el, int fd, void *privdata, int mask);
e2641e09 786void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask);
787void addReplyBulk(redisClient *c, robj *obj);
788void addReplyBulkCString(redisClient *c, char *s);
d51ebef5 789void addReplyBulkCBuffer(redisClient *c, void *p, size_t len);
790void addReplyBulkLongLong(redisClient *c, long long ll);
e2641e09 791void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
792void addReply(redisClient *c, robj *obj);
793void addReplySds(redisClient *c, sds s);
3ab20376
PN
794void addReplyError(redisClient *c, char *err);
795void addReplyStatus(redisClient *c, char *status);
e2641e09 796void addReplyDouble(redisClient *c, double d);
797void addReplyLongLong(redisClient *c, long long ll);
0537e7bf 798void addReplyMultiBulkLen(redisClient *c, long length);
1824e3a3 799void copyClientOutputBuffer(redisClient *dst, redisClient *src);
e2641e09 800void *dupClientReplyValue(void *o);
7a1fd61e 801void getClientsMaxBuffers(unsigned long *longest_output_list,
802 unsigned long *biggest_input_buffer);
becf5fdb 803sds getClientInfoString(redisClient *client);
45e7a1ce 804sds getAllClientsInfoString(void);
c1c9d551 805void rewriteClientCommandVector(redisClient *c, int argc, ...);
4dd444bb 806void rewriteClientCommandArgument(redisClient *c, int i, robj *newval);
3853c168 807unsigned long getClientOutputBufferMemoryUsage(redisClient *c);
7eac2a75 808void freeClientsInAsyncFreeQueue(void);
06b3dced 809void asyncCloseClientOnOutputBufferLimitReached(redisClient *c);
7fe8d49a 810int getClientLimitClassByName(char *name);
811char *getClientLimitClassName(int class);
8b7c3455 812void flushSlavesOutputBuffers(void);
ed4d4f11 813void disconnectSlaves(void);
e2641e09 814
3ab20376
PN
815#ifdef __GNUC__
816void addReplyErrorFormat(redisClient *c, const char *fmt, ...)
817 __attribute__((format(printf, 2, 3)));
818void addReplyStatusFormat(redisClient *c, const char *fmt, ...)
819 __attribute__((format(printf, 2, 3)));
820#else
821void addReplyErrorFormat(redisClient *c, const char *fmt, ...);
822void addReplyStatusFormat(redisClient *c, const char *fmt, ...);
823#endif
824
e2641e09 825/* List data type */
826void listTypeTryConversion(robj *subject, robj *value);
827void listTypePush(robj *subject, robj *value, int where);
828robj *listTypePop(robj *subject, int where);
829unsigned long listTypeLength(robj *subject);
3c08fdae 830listTypeIterator *listTypeInitIterator(robj *subject, long index, unsigned char direction);
e2641e09 831void listTypeReleaseIterator(listTypeIterator *li);
832int listTypeNext(listTypeIterator *li, listTypeEntry *entry);
833robj *listTypeGet(listTypeEntry *entry);
834void listTypeInsert(listTypeEntry *entry, robj *value, int where);
835int listTypeEqual(listTypeEntry *entry, robj *o);
836void listTypeDelete(listTypeEntry *entry);
837void listTypeConvert(robj *subject, int enc);
838void unblockClientWaitingData(redisClient *c);
f444e2af 839void handleClientsBlockedOnLists(void);
e2641e09 840void popGenericCommand(redisClient *c, int where);
841
842/* MULTI/EXEC/WATCH... */
843void unwatchAllKeys(redisClient *c);
844void initClientMultiState(redisClient *c);
845void freeClientMultiState(redisClient *c);
09e2d9ee 846void queueMultiCommand(redisClient *c);
e2641e09 847void touchWatchedKey(redisDb *db, robj *key);
848void touchWatchedKeysOnFlush(int dbid);
05406168 849void discardTransaction(redisClient *c);
41f0f927 850void flagTransaction(redisClient *c);
e2641e09 851
852/* Redis object implementation */
853void decrRefCount(void *o);
854void incrRefCount(robj *o);
4dd444bb 855robj *resetRefCount(robj *obj);
e2641e09 856void freeStringObject(robj *o);
857void freeListObject(robj *o);
858void freeSetObject(robj *o);
859void freeZsetObject(robj *o);
860void freeHashObject(robj *o);
861robj *createObject(int type, void *ptr);
862robj *createStringObject(char *ptr, size_t len);
863robj *dupStringObject(robj *o);
5d081931 864int isObjectRepresentableAsLongLong(robj *o, long long *llongval);
e2641e09 865robj *tryObjectEncoding(robj *o);
866robj *getDecodedObject(robj *o);
867size_t stringObjectLen(robj *o);
e2641e09 868robj *createStringObjectFromLongLong(long long value);
5574b53e 869robj *createStringObjectFromLongDouble(long double value);
e2641e09 870robj *createListObject(void);
871robj *createZiplistObject(void);
872robj *createSetObject(void);
96ffb2fe 873robj *createIntsetObject(void);
e2641e09 874robj *createHashObject(void);
875robj *createZsetObject(void);
9e7cee0e 876robj *createZsetZiplistObject(void);
e2641e09 877int getLongFromObjectOrReply(redisClient *c, robj *o, long *target, const char *msg);
878int checkType(redisClient *c, robj *o, int type);
879int getLongLongFromObjectOrReply(redisClient *c, robj *o, long long *target, const char *msg);
880int getDoubleFromObjectOrReply(redisClient *c, robj *o, double *target, const char *msg);
881int getLongLongFromObject(robj *o, long long *target);
5574b53e 882int getLongDoubleFromObject(robj *o, long double *target);
883int getLongDoubleFromObjectOrReply(redisClient *c, robj *o, long double *target, const char *msg);
e2641e09 884char *strEncoding(int encoding);
885int compareStringObjects(robj *a, robj *b);
886int equalStringObjects(robj *a, robj *b);
ef59a8bc 887unsigned long estimateObjectIdleTime(robj *o);
e2641e09 888
19e61097 889/* Synchronous I/O with timeout */
4ccf671c 890ssize_t syncWrite(int fd, char *ptr, ssize_t size, long long timeout);
891ssize_t syncRead(int fd, char *ptr, ssize_t size, long long timeout);
892ssize_t syncReadLine(int fd, char *ptr, ssize_t size, long long timeout);
19e61097 893
e2641e09 894/* Replication */
895void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc);
e31b615e 896void replicationFeedMonitors(redisClient *c, list *monitors, int dictid, robj **argv, int argc);
e2641e09 897void updateSlavesWaitingBgsave(int bgsaveerr);
f4aa600b 898void replicationCron(void);
e2641e09 899
97e7f8ae 900/* Generic persistence functions */
901void startLoading(FILE *fp);
902void loadingProgress(off_t pos);
903void stopLoading(void);
904
e2641e09 905/* RDB persistence */
2e4b0e77 906#include "rdb.h"
e2641e09 907
908/* AOF persistence */
a3fcd6bc 909void flushAppendOnlyFile(int force);
e2641e09 910void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc);
911void aofRemoveTempFile(pid_t childpid);
912int rewriteAppendOnlyFileBackground(void);
913int loadAppendOnlyFile(char *filename);
914void stopAppendOnly(void);
915int startAppendOnly(void);
36c17a53 916void backgroundRewriteDoneHandler(int exitcode, int bysignal);
edb95253 917void aofRewriteBufferReset(void);
918unsigned long aofRewriteBufferSize(void);
e2641e09 919
920/* Sorted sets data type */
c772d9c6 921
922/* Struct to hold a inclusive/exclusive range spec. */
923typedef struct {
924 double min, max;
925 int minex, maxex; /* are min or max exclusive? */
926} zrangespec;
927
e2641e09 928zskiplist *zslCreate(void);
929void zslFree(zskiplist *zsl);
69ef89f2 930zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj);
8588bfa3 931unsigned char *zzlInsert(unsigned char *zl, robj *ele, double score);
c772d9c6 932int zslDelete(zskiplist *zsl, double score, robj *obj);
933zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec range);
dddf5335
PN
934double zzlGetScore(unsigned char *sptr);
935void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr);
936void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr);
df26a0ae
PN
937unsigned int zsetLength(robj *zobj);
938void zsetConvert(robj *zobj, int encoding);
e2641e09 939
940/* Core functions */
f6b32c14 941int freeMemoryIfNeeded(void);
e2641e09 942int processCommand(redisClient *c);
633a9410 943void setupSignalHandlers(void);
1b1f47c9 944struct redisCommand *lookupCommand(sds name);
945struct redisCommand *lookupCommandByCString(char *s);
ce8b772b 946void call(redisClient *c, int flags);
d8b1228b 947void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc, int flags);
eeb34eff 948void alsoPropagate(struct redisCommand *cmd, int dbid, robj **argv, int argc, int target);
e2641e09 949int prepareForShutdown();
950void redisLog(int level, const char *fmt, ...);
288f811f 951void redisLogRaw(int level, const char *msg);
be4f8ccc 952void redisLogFromHandler(int level, const char *msg);
e2641e09 953void usage();
954void updateDictResizePolicy(void);
955int htNeedsResize(dict *dict);
956void oom(const char *msg);
1b1f47c9 957void populateCommandTable(void);
d7ed7fd2 958void resetCommandTableStats(void);
e2641e09 959
96ffb2fe
PN
960/* Set data type */
961robj *setTypeCreate(robj *value);
962int setTypeAdd(robj *subject, robj *value);
963int setTypeRemove(robj *subject, robj *value);
964int setTypeIsMember(robj *subject, robj *value);
cb72d0f1
PN
965setTypeIterator *setTypeInitIterator(robj *subject);
966void setTypeReleaseIterator(setTypeIterator *si);
1b508da7 967int setTypeNext(setTypeIterator *si, robj **objele, int64_t *llele);
968robj *setTypeNextObject(setTypeIterator *si);
dd48de74 969int setTypeRandomElement(robj *setobj, robj **objele, int64_t *llele);
96ffb2fe
PN
970unsigned long setTypeSize(robj *subject);
971void setTypeConvert(robj *subject, int enc);
972
e2641e09 973/* Hash data type */
ebd85e9a 974void hashTypeConvert(robj *o, int enc);
e2641e09 975void hashTypeTryConversion(robj *subject, robj **argv, int start, int end);
976void hashTypeTryObjectEncoding(robj *subject, robj **o1, robj **o2);
3d24304f 977robj *hashTypeGetObject(robj *o, robj *key);
e2641e09 978int hashTypeExists(robj *o, robj *key);
979int hashTypeSet(robj *o, robj *key, robj *value);
980int hashTypeDelete(robj *o, robj *key);
981unsigned long hashTypeLength(robj *o);
982hashTypeIterator *hashTypeInitIterator(robj *subject);
983void hashTypeReleaseIterator(hashTypeIterator *hi);
984int hashTypeNext(hashTypeIterator *hi);
ebd85e9a
PN
985void hashTypeCurrentFromZiplist(hashTypeIterator *hi, int what,
986 unsigned char **vstr,
987 unsigned int *vlen,
988 long long *vll);
989void hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what, robj **dst);
8c304be3 990robj *hashTypeCurrentObject(hashTypeIterator *hi, int what);
e2641e09 991robj *hashTypeLookupWriteOrCreate(redisClient *c, robj *key);
992
993/* Pub / Sub */
994int pubsubUnsubscribeAllChannels(redisClient *c, int notify);
995int pubsubUnsubscribeAllPatterns(redisClient *c, int notify);
996void freePubsubPattern(void *p);
997int listMatchPubsubPattern(void *a, void *b);
d38ef520 998int pubsubPublishMessage(robj *channel, robj *message);
e2641e09 999
e2641e09 1000/* Configuration */
67c6f0f6 1001void loadServerConfig(char *filename, char *options);
e2641e09 1002void appendServerSaveParams(time_t seconds, int changes);
1003void resetServerSaveParams();
1004
1005/* db.c -- Keyspace access API */
1006int removeExpire(redisDb *db, robj *key);
bcf2995c 1007void propagateExpire(redisDb *db, robj *key);
e2641e09 1008int expireIfNeeded(redisDb *db, robj *key);
7dcc10b6 1009long long getExpire(redisDb *db, robj *key);
1010void setExpire(redisDb *db, robj *key, long long when);
e2641e09 1011robj *lookupKey(redisDb *db, robj *key);
1012robj *lookupKeyRead(redisDb *db, robj *key);
1013robj *lookupKeyWrite(redisDb *db, robj *key);
1014robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply);
1015robj *lookupKeyWriteOrReply(redisClient *c, robj *key, robj *reply);
f85cd526 1016void dbAdd(redisDb *db, robj *key, robj *val);
1017void dbOverwrite(redisDb *db, robj *key, robj *val);
1018void setKey(redisDb *db, robj *key, robj *val);
e2641e09 1019int dbExists(redisDb *db, robj *key);
1020robj *dbRandomKey(redisDb *db);
1021int dbDelete(redisDb *db, robj *key);
1022long long emptyDb();
1023int selectDb(redisClient *c, int id);
cea8c5cd 1024void signalModifiedKey(redisDb *db, robj *key);
1025void signalFlushedDb(int dbid);
484354ff 1026unsigned int GetKeysInSlot(unsigned int hashslot, robj **keys, unsigned int count);
e2641e09 1027
9791f0f8 1028/* API to get key arguments from commands */
1029#define REDIS_GETKEYS_ALL 0
1030#define REDIS_GETKEYS_PRELOAD 1
1031int *getKeysFromCommand(struct redisCommand *cmd, robj **argv, int argc, int *numkeys, int flags);
1032void getKeysFreeResult(int *result);
1033int *noPreloadGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags);
1034int *renameGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags);
1035int *zunionInterGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags);
1036
120ba392 1037/* Sentinel */
1038void initSentinelConfig(void);
1039void initSentinel(void);
1040void sentinelTimer(void);
1041char *sentinelHandleConfiguration(char **argv, int argc);
1042
7585836e 1043/* Scripting */
1044void scriptingInit(void);
1045
e2641e09 1046/* Git SHA1 */
1047char *redisGitSHA1(void);
1048char *redisGitDirty(void);
1049
1050/* Commands prototypes */
1051void authCommand(redisClient *c);
1052void pingCommand(redisClient *c);
1053void echoCommand(redisClient *c);
1054void setCommand(redisClient *c);
1055void setnxCommand(redisClient *c);
1056void setexCommand(redisClient *c);
12d293ca 1057void psetexCommand(redisClient *c);
e2641e09 1058void getCommand(redisClient *c);
1059void delCommand(redisClient *c);
1060void existsCommand(redisClient *c);
3c1bf495
PN
1061void setbitCommand(redisClient *c);
1062void getbitCommand(redisClient *c);
9f9e1cea 1063void setrangeCommand(redisClient *c);
ef11bccc 1064void getrangeCommand(redisClient *c);
e2641e09 1065void incrCommand(redisClient *c);
1066void decrCommand(redisClient *c);
1067void incrbyCommand(redisClient *c);
1068void decrbyCommand(redisClient *c);
5574b53e 1069void incrbyfloatCommand(redisClient *c);
e2641e09 1070void selectCommand(redisClient *c);
1071void randomkeyCommand(redisClient *c);
1072void keysCommand(redisClient *c);
1073void dbsizeCommand(redisClient *c);
1074void lastsaveCommand(redisClient *c);
1075void saveCommand(redisClient *c);
1076void bgsaveCommand(redisClient *c);
1077void bgrewriteaofCommand(redisClient *c);
1078void shutdownCommand(redisClient *c);
1079void moveCommand(redisClient *c);
1080void renameCommand(redisClient *c);
1081void renamenxCommand(redisClient *c);
1082void lpushCommand(redisClient *c);
1083void rpushCommand(redisClient *c);
1084void lpushxCommand(redisClient *c);
1085void rpushxCommand(redisClient *c);
1086void linsertCommand(redisClient *c);
1087void lpopCommand(redisClient *c);
1088void rpopCommand(redisClient *c);
1089void llenCommand(redisClient *c);
1090void lindexCommand(redisClient *c);
1091void lrangeCommand(redisClient *c);
1092void ltrimCommand(redisClient *c);
1093void typeCommand(redisClient *c);
1094void lsetCommand(redisClient *c);
1095void saddCommand(redisClient *c);
1096void sremCommand(redisClient *c);
1097void smoveCommand(redisClient *c);
1098void sismemberCommand(redisClient *c);
1099void scardCommand(redisClient *c);
1100void spopCommand(redisClient *c);
1101void srandmemberCommand(redisClient *c);
1102void sinterCommand(redisClient *c);
1103void sinterstoreCommand(redisClient *c);
1104void sunionCommand(redisClient *c);
1105void sunionstoreCommand(redisClient *c);
1106void sdiffCommand(redisClient *c);
1107void sdiffstoreCommand(redisClient *c);
1108void syncCommand(redisClient *c);
1109void flushdbCommand(redisClient *c);
1110void flushallCommand(redisClient *c);
1111void sortCommand(redisClient *c);
1112void lremCommand(redisClient *c);
8a979f03 1113void rpoplpushCommand(redisClient *c);
e2641e09 1114void infoCommand(redisClient *c);
1115void mgetCommand(redisClient *c);
1116void monitorCommand(redisClient *c);
1117void expireCommand(redisClient *c);
1118void expireatCommand(redisClient *c);
12d293ca 1119void pexpireCommand(redisClient *c);
1120void pexpireatCommand(redisClient *c);
e2641e09 1121void getsetCommand(redisClient *c);
1122void ttlCommand(redisClient *c);
12d293ca 1123void pttlCommand(redisClient *c);
a539d29a 1124void persistCommand(redisClient *c);
e2641e09 1125void slaveofCommand(redisClient *c);
1126void debugCommand(redisClient *c);
1127void msetCommand(redisClient *c);
1128void msetnxCommand(redisClient *c);
1129void zaddCommand(redisClient *c);
1130void zincrbyCommand(redisClient *c);
1131void zrangeCommand(redisClient *c);
1132void zrangebyscoreCommand(redisClient *c);
25bb8a44 1133void zrevrangebyscoreCommand(redisClient *c);
e2641e09 1134void zcountCommand(redisClient *c);
1135void zrevrangeCommand(redisClient *c);
1136void zcardCommand(redisClient *c);
1137void zremCommand(redisClient *c);
1138void zscoreCommand(redisClient *c);
1139void zremrangebyscoreCommand(redisClient *c);
1140void multiCommand(redisClient *c);
1141void execCommand(redisClient *c);
1142void discardCommand(redisClient *c);
1143void blpopCommand(redisClient *c);
1144void brpopCommand(redisClient *c);
b2a7fd0c 1145void brpoplpushCommand(redisClient *c);
e2641e09 1146void appendCommand(redisClient *c);
80091bba 1147void strlenCommand(redisClient *c);
e2641e09 1148void zrankCommand(redisClient *c);
1149void zrevrankCommand(redisClient *c);
1150void hsetCommand(redisClient *c);
1151void hsetnxCommand(redisClient *c);
1152void hgetCommand(redisClient *c);
1153void hmsetCommand(redisClient *c);
1154void hmgetCommand(redisClient *c);
1155void hdelCommand(redisClient *c);
1156void hlenCommand(redisClient *c);
1157void zremrangebyrankCommand(redisClient *c);
1158void zunionstoreCommand(redisClient *c);
1159void zinterstoreCommand(redisClient *c);
1160void hkeysCommand(redisClient *c);
1161void hvalsCommand(redisClient *c);
1162void hgetallCommand(redisClient *c);
1163void hexistsCommand(redisClient *c);
1164void configCommand(redisClient *c);
1165void hincrbyCommand(redisClient *c);
68bfe993 1166void hincrbyfloatCommand(redisClient *c);
e2641e09 1167void subscribeCommand(redisClient *c);
1168void unsubscribeCommand(redisClient *c);
1169void psubscribeCommand(redisClient *c);
1170void punsubscribeCommand(redisClient *c);
1171void publishCommand(redisClient *c);
1172void watchCommand(redisClient *c);
1173void unwatchCommand(redisClient *c);
ecc91094 1174void restoreCommand(redisClient *c);
1175void migrateCommand(redisClient *c);
626f6b2d 1176void dumpCommand(redisClient *c);
ece74202 1177void objectCommand(redisClient *c);
3cd12b56 1178void clientCommand(redisClient *c);
7585836e 1179void evalCommand(redisClient *c);
7229d60d 1180void evalShaCommand(redisClient *c);
070e3945 1181void scriptCommand(redisClient *c);
9494f1f1 1182void timeCommand(redisClient *c);
4a789dec 1183void bitopCommand(redisClient *c);
1184void bitcountCommand(redisClient *c);
dbd8c753 1185void replconfCommand(redisClient *c);
e2641e09 1186
b3aa6d71 1187#if defined(__GNUC__)
b3aa6d71 1188void *calloc(size_t count, size_t size) __attribute__ ((deprecated));
1189void free(void *ptr) __attribute__ ((deprecated));
1190void *malloc(size_t size) __attribute__ ((deprecated));
1191void *realloc(void *ptr, size_t size) __attribute__ ((deprecated));
1192#endif
1193
e3e69935 1194/* Debugging stuff */
bab205f7 1195void _redisAssertWithInfo(redisClient *c, robj *o, char *estr, char *file, int line);
e3e69935 1196void _redisAssert(char *estr, char *file, int line);
1197void _redisPanic(char *msg, char *file, int line);
fa5af017 1198void bugReportStart(void);
00010fa9 1199void redisLogObjectDebugInfo(robj *o);
d4d20859 1200void sigsegvHandler(int sig, siginfo_t *info, void *secret);
1201sds genRedisInfoString(char *section);
fc030ac7 1202void enableWatchdog(int period);
1203void disableWatchdog(void);
1204void watchdogScheduleSignal(int period);
0b8441c1 1205void redisLogHexDump(int level, char *descr, void *value, size_t len);
120ba392 1206
1207#define redisDebug(fmt, ...) \
1208 printf("DEBUG %s:%d > " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)
1209#define redisDebugMark() \
1210 printf("-- MARK %s:%d --\n", __FILE__, __LINE__)
1211
e2641e09 1212#endif