]> git.saurik.com Git - redis.git/blame - redis.c
Merge branch 'issue_191' of git://github.com/gnrfan/redis
[redis.git] / redis.c
CommitLineData
ed9b544e 1/*
12d090d2 2 * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
ed9b544e 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
a9c723ea 30#define REDIS_VERSION "1.3.7"
23d4709d 31
32#include "fmacros.h"
fbf9bcdb 33#include "config.h"
ed9b544e 34
35#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
38#include <time.h>
39#include <unistd.h>
c9468bcf 40#define __USE_POSIX199309
54bac49d 41#define __USE_UNIX98
ed9b544e 42#include <signal.h>
fbf9bcdb 43
44#ifdef HAVE_BACKTRACE
c9468bcf 45#include <execinfo.h>
46#include <ucontext.h>
fbf9bcdb 47#endif /* HAVE_BACKTRACE */
48
ed9b544e 49#include <sys/wait.h>
50#include <errno.h>
51#include <assert.h>
52#include <ctype.h>
53#include <stdarg.h>
54#include <inttypes.h>
55#include <arpa/inet.h>
56#include <sys/stat.h>
57#include <fcntl.h>
58#include <sys/time.h>
59#include <sys/resource.h>
2895e862 60#include <sys/uio.h>
f78fd11b 61#include <limits.h>
a7866db6 62#include <math.h>
92f8e882 63#include <pthread.h>
0bc1b2f6 64
65#if defined(__sun)
5043dff3 66#include "solarisfixes.h"
67#endif
ed9b544e 68
c9468bcf 69#include "redis.h"
ed9b544e 70#include "ae.h" /* Event driven programming library */
71#include "sds.h" /* Dynamic safe strings */
72#include "anet.h" /* Networking the easy way */
73#include "dict.h" /* Hash tables */
74#include "adlist.h" /* Linked lists */
75#include "zmalloc.h" /* total memory usage aware version of malloc/free */
5f5b9840 76#include "lzf.h" /* LZF compression library */
77#include "pqsort.h" /* Partial qsort for SORT+LIMIT */
5234952b 78#include "zipmap.h"
ed9b544e 79
80/* Error codes */
81#define REDIS_OK 0
82#define REDIS_ERR -1
83
84/* Static server configuration */
85#define REDIS_SERVERPORT 6379 /* TCP port */
86#define REDIS_MAXIDLETIME (60*5) /* default client timeout */
6208b3a7 87#define REDIS_IOBUF_LEN 1024
ed9b544e 88#define REDIS_LOADBUF_LEN 1024
93ea3759 89#define REDIS_STATIC_ARGS 4
ed9b544e 90#define REDIS_DEFAULT_DBNUM 16
91#define REDIS_CONFIGLINE_MAX 1024
92#define REDIS_OBJFREELIST_MAX 1000000 /* Max number of objects to cache */
93#define REDIS_MAX_SYNC_TIME 60 /* Slave can't take more to sync */
94754ccc 94#define REDIS_EXPIRELOOKUPS_PER_CRON 100 /* try to expire 100 keys/second */
6f376729 95#define REDIS_MAX_WRITE_PER_EVENT (1024*64)
2895e862 96#define REDIS_REQUEST_MAX_SIZE (1024*1024*256) /* max bytes in inline command */
97
98/* If more then REDIS_WRITEV_THRESHOLD write packets are pending use writev */
99#define REDIS_WRITEV_THRESHOLD 3
100/* Max number of iovecs used for each writev call */
101#define REDIS_WRITEV_IOVEC_COUNT 256
ed9b544e 102
103/* Hash table parameters */
104#define REDIS_HT_MINFILL 10 /* Minimal hash table fill 10% */
ed9b544e 105
106/* Command flags */
3fd78bcd 107#define REDIS_CMD_BULK 1 /* Bulk write command */
108#define REDIS_CMD_INLINE 2 /* Inline command */
109/* REDIS_CMD_DENYOOM reserves a longer comment: all the commands marked with
110 this flags will return an error when the 'maxmemory' option is set in the
111 config file and the server is using more than maxmemory bytes of memory.
112 In short this commands are denied on low memory conditions. */
113#define REDIS_CMD_DENYOOM 4
ed9b544e 114
115/* Object types */
116#define REDIS_STRING 0
117#define REDIS_LIST 1
118#define REDIS_SET 2
1812e024 119#define REDIS_ZSET 3
120#define REDIS_HASH 4
f78fd11b 121
5234952b 122/* Objects encoding. Some kind of objects like Strings and Hashes can be
123 * internally represented in multiple ways. The 'encoding' field of the object
124 * is set to one of this fields for this object. */
942a3961 125#define REDIS_ENCODING_RAW 0 /* Raw representation */
126#define REDIS_ENCODING_INT 1 /* Encoded as integer */
5234952b 127#define REDIS_ENCODING_ZIPMAP 2 /* Encoded as zipmap */
128#define REDIS_ENCODING_HT 3 /* Encoded as an hash table */
942a3961 129
07efaf74 130static char* strencoding[] = {
131 "raw", "int", "zipmap", "hashtable"
132};
133
f78fd11b 134/* Object types only used for dumping to disk */
bb32ede5 135#define REDIS_EXPIRETIME 253
ed9b544e 136#define REDIS_SELECTDB 254
137#define REDIS_EOF 255
138
f78fd11b 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
a4d1ba9a 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.
f78fd11b 149 *
10c43610 150 * Lenghts up to 63 are stored using a single byte, most DB keys, and may
151 * values, will fit inside. */
f78fd11b 152#define REDIS_RDB_6BITLEN 0
153#define REDIS_RDB_14BITLEN 1
154#define REDIS_RDB_32BITLEN 2
17be1a4a 155#define REDIS_RDB_ENCVAL 3
f78fd11b 156#define REDIS_RDB_LENERR UINT_MAX
157
a4d1ba9a 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 */
774e3047 164#define REDIS_RDB_ENC_LZF 3 /* string compressed with FASTLZ */
a4d1ba9a 165
75680a3c 166/* Virtual memory object->where field. */
167#define REDIS_VM_MEMORY 0 /* The object is on memory */
168#define REDIS_VM_SWAPPED 1 /* The object is on disk */
169#define REDIS_VM_SWAPPING 2 /* Redis is swapping this object on disk */
170#define REDIS_VM_LOADING 3 /* Redis is loading this object from disk */
171
06224fec 172/* Virtual memory static configuration stuff.
173 * Check vmFindContiguousPages() to know more about this magic numbers. */
174#define REDIS_VM_MAX_NEAR_PAGES 65536
175#define REDIS_VM_MAX_RANDOM_JUMP 4096
92f8e882 176#define REDIS_VM_MAX_THREADS 32
bcaa7a4f 177#define REDIS_THREAD_STACK_SIZE (1024*1024*4)
f6c0bba8 178/* The following is the *percentage* of completed I/O jobs to process when the
179 * handelr is called. While Virtual Memory I/O operations are performed by
180 * threads, this operations must be processed by the main thread when completed
181 * in order to take effect. */
c953f24b 182#define REDIS_MAX_COMPLETED_JOBS_PROCESSED 1
06224fec 183
ed9b544e 184/* Client flags */
d5d55fc3 185#define REDIS_SLAVE 1 /* This client is a slave server */
186#define REDIS_MASTER 2 /* This client is a master server */
187#define REDIS_MONITOR 4 /* This client is a slave monitor, see MONITOR */
188#define REDIS_MULTI 8 /* This client is in a MULTI context */
189#define REDIS_BLOCKED 16 /* The client is waiting in a blocking operation */
190#define REDIS_IO_WAIT 32 /* The client is waiting for Virtual Memory I/O */
ed9b544e 191
40d224a9 192/* Slave replication state - slave side */
ed9b544e 193#define REDIS_REPL_NONE 0 /* No active replication */
194#define REDIS_REPL_CONNECT 1 /* Must connect to master */
195#define REDIS_REPL_CONNECTED 2 /* Connected to master */
196
40d224a9 197/* Slave replication state - from the point of view of master
198 * Note that in SEND_BULK and ONLINE state the slave receives new updates
199 * in its output queue. In the WAIT_BGSAVE state instead the server is waiting
200 * to start the next background saving in order to send updates to it. */
201#define REDIS_REPL_WAIT_BGSAVE_START 3 /* master waits bgsave to start feeding it */
202#define REDIS_REPL_WAIT_BGSAVE_END 4 /* master waits bgsave to start bulk DB transmission */
203#define REDIS_REPL_SEND_BULK 5 /* master is sending the bulk DB */
204#define REDIS_REPL_ONLINE 6 /* bulk DB already transmitted, receive updates */
205
ed9b544e 206/* List related stuff */
207#define REDIS_HEAD 0
208#define REDIS_TAIL 1
209
210/* Sort operations */
211#define REDIS_SORT_GET 0
443c6409 212#define REDIS_SORT_ASC 1
213#define REDIS_SORT_DESC 2
ed9b544e 214#define REDIS_SORTKEY_MAX 1024
215
216/* Log levels */
217#define REDIS_DEBUG 0
f870935d 218#define REDIS_VERBOSE 1
219#define REDIS_NOTICE 2
220#define REDIS_WARNING 3
ed9b544e 221
222/* Anti-warning macro... */
223#define REDIS_NOTUSED(V) ((void) V)
224
6b47e12e 225#define ZSKIPLIST_MAXLEVEL 32 /* Should be enough for 2^32 elements */
226#define ZSKIPLIST_P 0.25 /* Skiplist P = 1/4 */
ed9b544e 227
48f0308a 228/* Append only defines */
229#define APPENDFSYNC_NO 0
230#define APPENDFSYNC_ALWAYS 1
231#define APPENDFSYNC_EVERYSEC 2
232
cbba7dd7 233/* Hashes related defaults */
234#define REDIS_HASH_MAX_ZIPMAP_ENTRIES 64
235#define REDIS_HASH_MAX_ZIPMAP_VALUE 512
236
dfc5e96c 237/* We can print the stacktrace, so our assert is defined this way: */
478c2c6f 238#define redisAssert(_e) ((_e)?(void)0 : (_redisAssert(#_e,__FILE__,__LINE__),_exit(1)))
6c96ba7d 239static void _redisAssert(char *estr, char *file, int line);
dfc5e96c 240
ed9b544e 241/*================================= Data types ============================== */
242
243/* A redis object, that is a type able to hold a string / list / set */
75680a3c 244
245/* The VM object structure */
246struct redisObjectVM {
3a66edc7 247 off_t page; /* the page at witch the object is stored on disk */
248 off_t usedpages; /* number of pages used on disk */
249 time_t atime; /* Last access time */
75680a3c 250} vm;
251
252/* The actual Redis Object */
ed9b544e 253typedef struct redisObject {
ed9b544e 254 void *ptr;
942a3961 255 unsigned char type;
256 unsigned char encoding;
d894161b 257 unsigned char storage; /* If this object is a key, where is the value?
258 * REDIS_VM_MEMORY, REDIS_VM_SWAPPED, ... */
259 unsigned char vtype; /* If this object is a key, and value is swapped out,
260 * this is the type of the swapped out object. */
ed9b544e 261 int refcount;
75680a3c 262 /* VM fields, this are only allocated if VM is active, otherwise the
263 * object allocation function will just allocate
264 * sizeof(redisObjct) minus sizeof(redisObjectVM), so using
265 * Redis without VM active will not have any overhead. */
266 struct redisObjectVM vm;
ed9b544e 267} robj;
268
dfc5e96c 269/* Macro used to initalize a Redis object allocated on the stack.
270 * Note that this macro is taken near the structure definition to make sure
271 * we'll update it when the structure is changed, to avoid bugs like
272 * bug #85 introduced exactly in this way. */
273#define initStaticStringObject(_var,_ptr) do { \
274 _var.refcount = 1; \
275 _var.type = REDIS_STRING; \
276 _var.encoding = REDIS_ENCODING_RAW; \
277 _var.ptr = _ptr; \
3a66edc7 278 if (server.vm_enabled) _var.storage = REDIS_VM_MEMORY; \
dfc5e96c 279} while(0);
280
3305306f 281typedef struct redisDb {
4409877e 282 dict *dict; /* The keyspace for this DB */
283 dict *expires; /* Timeout of keys with a timeout set */
284 dict *blockingkeys; /* Keys with clients waiting for data (BLPOP) */
d5d55fc3 285 dict *io_keys; /* Keys with clients waiting for VM I/O */
3305306f 286 int id;
287} redisDb;
288
6e469882 289/* Client MULTI/EXEC state */
290typedef struct multiCmd {
291 robj **argv;
292 int argc;
293 struct redisCommand *cmd;
294} multiCmd;
295
296typedef struct multiState {
297 multiCmd *commands; /* Array of MULTI commands */
298 int count; /* Total number of MULTI commands */
299} multiState;
300
ed9b544e 301/* With multiplexing we need to take per-clinet state.
302 * Clients are taken in a liked list. */
303typedef struct redisClient {
304 int fd;
3305306f 305 redisDb *db;
ed9b544e 306 int dictid;
307 sds querybuf;
e8a74421 308 robj **argv, **mbargv;
309 int argc, mbargc;
40d224a9 310 int bulklen; /* bulk read len. -1 if not in bulk read mode */
e8a74421 311 int multibulk; /* multi bulk command format active */
ed9b544e 312 list *reply;
313 int sentlen;
314 time_t lastinteraction; /* time of the last interaction, used for timeout */
d5d55fc3 315 int flags; /* REDIS_SLAVE | REDIS_MONITOR | REDIS_MULTI ... */
40d224a9 316 int slaveseldb; /* slave selected db, if this client is a slave */
317 int authenticated; /* when requirepass is non-NULL */
318 int replstate; /* replication state if this is a slave */
319 int repldbfd; /* replication DB file descriptor */
6e469882 320 long repldboff; /* replication DB file offset */
40d224a9 321 off_t repldbsize; /* replication DB file size */
6e469882 322 multiState mstate; /* MULTI/EXEC state */
d5d55fc3 323 robj **blockingkeys; /* The key we are waiting to terminate a blocking
4409877e 324 * operation such as BLPOP. Otherwise NULL. */
b177fd30 325 int blockingkeysnum; /* Number of blocking keys */
4409877e 326 time_t blockingto; /* Blocking operation timeout. If UNIX current time
327 * is >= blockingto then the operation timed out. */
92f8e882 328 list *io_keys; /* Keys this client is waiting to be loaded from the
329 * swap file in order to continue. */
ed9b544e 330} redisClient;
331
332struct saveparam {
333 time_t seconds;
334 int changes;
335};
336
337/* Global server state structure */
338struct redisServer {
339 int port;
340 int fd;
3305306f 341 redisDb *db;
4409877e 342 dict *sharingpool; /* Poll used for object sharing */
10c43610 343 unsigned int sharingpoolsize;
ed9b544e 344 long long dirty; /* changes to DB from the last save */
345 list *clients;
87eca727 346 list *slaves, *monitors;
ed9b544e 347 char neterr[ANET_ERR_LEN];
348 aeEventLoop *el;
349 int cronloops; /* number of times the cron function run */
350 list *objfreelist; /* A list of freed objects to avoid malloc() */
351 time_t lastsave; /* Unix time of last save succeeede */
ed9b544e 352 /* Fields used only for stats */
353 time_t stat_starttime; /* server start time */
354 long long stat_numcommands; /* number of processed commands */
355 long long stat_numconnections; /* number of connections received */
356 /* Configuration */
357 int verbosity;
358 int glueoutputbuf;
359 int maxidletime;
360 int dbnum;
361 int daemonize;
44b38ef4 362 int appendonly;
48f0308a 363 int appendfsync;
364 time_t lastfsync;
44b38ef4 365 int appendfd;
366 int appendseldb;
ed329fcf 367 char *pidfile;
9f3c422c 368 pid_t bgsavechildpid;
9d65a1bb 369 pid_t bgrewritechildpid;
370 sds bgrewritebuf; /* buffer taken by parent during oppend only rewrite */
ed9b544e 371 struct saveparam *saveparams;
372 int saveparamslen;
373 char *logfile;
374 char *bindaddr;
375 char *dbfilename;
44b38ef4 376 char *appendfilename;
abcb223e 377 char *requirepass;
10c43610 378 int shareobjects;
121f70cf 379 int rdbcompression;
ed9b544e 380 /* Replication related */
381 int isslave;
d0ccebcf 382 char *masterauth;
ed9b544e 383 char *masterhost;
384 int masterport;
40d224a9 385 redisClient *master; /* client that is master for this slave */
ed9b544e 386 int replstate;
285add55 387 unsigned int maxclients;
4ef8de8a 388 unsigned long long maxmemory;
d5d55fc3 389 unsigned int blpop_blocked_clients;
390 unsigned int vm_blocked_clients;
ed9b544e 391 /* Sort parameters - qsort_r() is only available under BSD so we
392 * have to take this state global, in order to pass it to sortCompare() */
393 int sort_desc;
394 int sort_alpha;
395 int sort_bypattern;
75680a3c 396 /* Virtual memory configuration */
397 int vm_enabled;
054e426d 398 char *vm_swap_file;
75680a3c 399 off_t vm_page_size;
400 off_t vm_pages;
4ef8de8a 401 unsigned long long vm_max_memory;
cbba7dd7 402 /* Hashes config */
403 size_t hash_max_zipmap_entries;
404 size_t hash_max_zipmap_value;
75680a3c 405 /* Virtual memory state */
406 FILE *vm_fp;
407 int vm_fd;
408 off_t vm_next_page; /* Next probably empty page */
409 off_t vm_near_pages; /* Number of pages allocated sequentially */
06224fec 410 unsigned char *vm_bitmap; /* Bitmap of free/used pages */
3a66edc7 411 time_t unixtime; /* Unix time sampled every second. */
92f8e882 412 /* Virtual memory I/O threads stuff */
92f8e882 413 /* An I/O thread process an element taken from the io_jobs queue and
996cb5f7 414 * put the result of the operation in the io_done list. While the
415 * job is being processed, it's put on io_processing queue. */
416 list *io_newjobs; /* List of VM I/O jobs yet to be processed */
417 list *io_processing; /* List of VM I/O jobs being processed */
418 list *io_processed; /* List of VM I/O jobs already processed */
d5d55fc3 419 list *io_ready_clients; /* Clients ready to be unblocked. All keys loaded */
996cb5f7 420 pthread_mutex_t io_mutex; /* lock to access io_jobs/io_done/io_thread_job */
a5819310 421 pthread_mutex_t obj_freelist_mutex; /* safe redis objects creation/free */
422 pthread_mutex_t io_swapfile_mutex; /* So we can lseek + write */
bcaa7a4f 423 pthread_attr_t io_threads_attr; /* attributes for threads creation */
92f8e882 424 int io_active_threads; /* Number of running I/O threads */
425 int vm_max_threads; /* Max number of I/O threads running at the same time */
996cb5f7 426 /* Our main thread is blocked on the event loop, locking for sockets ready
427 * to be read or written, so when a threaded I/O operation is ready to be
428 * processed by the main thread, the I/O thread will use a unix pipe to
429 * awake the main thread. The followings are the two pipe FDs. */
430 int io_ready_pipe_read;
431 int io_ready_pipe_write;
7d98e08c 432 /* Virtual memory stats */
433 unsigned long long vm_stats_used_pages;
434 unsigned long long vm_stats_swapped_objects;
435 unsigned long long vm_stats_swapouts;
436 unsigned long long vm_stats_swapins;
b9bc0eef 437 FILE *devnull;
ed9b544e 438};
439
440typedef void redisCommandProc(redisClient *c);
441struct redisCommand {
442 char *name;
443 redisCommandProc *proc;
444 int arity;
445 int flags;
76583ea4
PN
446 /* Use a function to determine which keys need to be loaded
447 * in the background prior to executing this command. Takes precedence
448 * over vm_firstkey and others, ignored when NULL */
449 redisCommandProc *vm_preload_proc;
7c775e09 450 /* What keys should be loaded in background when calling this command? */
451 int vm_firstkey; /* The first argument that's a key (0 = no keys) */
452 int vm_lastkey; /* THe last argument that's a key */
453 int vm_keystep; /* The step between first and last key */
ed9b544e 454};
455
de96dbfe 456struct redisFunctionSym {
457 char *name;
56906eef 458 unsigned long pointer;
de96dbfe 459};
460
ed9b544e 461typedef struct _redisSortObject {
462 robj *obj;
463 union {
464 double score;
465 robj *cmpobj;
466 } u;
467} redisSortObject;
468
469typedef struct _redisSortOperation {
470 int type;
471 robj *pattern;
472} redisSortOperation;
473
6b47e12e 474/* ZSETs use a specialized version of Skiplists */
475
476typedef struct zskiplistNode {
477 struct zskiplistNode **forward;
e3870fab 478 struct zskiplistNode *backward;
912b9165 479 unsigned int *span;
6b47e12e 480 double score;
481 robj *obj;
482} zskiplistNode;
483
484typedef struct zskiplist {
e3870fab 485 struct zskiplistNode *header, *tail;
d13f767c 486 unsigned long length;
6b47e12e 487 int level;
488} zskiplist;
489
1812e024 490typedef struct zset {
491 dict *dict;
6b47e12e 492 zskiplist *zsl;
1812e024 493} zset;
494
6b47e12e 495/* Our shared "common" objects */
496
ed9b544e 497struct sharedObjectsStruct {
c937aa89 498 robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *pong, *space,
6e469882 499 *colon, *nullbulk, *nullmultibulk, *queued,
c937aa89 500 *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
501 *outofrangeerr, *plus,
ed9b544e 502 *select0, *select1, *select2, *select3, *select4,
503 *select5, *select6, *select7, *select8, *select9;
504} shared;
505
a7866db6 506/* Global vars that are actally used as constants. The following double
507 * values are used for double on-disk serialization, and are initialized
508 * at runtime to avoid strange compiler optimizations. */
509
510static double R_Zero, R_PosInf, R_NegInf, R_Nan;
511
92f8e882 512/* VM threaded I/O request message */
b9bc0eef 513#define REDIS_IOJOB_LOAD 0 /* Load from disk to memory */
514#define REDIS_IOJOB_PREPARE_SWAP 1 /* Compute needed pages */
515#define REDIS_IOJOB_DO_SWAP 2 /* Swap from memory to disk */
d5d55fc3 516typedef struct iojob {
996cb5f7 517 int type; /* Request type, REDIS_IOJOB_* */
b9bc0eef 518 redisDb *db;/* Redis database */
92f8e882 519 robj *key; /* This I/O request is about swapping this key */
b9bc0eef 520 robj *val; /* the value to swap for REDIS_IOREQ_*_SWAP, otherwise this
92f8e882 521 * field is populated by the I/O thread for REDIS_IOREQ_LOAD. */
522 off_t page; /* Swap page where to read/write the object */
b9bc0eef 523 off_t pages; /* Swap pages needed to safe object. PREPARE_SWAP return val */
996cb5f7 524 int canceled; /* True if this command was canceled by blocking side of VM */
525 pthread_t thread; /* ID of the thread processing this entry */
526} iojob;
92f8e882 527
ed9b544e 528/*================================ Prototypes =============================== */
529
530static void freeStringObject(robj *o);
531static void freeListObject(robj *o);
532static void freeSetObject(robj *o);
533static void decrRefCount(void *o);
534static robj *createObject(int type, void *ptr);
535static void freeClient(redisClient *c);
f78fd11b 536static int rdbLoad(char *filename);
ed9b544e 537static void addReply(redisClient *c, robj *obj);
538static void addReplySds(redisClient *c, sds s);
539static void incrRefCount(robj *o);
f78fd11b 540static int rdbSaveBackground(char *filename);
ed9b544e 541static robj *createStringObject(char *ptr, size_t len);
4ef8de8a 542static robj *dupStringObject(robj *o);
87eca727 543static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc);
44b38ef4 544static void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc);
ed9b544e 545static int syncWithMaster(void);
10c43610 546static robj *tryObjectSharing(robj *o);
942a3961 547static int tryObjectEncoding(robj *o);
9d65a1bb 548static robj *getDecodedObject(robj *o);
3305306f 549static int removeExpire(redisDb *db, robj *key);
550static int expireIfNeeded(redisDb *db, robj *key);
551static int deleteIfVolatile(redisDb *db, robj *key);
1b03836c 552static int deleteIfSwapped(redisDb *db, robj *key);
94754ccc 553static int deleteKey(redisDb *db, robj *key);
bb32ede5 554static time_t getExpire(redisDb *db, robj *key);
555static int setExpire(redisDb *db, robj *key, time_t when);
a3b21203 556static void updateSlavesWaitingBgsave(int bgsaveerr);
3fd78bcd 557static void freeMemoryIfNeeded(void);
de96dbfe 558static int processCommand(redisClient *c);
56906eef 559static void setupSigSegvAction(void);
a3b21203 560static void rdbRemoveTempFile(pid_t childpid);
9d65a1bb 561static void aofRemoveTempFile(pid_t childpid);
0ea663ea 562static size_t stringObjectLen(robj *o);
638e42ac 563static void processInputBuffer(redisClient *c);
6b47e12e 564static zskiplist *zslCreate(void);
fd8ccf44 565static void zslFree(zskiplist *zsl);
2b59cfdf 566static void zslInsert(zskiplist *zsl, double score, robj *obj);
2895e862 567static void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask);
6e469882 568static void initClientMultiState(redisClient *c);
569static void freeClientMultiState(redisClient *c);
570static void queueMultiCommand(redisClient *c, struct redisCommand *cmd);
b0d8747d 571static void unblockClientWaitingData(redisClient *c);
4409877e 572static int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele);
75680a3c 573static void vmInit(void);
a35ddf12 574static void vmMarkPagesFree(off_t page, off_t count);
55cf8433 575static robj *vmLoadObject(robj *key);
7e69548d 576static robj *vmPreviewObject(robj *key);
a69a0c9c 577static int vmSwapOneObjectBlocking(void);
578static int vmSwapOneObjectThreaded(void);
7e69548d 579static int vmCanSwapOut(void);
a5819310 580static int tryFreeOneObjectFromFreelist(void);
996cb5f7 581static void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
582static void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata, int mask);
583static void vmCancelThreadedIOJob(robj *o);
b9bc0eef 584static void lockThreadedIO(void);
585static void unlockThreadedIO(void);
586static int vmSwapObjectThreaded(robj *key, robj *val, redisDb *db);
587static void freeIOJob(iojob *j);
588static void queueIOJob(iojob *j);
a5819310 589static int vmWriteObjectOnSwap(robj *o, off_t page);
590static robj *vmReadObjectFromSwap(off_t page, int type);
054e426d 591static void waitEmptyIOJobsQueue(void);
592static void vmReopenSwapFile(void);
970e10bb 593static int vmFreePage(off_t page);
76583ea4 594static void zunionInterBlockClientOnSwappedKeys(redisClient *c);
d5d55fc3 595static int blockClientOnSwappedKeys(struct redisCommand *cmd, redisClient *c);
596static int dontWaitForSwappedKey(redisClient *c, robj *key);
597static void handleClientsBlockedOnSwappedKey(redisDb *db, robj *key);
598static void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask);
599static struct redisCommand *lookupCommand(char *name);
600static void call(redisClient *c, struct redisCommand *cmd);
601static void resetClient(redisClient *c);
ada386b2 602static void convertToRealHash(robj *o);
ed9b544e 603
abcb223e 604static void authCommand(redisClient *c);
ed9b544e 605static void pingCommand(redisClient *c);
606static void echoCommand(redisClient *c);
607static void setCommand(redisClient *c);
608static void setnxCommand(redisClient *c);
609static void getCommand(redisClient *c);
610static void delCommand(redisClient *c);
611static void existsCommand(redisClient *c);
612static void incrCommand(redisClient *c);
613static void decrCommand(redisClient *c);
614static void incrbyCommand(redisClient *c);
615static void decrbyCommand(redisClient *c);
616static void selectCommand(redisClient *c);
617static void randomkeyCommand(redisClient *c);
618static void keysCommand(redisClient *c);
619static void dbsizeCommand(redisClient *c);
620static void lastsaveCommand(redisClient *c);
621static void saveCommand(redisClient *c);
622static void bgsaveCommand(redisClient *c);
9d65a1bb 623static void bgrewriteaofCommand(redisClient *c);
ed9b544e 624static void shutdownCommand(redisClient *c);
625static void moveCommand(redisClient *c);
626static void renameCommand(redisClient *c);
627static void renamenxCommand(redisClient *c);
628static void lpushCommand(redisClient *c);
629static void rpushCommand(redisClient *c);
630static void lpopCommand(redisClient *c);
631static void rpopCommand(redisClient *c);
632static void llenCommand(redisClient *c);
633static void lindexCommand(redisClient *c);
634static void lrangeCommand(redisClient *c);
635static void ltrimCommand(redisClient *c);
636static void typeCommand(redisClient *c);
637static void lsetCommand(redisClient *c);
638static void saddCommand(redisClient *c);
639static void sremCommand(redisClient *c);
a4460ef4 640static void smoveCommand(redisClient *c);
ed9b544e 641static void sismemberCommand(redisClient *c);
642static void scardCommand(redisClient *c);
12fea928 643static void spopCommand(redisClient *c);
2abb95a9 644static void srandmemberCommand(redisClient *c);
ed9b544e 645static void sinterCommand(redisClient *c);
646static void sinterstoreCommand(redisClient *c);
40d224a9 647static void sunionCommand(redisClient *c);
648static void sunionstoreCommand(redisClient *c);
f4f56e1d 649static void sdiffCommand(redisClient *c);
650static void sdiffstoreCommand(redisClient *c);
ed9b544e 651static void syncCommand(redisClient *c);
652static void flushdbCommand(redisClient *c);
653static void flushallCommand(redisClient *c);
654static void sortCommand(redisClient *c);
655static void lremCommand(redisClient *c);
0f5f7e9a 656static void rpoplpushcommand(redisClient *c);
ed9b544e 657static void infoCommand(redisClient *c);
70003d28 658static void mgetCommand(redisClient *c);
87eca727 659static void monitorCommand(redisClient *c);
3305306f 660static void expireCommand(redisClient *c);
802e8373 661static void expireatCommand(redisClient *c);
f6b141c5 662static void getsetCommand(redisClient *c);
fd88489a 663static void ttlCommand(redisClient *c);
321b0e13 664static void slaveofCommand(redisClient *c);
7f957c92 665static void debugCommand(redisClient *c);
f6b141c5 666static void msetCommand(redisClient *c);
667static void msetnxCommand(redisClient *c);
fd8ccf44 668static void zaddCommand(redisClient *c);
7db723ad 669static void zincrbyCommand(redisClient *c);
cc812361 670static void zrangeCommand(redisClient *c);
50c55df5 671static void zrangebyscoreCommand(redisClient *c);
f44dd428 672static void zcountCommand(redisClient *c);
e3870fab 673static void zrevrangeCommand(redisClient *c);
3c41331e 674static void zcardCommand(redisClient *c);
1b7106e7 675static void zremCommand(redisClient *c);
6e333bbe 676static void zscoreCommand(redisClient *c);
1807985b 677static void zremrangebyscoreCommand(redisClient *c);
6e469882 678static void multiCommand(redisClient *c);
679static void execCommand(redisClient *c);
18b6cb76 680static void discardCommand(redisClient *c);
4409877e 681static void blpopCommand(redisClient *c);
682static void brpopCommand(redisClient *c);
4b00bebd 683static void appendCommand(redisClient *c);
39191553 684static void substrCommand(redisClient *c);
69d95c3e 685static void zrankCommand(redisClient *c);
798d9e55 686static void zrevrankCommand(redisClient *c);
978c2c94 687static void hsetCommand(redisClient *c);
688static void hgetCommand(redisClient *c);
07efaf74 689static void hdelCommand(redisClient *c);
92b27fe9 690static void hlenCommand(redisClient *c);
9212eafd 691static void zremrangebyrankCommand(redisClient *c);
2830ca53
PN
692static void zunionCommand(redisClient *c);
693static void zinterCommand(redisClient *c);
78409a0f 694static void hkeysCommand(redisClient *c);
695static void hvalsCommand(redisClient *c);
696static void hgetallCommand(redisClient *c);
a86f14b1 697static void hexistsCommand(redisClient *c);
f6b141c5 698
ed9b544e 699/*================================= Globals ================================= */
700
701/* Global vars */
702static struct redisServer server; /* server global state */
703static struct redisCommand cmdTable[] = {
76583ea4
PN
704 {"get",getCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
705 {"set",setCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,0,0,0},
706 {"setnx",setnxCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,0,0,0},
707 {"append",appendCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
708 {"substr",substrCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
709 {"del",delCommand,-2,REDIS_CMD_INLINE,NULL,0,0,0},
710 {"exists",existsCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
711 {"incr",incrCommand,2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
712 {"decr",decrCommand,2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
713 {"mget",mgetCommand,-2,REDIS_CMD_INLINE,NULL,1,-1,1},
714 {"rpush",rpushCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
715 {"lpush",lpushCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
716 {"rpop",rpopCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
717 {"lpop",lpopCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
718 {"brpop",brpopCommand,-3,REDIS_CMD_INLINE,NULL,1,1,1},
719 {"blpop",blpopCommand,-3,REDIS_CMD_INLINE,NULL,1,1,1},
720 {"llen",llenCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
721 {"lindex",lindexCommand,3,REDIS_CMD_INLINE,NULL,1,1,1},
722 {"lset",lsetCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
723 {"lrange",lrangeCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
724 {"ltrim",ltrimCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
725 {"lrem",lremCommand,4,REDIS_CMD_BULK,NULL,1,1,1},
726 {"rpoplpush",rpoplpushcommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,2,1},
727 {"sadd",saddCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
728 {"srem",sremCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
729 {"smove",smoveCommand,4,REDIS_CMD_BULK,NULL,1,2,1},
730 {"sismember",sismemberCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
731 {"scard",scardCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
732 {"spop",spopCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
733 {"srandmember",srandmemberCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
734 {"sinter",sinterCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,-1,1},
735 {"sinterstore",sinterstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,2,-1,1},
736 {"sunion",sunionCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,-1,1},
737 {"sunionstore",sunionstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,2,-1,1},
738 {"sdiff",sdiffCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,-1,1},
739 {"sdiffstore",sdiffstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,2,-1,1},
740 {"smembers",sinterCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
741 {"zadd",zaddCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
742 {"zincrby",zincrbyCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
743 {"zrem",zremCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
744 {"zremrangebyscore",zremrangebyscoreCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
745 {"zremrangebyrank",zremrangebyrankCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
746 {"zunion",zunionCommand,-4,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,zunionInterBlockClientOnSwappedKeys,0,0,0},
747 {"zinter",zinterCommand,-4,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,zunionInterBlockClientOnSwappedKeys,0,0,0},
748 {"zrange",zrangeCommand,-4,REDIS_CMD_INLINE,NULL,1,1,1},
749 {"zrangebyscore",zrangebyscoreCommand,-4,REDIS_CMD_INLINE,NULL,1,1,1},
750 {"zcount",zcountCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
751 {"zrevrange",zrevrangeCommand,-4,REDIS_CMD_INLINE,NULL,1,1,1},
752 {"zcard",zcardCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
753 {"zscore",zscoreCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
754 {"zrank",zrankCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
755 {"zrevrank",zrevrankCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
756 {"hset",hsetCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
757 {"hget",hgetCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
758 {"hdel",hdelCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
759 {"hlen",hlenCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
760 {"hkeys",hkeysCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
761 {"hvals",hvalsCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
762 {"hgetall",hgetallCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
4583c4f0 763 {"hexists",hexistsCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
76583ea4
PN
764 {"incrby",incrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
765 {"decrby",decrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
766 {"getset",getsetCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
767 {"mset",msetCommand,-3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,-1,2},
768 {"msetnx",msetnxCommand,-3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,-1,2},
769 {"randomkey",randomkeyCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
770 {"select",selectCommand,2,REDIS_CMD_INLINE,NULL,0,0,0},
771 {"move",moveCommand,3,REDIS_CMD_INLINE,NULL,1,1,1},
772 {"rename",renameCommand,3,REDIS_CMD_INLINE,NULL,1,1,1},
773 {"renamenx",renamenxCommand,3,REDIS_CMD_INLINE,NULL,1,1,1},
774 {"expire",expireCommand,3,REDIS_CMD_INLINE,NULL,0,0,0},
775 {"expireat",expireatCommand,3,REDIS_CMD_INLINE,NULL,0,0,0},
776 {"keys",keysCommand,2,REDIS_CMD_INLINE,NULL,0,0,0},
777 {"dbsize",dbsizeCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
778 {"auth",authCommand,2,REDIS_CMD_INLINE,NULL,0,0,0},
779 {"ping",pingCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
780 {"echo",echoCommand,2,REDIS_CMD_BULK,NULL,0,0,0},
781 {"save",saveCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
782 {"bgsave",bgsaveCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
783 {"bgrewriteaof",bgrewriteaofCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
784 {"shutdown",shutdownCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
785 {"lastsave",lastsaveCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
786 {"type",typeCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
787 {"multi",multiCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
788 {"exec",execCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
789 {"discard",discardCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
790 {"sync",syncCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
791 {"flushdb",flushdbCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
792 {"flushall",flushallCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
793 {"sort",sortCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
794 {"info",infoCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
795 {"monitor",monitorCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
796 {"ttl",ttlCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
797 {"slaveof",slaveofCommand,3,REDIS_CMD_INLINE,NULL,0,0,0},
798 {"debug",debugCommand,-2,REDIS_CMD_INLINE,NULL,0,0,0},
799 {NULL,NULL,0,0,NULL,0,0,0}
ed9b544e 800};
bcfc686d 801
ed9b544e 802/*============================ Utility functions ============================ */
803
804/* Glob-style pattern matching. */
805int stringmatchlen(const char *pattern, int patternLen,
806 const char *string, int stringLen, int nocase)
807{
808 while(patternLen) {
809 switch(pattern[0]) {
810 case '*':
811 while (pattern[1] == '*') {
812 pattern++;
813 patternLen--;
814 }
815 if (patternLen == 1)
816 return 1; /* match */
817 while(stringLen) {
818 if (stringmatchlen(pattern+1, patternLen-1,
819 string, stringLen, nocase))
820 return 1; /* match */
821 string++;
822 stringLen--;
823 }
824 return 0; /* no match */
825 break;
826 case '?':
827 if (stringLen == 0)
828 return 0; /* no match */
829 string++;
830 stringLen--;
831 break;
832 case '[':
833 {
834 int not, match;
835
836 pattern++;
837 patternLen--;
838 not = pattern[0] == '^';
839 if (not) {
840 pattern++;
841 patternLen--;
842 }
843 match = 0;
844 while(1) {
845 if (pattern[0] == '\\') {
846 pattern++;
847 patternLen--;
848 if (pattern[0] == string[0])
849 match = 1;
850 } else if (pattern[0] == ']') {
851 break;
852 } else if (patternLen == 0) {
853 pattern--;
854 patternLen++;
855 break;
856 } else if (pattern[1] == '-' && patternLen >= 3) {
857 int start = pattern[0];
858 int end = pattern[2];
859 int c = string[0];
860 if (start > end) {
861 int t = start;
862 start = end;
863 end = t;
864 }
865 if (nocase) {
866 start = tolower(start);
867 end = tolower(end);
868 c = tolower(c);
869 }
870 pattern += 2;
871 patternLen -= 2;
872 if (c >= start && c <= end)
873 match = 1;
874 } else {
875 if (!nocase) {
876 if (pattern[0] == string[0])
877 match = 1;
878 } else {
879 if (tolower((int)pattern[0]) == tolower((int)string[0]))
880 match = 1;
881 }
882 }
883 pattern++;
884 patternLen--;
885 }
886 if (not)
887 match = !match;
888 if (!match)
889 return 0; /* no match */
890 string++;
891 stringLen--;
892 break;
893 }
894 case '\\':
895 if (patternLen >= 2) {
896 pattern++;
897 patternLen--;
898 }
899 /* fall through */
900 default:
901 if (!nocase) {
902 if (pattern[0] != string[0])
903 return 0; /* no match */
904 } else {
905 if (tolower((int)pattern[0]) != tolower((int)string[0]))
906 return 0; /* no match */
907 }
908 string++;
909 stringLen--;
910 break;
911 }
912 pattern++;
913 patternLen--;
914 if (stringLen == 0) {
915 while(*pattern == '*') {
916 pattern++;
917 patternLen--;
918 }
919 break;
920 }
921 }
922 if (patternLen == 0 && stringLen == 0)
923 return 1;
924 return 0;
925}
926
56906eef 927static void redisLog(int level, const char *fmt, ...) {
ed9b544e 928 va_list ap;
929 FILE *fp;
930
931 fp = (server.logfile == NULL) ? stdout : fopen(server.logfile,"a");
932 if (!fp) return;
933
934 va_start(ap, fmt);
935 if (level >= server.verbosity) {
6766f45e 936 char *c = ".-*#";
1904ecc1 937 char buf[64];
938 time_t now;
939
940 now = time(NULL);
6c9385e0 941 strftime(buf,64,"%d %b %H:%M:%S",localtime(&now));
054e426d 942 fprintf(fp,"[%d] %s %c ",(int)getpid(),buf,c[level]);
ed9b544e 943 vfprintf(fp, fmt, ap);
944 fprintf(fp,"\n");
945 fflush(fp);
946 }
947 va_end(ap);
948
949 if (server.logfile) fclose(fp);
950}
951
952/*====================== Hash table type implementation ==================== */
953
954/* This is an hash table type that uses the SDS dynamic strings libary as
955 * keys and radis objects as values (objects can hold SDS strings,
956 * lists, sets). */
957
1812e024 958static void dictVanillaFree(void *privdata, void *val)
959{
960 DICT_NOTUSED(privdata);
961 zfree(val);
962}
963
4409877e 964static void dictListDestructor(void *privdata, void *val)
965{
966 DICT_NOTUSED(privdata);
967 listRelease((list*)val);
968}
969
ed9b544e 970static int sdsDictKeyCompare(void *privdata, const void *key1,
971 const void *key2)
972{
973 int l1,l2;
974 DICT_NOTUSED(privdata);
975
976 l1 = sdslen((sds)key1);
977 l2 = sdslen((sds)key2);
978 if (l1 != l2) return 0;
979 return memcmp(key1, key2, l1) == 0;
980}
981
982static void dictRedisObjectDestructor(void *privdata, void *val)
983{
984 DICT_NOTUSED(privdata);
985
a35ddf12 986 if (val == NULL) return; /* Values of swapped out keys as set to NULL */
ed9b544e 987 decrRefCount(val);
988}
989
942a3961 990static int dictObjKeyCompare(void *privdata, const void *key1,
ed9b544e 991 const void *key2)
992{
993 const robj *o1 = key1, *o2 = key2;
994 return sdsDictKeyCompare(privdata,o1->ptr,o2->ptr);
995}
996
942a3961 997static unsigned int dictObjHash(const void *key) {
ed9b544e 998 const robj *o = key;
999 return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
1000}
1001
942a3961 1002static int dictEncObjKeyCompare(void *privdata, const void *key1,
1003 const void *key2)
1004{
9d65a1bb 1005 robj *o1 = (robj*) key1, *o2 = (robj*) key2;
1006 int cmp;
942a3961 1007
2a1198b4 1008 if (o1->encoding == REDIS_ENCODING_INT &&
1009 o2->encoding == REDIS_ENCODING_INT &&
db5946fc 1010 o1->ptr == o2->ptr) return 1;
2a1198b4 1011
9d65a1bb 1012 o1 = getDecodedObject(o1);
1013 o2 = getDecodedObject(o2);
1014 cmp = sdsDictKeyCompare(privdata,o1->ptr,o2->ptr);
1015 decrRefCount(o1);
1016 decrRefCount(o2);
1017 return cmp;
942a3961 1018}
1019
1020static unsigned int dictEncObjHash(const void *key) {
9d65a1bb 1021 robj *o = (robj*) key;
942a3961 1022
ed9e4966 1023 if (o->encoding == REDIS_ENCODING_RAW) {
1024 return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
1025 } else {
1026 if (o->encoding == REDIS_ENCODING_INT) {
1027 char buf[32];
1028 int len;
1029
1030 len = snprintf(buf,32,"%ld",(long)o->ptr);
1031 return dictGenHashFunction((unsigned char*)buf, len);
1032 } else {
1033 unsigned int hash;
1034
1035 o = getDecodedObject(o);
1036 hash = dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
1037 decrRefCount(o);
1038 return hash;
1039 }
1040 }
942a3961 1041}
1042
f2d9f50f 1043/* Sets type and expires */
ed9b544e 1044static dictType setDictType = {
942a3961 1045 dictEncObjHash, /* hash function */
ed9b544e 1046 NULL, /* key dup */
1047 NULL, /* val dup */
942a3961 1048 dictEncObjKeyCompare, /* key compare */
ed9b544e 1049 dictRedisObjectDestructor, /* key destructor */
1050 NULL /* val destructor */
1051};
1052
f2d9f50f 1053/* Sorted sets hash (note: a skiplist is used in addition to the hash table) */
1812e024 1054static dictType zsetDictType = {
1055 dictEncObjHash, /* hash function */
1056 NULL, /* key dup */
1057 NULL, /* val dup */
1058 dictEncObjKeyCompare, /* key compare */
1059 dictRedisObjectDestructor, /* key destructor */
da0a1620 1060 dictVanillaFree /* val destructor of malloc(sizeof(double)) */
1812e024 1061};
1062
f2d9f50f 1063/* Db->dict */
5234952b 1064static dictType dbDictType = {
942a3961 1065 dictObjHash, /* hash function */
ed9b544e 1066 NULL, /* key dup */
1067 NULL, /* val dup */
942a3961 1068 dictObjKeyCompare, /* key compare */
ed9b544e 1069 dictRedisObjectDestructor, /* key destructor */
1070 dictRedisObjectDestructor /* val destructor */
1071};
1072
f2d9f50f 1073/* Db->expires */
1074static dictType keyptrDictType = {
1075 dictObjHash, /* hash function */
1076 NULL, /* key dup */
1077 NULL, /* val dup */
1078 dictObjKeyCompare, /* key compare */
1079 dictRedisObjectDestructor, /* key destructor */
1080 NULL /* val destructor */
1081};
1082
5234952b 1083/* Hash type hash table (note that small hashes are represented with zimpaps) */
1084static dictType hashDictType = {
1085 dictEncObjHash, /* hash function */
1086 NULL, /* key dup */
1087 NULL, /* val dup */
1088 dictEncObjKeyCompare, /* key compare */
1089 dictRedisObjectDestructor, /* key destructor */
1090 dictRedisObjectDestructor /* val destructor */
1091};
1092
4409877e 1093/* Keylist hash table type has unencoded redis objects as keys and
d5d55fc3 1094 * lists as values. It's used for blocking operations (BLPOP) and to
1095 * map swapped keys to a list of clients waiting for this keys to be loaded. */
4409877e 1096static dictType keylistDictType = {
1097 dictObjHash, /* hash function */
1098 NULL, /* key dup */
1099 NULL, /* val dup */
1100 dictObjKeyCompare, /* key compare */
1101 dictRedisObjectDestructor, /* key destructor */
1102 dictListDestructor /* val destructor */
1103};
1104
42ab0172
AO
1105static void version();
1106
ed9b544e 1107/* ========================= Random utility functions ======================= */
1108
1109/* Redis generally does not try to recover from out of memory conditions
1110 * when allocating objects or strings, it is not clear if it will be possible
1111 * to report this condition to the client since the networking layer itself
1112 * is based on heap allocation for send buffers, so we simply abort.
1113 * At least the code will be simpler to read... */
1114static void oom(const char *msg) {
71c54b21 1115 redisLog(REDIS_WARNING, "%s: Out of memory\n",msg);
ed9b544e 1116 sleep(1);
1117 abort();
1118}
1119
1120/* ====================== Redis server networking stuff ===================== */
56906eef 1121static void closeTimedoutClients(void) {
ed9b544e 1122 redisClient *c;
ed9b544e 1123 listNode *ln;
1124 time_t now = time(NULL);
c7df85a4 1125 listIter li;
ed9b544e 1126
c7df85a4 1127 listRewind(server.clients,&li);
1128 while ((ln = listNext(&li)) != NULL) {
ed9b544e 1129 c = listNodeValue(ln);
f86a74e9 1130 if (server.maxidletime &&
1131 !(c->flags & REDIS_SLAVE) && /* no timeout for slaves */
c7cf2ec9 1132 !(c->flags & REDIS_MASTER) && /* no timeout for masters */
f86a74e9 1133 (now - c->lastinteraction > server.maxidletime))
1134 {
f870935d 1135 redisLog(REDIS_VERBOSE,"Closing idle client");
ed9b544e 1136 freeClient(c);
f86a74e9 1137 } else if (c->flags & REDIS_BLOCKED) {
58d976b8 1138 if (c->blockingto != 0 && c->blockingto < now) {
b177fd30 1139 addReply(c,shared.nullmultibulk);
b0d8747d 1140 unblockClientWaitingData(c);
f86a74e9 1141 }
ed9b544e 1142 }
1143 }
ed9b544e 1144}
1145
12fea928 1146static int htNeedsResize(dict *dict) {
1147 long long size, used;
1148
1149 size = dictSlots(dict);
1150 used = dictSize(dict);
1151 return (size && used && size > DICT_HT_INITIAL_SIZE &&
1152 (used*100/size < REDIS_HT_MINFILL));
1153}
1154
0bc03378 1155/* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
1156 * we resize the hash table to save memory */
56906eef 1157static void tryResizeHashTables(void) {
0bc03378 1158 int j;
1159
1160 for (j = 0; j < server.dbnum; j++) {
12fea928 1161 if (htNeedsResize(server.db[j].dict)) {
f870935d 1162 redisLog(REDIS_VERBOSE,"The hash table %d is too sparse, resize it...",j);
0bc03378 1163 dictResize(server.db[j].dict);
f870935d 1164 redisLog(REDIS_VERBOSE,"Hash table %d resized.",j);
0bc03378 1165 }
12fea928 1166 if (htNeedsResize(server.db[j].expires))
1167 dictResize(server.db[j].expires);
0bc03378 1168 }
1169}
1170
9d65a1bb 1171/* A background saving child (BGSAVE) terminated its work. Handle this. */
1172void backgroundSaveDoneHandler(int statloc) {
1173 int exitcode = WEXITSTATUS(statloc);
1174 int bysignal = WIFSIGNALED(statloc);
1175
1176 if (!bysignal && exitcode == 0) {
1177 redisLog(REDIS_NOTICE,
1178 "Background saving terminated with success");
1179 server.dirty = 0;
1180 server.lastsave = time(NULL);
1181 } else if (!bysignal && exitcode != 0) {
1182 redisLog(REDIS_WARNING, "Background saving error");
1183 } else {
1184 redisLog(REDIS_WARNING,
1185 "Background saving terminated by signal");
1186 rdbRemoveTempFile(server.bgsavechildpid);
1187 }
1188 server.bgsavechildpid = -1;
1189 /* Possibly there are slaves waiting for a BGSAVE in order to be served
1190 * (the first stage of SYNC is a bulk transfer of dump.rdb) */
1191 updateSlavesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR);
1192}
1193
1194/* A background append only file rewriting (BGREWRITEAOF) terminated its work.
1195 * Handle this. */
1196void backgroundRewriteDoneHandler(int statloc) {
1197 int exitcode = WEXITSTATUS(statloc);
1198 int bysignal = WIFSIGNALED(statloc);
1199
1200 if (!bysignal && exitcode == 0) {
1201 int fd;
1202 char tmpfile[256];
1203
1204 redisLog(REDIS_NOTICE,
1205 "Background append only file rewriting terminated with success");
1206 /* Now it's time to flush the differences accumulated by the parent */
1207 snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) server.bgrewritechildpid);
1208 fd = open(tmpfile,O_WRONLY|O_APPEND);
1209 if (fd == -1) {
1210 redisLog(REDIS_WARNING, "Not able to open the temp append only file produced by the child: %s", strerror(errno));
1211 goto cleanup;
1212 }
1213 /* Flush our data... */
1214 if (write(fd,server.bgrewritebuf,sdslen(server.bgrewritebuf)) !=
1215 (signed) sdslen(server.bgrewritebuf)) {
1216 redisLog(REDIS_WARNING, "Error or short write trying to flush the parent diff of the append log file in the child temp file: %s", strerror(errno));
1217 close(fd);
1218 goto cleanup;
1219 }
b32627cd 1220 redisLog(REDIS_NOTICE,"Parent diff flushed into the new append log file with success (%lu bytes)",sdslen(server.bgrewritebuf));
9d65a1bb 1221 /* Now our work is to rename the temp file into the stable file. And
1222 * switch the file descriptor used by the server for append only. */
1223 if (rename(tmpfile,server.appendfilename) == -1) {
1224 redisLog(REDIS_WARNING,"Can't rename the temp append only file into the stable one: %s", strerror(errno));
1225 close(fd);
1226 goto cleanup;
1227 }
1228 /* Mission completed... almost */
1229 redisLog(REDIS_NOTICE,"Append only file successfully rewritten.");
1230 if (server.appendfd != -1) {
1231 /* If append only is actually enabled... */
1232 close(server.appendfd);
1233 server.appendfd = fd;
1234 fsync(fd);
85a83172 1235 server.appendseldb = -1; /* Make sure it will issue SELECT */
9d65a1bb 1236 redisLog(REDIS_NOTICE,"The new append only file was selected for future appends.");
1237 } else {
1238 /* If append only is disabled we just generate a dump in this
1239 * format. Why not? */
1240 close(fd);
1241 }
1242 } else if (!bysignal && exitcode != 0) {
1243 redisLog(REDIS_WARNING, "Background append only file rewriting error");
1244 } else {
1245 redisLog(REDIS_WARNING,
1246 "Background append only file rewriting terminated by signal");
1247 }
1248cleanup:
1249 sdsfree(server.bgrewritebuf);
1250 server.bgrewritebuf = sdsempty();
1251 aofRemoveTempFile(server.bgrewritechildpid);
1252 server.bgrewritechildpid = -1;
1253}
1254
56906eef 1255static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
94754ccc 1256 int j, loops = server.cronloops++;
ed9b544e 1257 REDIS_NOTUSED(eventLoop);
1258 REDIS_NOTUSED(id);
1259 REDIS_NOTUSED(clientData);
1260
3a66edc7 1261 /* We take a cached value of the unix time in the global state because
1262 * with virtual memory and aging there is to store the current time
1263 * in objects at every object access, and accuracy is not needed.
1264 * To access a global var is faster than calling time(NULL) */
1265 server.unixtime = time(NULL);
1266
0bc03378 1267 /* Show some info about non-empty databases */
ed9b544e 1268 for (j = 0; j < server.dbnum; j++) {
dec423d9 1269 long long size, used, vkeys;
94754ccc 1270
3305306f 1271 size = dictSlots(server.db[j].dict);
1272 used = dictSize(server.db[j].dict);
94754ccc 1273 vkeys = dictSize(server.db[j].expires);
c3cb078d 1274 if (!(loops % 5) && (used || vkeys)) {
f870935d 1275 redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
a4d1ba9a 1276 /* dictPrintStats(server.dict); */
ed9b544e 1277 }
ed9b544e 1278 }
1279
0bc03378 1280 /* We don't want to resize the hash tables while a bacground saving
1281 * is in progress: the saving child is created using fork() that is
1282 * implemented with a copy-on-write semantic in most modern systems, so
1283 * if we resize the HT while there is the saving child at work actually
1284 * a lot of memory movements in the parent will cause a lot of pages
1285 * copied. */
9d65a1bb 1286 if (server.bgsavechildpid == -1) tryResizeHashTables();
0bc03378 1287
ed9b544e 1288 /* Show information about connected clients */
1289 if (!(loops % 5)) {
f870935d 1290 redisLog(REDIS_VERBOSE,"%d clients connected (%d slaves), %zu bytes in use, %d shared objects",
ed9b544e 1291 listLength(server.clients)-listLength(server.slaves),
1292 listLength(server.slaves),
b72f6a4b 1293 zmalloc_used_memory(),
3305306f 1294 dictSize(server.sharingpool));
ed9b544e 1295 }
1296
1297 /* Close connections of timedout clients */
d5d55fc3 1298 if ((server.maxidletime && !(loops % 10)) || server.blpop_blocked_clients)
ed9b544e 1299 closeTimedoutClients();
1300
9d65a1bb 1301 /* Check if a background saving or AOF rewrite in progress terminated */
1302 if (server.bgsavechildpid != -1 || server.bgrewritechildpid != -1) {
ed9b544e 1303 int statloc;
9d65a1bb 1304 pid_t pid;
1305
1306 if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
1307 if (pid == server.bgsavechildpid) {
1308 backgroundSaveDoneHandler(statloc);
ed9b544e 1309 } else {
9d65a1bb 1310 backgroundRewriteDoneHandler(statloc);
ed9b544e 1311 }
ed9b544e 1312 }
1313 } else {
1314 /* If there is not a background saving in progress check if
1315 * we have to save now */
1316 time_t now = time(NULL);
1317 for (j = 0; j < server.saveparamslen; j++) {
1318 struct saveparam *sp = server.saveparams+j;
1319
1320 if (server.dirty >= sp->changes &&
1321 now-server.lastsave > sp->seconds) {
1322 redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
1323 sp->changes, sp->seconds);
f78fd11b 1324 rdbSaveBackground(server.dbfilename);
ed9b544e 1325 break;
1326 }
1327 }
1328 }
94754ccc 1329
f2324293 1330 /* Try to expire a few timed out keys. The algorithm used is adaptive and
1331 * will use few CPU cycles if there are few expiring keys, otherwise
1332 * it will get more aggressive to avoid that too much memory is used by
1333 * keys that can be removed from the keyspace. */
94754ccc 1334 for (j = 0; j < server.dbnum; j++) {
f2324293 1335 int expired;
94754ccc 1336 redisDb *db = server.db+j;
94754ccc 1337
f2324293 1338 /* Continue to expire if at the end of the cycle more than 25%
1339 * of the keys were expired. */
1340 do {
4ef8de8a 1341 long num = dictSize(db->expires);
94754ccc 1342 time_t now = time(NULL);
1343
f2324293 1344 expired = 0;
94754ccc 1345 if (num > REDIS_EXPIRELOOKUPS_PER_CRON)
1346 num = REDIS_EXPIRELOOKUPS_PER_CRON;
1347 while (num--) {
1348 dictEntry *de;
1349 time_t t;
1350
1351 if ((de = dictGetRandomKey(db->expires)) == NULL) break;
1352 t = (time_t) dictGetEntryVal(de);
1353 if (now > t) {
1354 deleteKey(db,dictGetEntryKey(de));
f2324293 1355 expired++;
94754ccc 1356 }
1357 }
f2324293 1358 } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4);
94754ccc 1359 }
1360
4ef8de8a 1361 /* Swap a few keys on disk if we are over the memory limit and VM
f870935d 1362 * is enbled. Try to free objects from the free list first. */
7e69548d 1363 if (vmCanSwapOut()) {
1364 while (server.vm_enabled && zmalloc_used_memory() >
f870935d 1365 server.vm_max_memory)
1366 {
72e9fd40 1367 int retval;
1368
a5819310 1369 if (tryFreeOneObjectFromFreelist() == REDIS_OK) continue;
72e9fd40 1370 retval = (server.vm_max_threads == 0) ?
1371 vmSwapOneObjectBlocking() :
1372 vmSwapOneObjectThreaded();
1373 if (retval == REDIS_ERR && (loops % 30) == 0 &&
1374 zmalloc_used_memory() >
1375 (server.vm_max_memory+server.vm_max_memory/10))
1376 {
1377 redisLog(REDIS_WARNING,"WARNING: vm-max-memory limit exceeded by more than 10%% but unable to swap more objects out!");
7e69548d 1378 }
72e9fd40 1379 /* Note that when using threade I/O we free just one object,
1380 * because anyway when the I/O thread in charge to swap this
1381 * object out will finish, the handler of completed jobs
1382 * will try to swap more objects if we are still out of memory. */
1383 if (retval == REDIS_ERR || server.vm_max_threads > 0) break;
4ef8de8a 1384 }
1385 }
1386
ed9b544e 1387 /* Check if we should connect to a MASTER */
1388 if (server.replstate == REDIS_REPL_CONNECT) {
1389 redisLog(REDIS_NOTICE,"Connecting to MASTER...");
1390 if (syncWithMaster() == REDIS_OK) {
1391 redisLog(REDIS_NOTICE,"MASTER <-> SLAVE sync succeeded");
1392 }
1393 }
1394 return 1000;
1395}
1396
d5d55fc3 1397/* This function gets called every time Redis is entering the
1398 * main loop of the event driven library, that is, before to sleep
1399 * for ready file descriptors. */
1400static void beforeSleep(struct aeEventLoop *eventLoop) {
1401 REDIS_NOTUSED(eventLoop);
1402
1403 if (server.vm_enabled && listLength(server.io_ready_clients)) {
1404 listIter li;
1405 listNode *ln;
1406
1407 listRewind(server.io_ready_clients,&li);
1408 while((ln = listNext(&li))) {
1409 redisClient *c = ln->value;
1410 struct redisCommand *cmd;
1411
1412 /* Resume the client. */
1413 listDelNode(server.io_ready_clients,ln);
1414 c->flags &= (~REDIS_IO_WAIT);
1415 server.vm_blocked_clients--;
1416 aeCreateFileEvent(server.el, c->fd, AE_READABLE,
1417 readQueryFromClient, c);
1418 cmd = lookupCommand(c->argv[0]->ptr);
1419 assert(cmd != NULL);
1420 call(c,cmd);
1421 resetClient(c);
1422 /* There may be more data to process in the input buffer. */
1423 if (c->querybuf && sdslen(c->querybuf) > 0)
1424 processInputBuffer(c);
1425 }
1426 }
1427}
1428
ed9b544e 1429static void createSharedObjects(void) {
1430 shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
1431 shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
1432 shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
c937aa89 1433 shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
1434 shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
1435 shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
1436 shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
1437 shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
1438 shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
ed9b544e 1439 shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
6e469882 1440 shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n"));
ed9b544e 1441 shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
1442 "-ERR Operation against a key holding the wrong kind of value\r\n"));
ed9b544e 1443 shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
1444 "-ERR no such key\r\n"));
ed9b544e 1445 shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
1446 "-ERR syntax error\r\n"));
c937aa89 1447 shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
1448 "-ERR source and destination objects are the same\r\n"));
1449 shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
1450 "-ERR index out of range\r\n"));
ed9b544e 1451 shared.space = createObject(REDIS_STRING,sdsnew(" "));
c937aa89 1452 shared.colon = createObject(REDIS_STRING,sdsnew(":"));
1453 shared.plus = createObject(REDIS_STRING,sdsnew("+"));
ed9b544e 1454 shared.select0 = createStringObject("select 0\r\n",10);
1455 shared.select1 = createStringObject("select 1\r\n",10);
1456 shared.select2 = createStringObject("select 2\r\n",10);
1457 shared.select3 = createStringObject("select 3\r\n",10);
1458 shared.select4 = createStringObject("select 4\r\n",10);
1459 shared.select5 = createStringObject("select 5\r\n",10);
1460 shared.select6 = createStringObject("select 6\r\n",10);
1461 shared.select7 = createStringObject("select 7\r\n",10);
1462 shared.select8 = createStringObject("select 8\r\n",10);
1463 shared.select9 = createStringObject("select 9\r\n",10);
1464}
1465
1466static void appendServerSaveParams(time_t seconds, int changes) {
1467 server.saveparams = zrealloc(server.saveparams,sizeof(struct saveparam)*(server.saveparamslen+1));
ed9b544e 1468 server.saveparams[server.saveparamslen].seconds = seconds;
1469 server.saveparams[server.saveparamslen].changes = changes;
1470 server.saveparamslen++;
1471}
1472
bcfc686d 1473static void resetServerSaveParams() {
ed9b544e 1474 zfree(server.saveparams);
1475 server.saveparams = NULL;
1476 server.saveparamslen = 0;
1477}
1478
1479static void initServerConfig() {
1480 server.dbnum = REDIS_DEFAULT_DBNUM;
1481 server.port = REDIS_SERVERPORT;
f870935d 1482 server.verbosity = REDIS_VERBOSE;
ed9b544e 1483 server.maxidletime = REDIS_MAXIDLETIME;
1484 server.saveparams = NULL;
1485 server.logfile = NULL; /* NULL = log on standard output */
1486 server.bindaddr = NULL;
1487 server.glueoutputbuf = 1;
1488 server.daemonize = 0;
44b38ef4 1489 server.appendonly = 0;
4e141d5a 1490 server.appendfsync = APPENDFSYNC_ALWAYS;
48f0308a 1491 server.lastfsync = time(NULL);
44b38ef4 1492 server.appendfd = -1;
1493 server.appendseldb = -1; /* Make sure the first time will not match */
ed329fcf 1494 server.pidfile = "/var/run/redis.pid";
ed9b544e 1495 server.dbfilename = "dump.rdb";
9d65a1bb 1496 server.appendfilename = "appendonly.aof";
abcb223e 1497 server.requirepass = NULL;
10c43610 1498 server.shareobjects = 0;
b0553789 1499 server.rdbcompression = 1;
21aecf4b 1500 server.sharingpoolsize = 1024;
285add55 1501 server.maxclients = 0;
d5d55fc3 1502 server.blpop_blocked_clients = 0;
3fd78bcd 1503 server.maxmemory = 0;
75680a3c 1504 server.vm_enabled = 0;
054e426d 1505 server.vm_swap_file = zstrdup("/tmp/redis-%p.vm");
75680a3c 1506 server.vm_page_size = 256; /* 256 bytes per page */
1507 server.vm_pages = 1024*1024*100; /* 104 millions of pages */
1508 server.vm_max_memory = 1024LL*1024*1024*1; /* 1 GB of RAM */
92f8e882 1509 server.vm_max_threads = 4;
d5d55fc3 1510 server.vm_blocked_clients = 0;
cbba7dd7 1511 server.hash_max_zipmap_entries = REDIS_HASH_MAX_ZIPMAP_ENTRIES;
1512 server.hash_max_zipmap_value = REDIS_HASH_MAX_ZIPMAP_VALUE;
75680a3c 1513
bcfc686d 1514 resetServerSaveParams();
ed9b544e 1515
1516 appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
1517 appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
1518 appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
1519 /* Replication related */
1520 server.isslave = 0;
d0ccebcf 1521 server.masterauth = NULL;
ed9b544e 1522 server.masterhost = NULL;
1523 server.masterport = 6379;
1524 server.master = NULL;
1525 server.replstate = REDIS_REPL_NONE;
a7866db6 1526
1527 /* Double constants initialization */
1528 R_Zero = 0.0;
1529 R_PosInf = 1.0/R_Zero;
1530 R_NegInf = -1.0/R_Zero;
1531 R_Nan = R_Zero/R_Zero;
ed9b544e 1532}
1533
1534static void initServer() {
1535 int j;
1536
1537 signal(SIGHUP, SIG_IGN);
1538 signal(SIGPIPE, SIG_IGN);
fe3bbfbe 1539 setupSigSegvAction();
ed9b544e 1540
b9bc0eef 1541 server.devnull = fopen("/dev/null","w");
1542 if (server.devnull == NULL) {
1543 redisLog(REDIS_WARNING, "Can't open /dev/null: %s", server.neterr);
1544 exit(1);
1545 }
ed9b544e 1546 server.clients = listCreate();
1547 server.slaves = listCreate();
87eca727 1548 server.monitors = listCreate();
ed9b544e 1549 server.objfreelist = listCreate();
1550 createSharedObjects();
1551 server.el = aeCreateEventLoop();
3305306f 1552 server.db = zmalloc(sizeof(redisDb)*server.dbnum);
10c43610 1553 server.sharingpool = dictCreate(&setDictType,NULL);
ed9b544e 1554 server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr);
1555 if (server.fd == -1) {
1556 redisLog(REDIS_WARNING, "Opening TCP port: %s", server.neterr);
1557 exit(1);
1558 }
3305306f 1559 for (j = 0; j < server.dbnum; j++) {
5234952b 1560 server.db[j].dict = dictCreate(&dbDictType,NULL);
f2d9f50f 1561 server.db[j].expires = dictCreate(&keyptrDictType,NULL);
4409877e 1562 server.db[j].blockingkeys = dictCreate(&keylistDictType,NULL);
d5d55fc3 1563 if (server.vm_enabled)
1564 server.db[j].io_keys = dictCreate(&keylistDictType,NULL);
3305306f 1565 server.db[j].id = j;
1566 }
ed9b544e 1567 server.cronloops = 0;
9f3c422c 1568 server.bgsavechildpid = -1;
9d65a1bb 1569 server.bgrewritechildpid = -1;
1570 server.bgrewritebuf = sdsempty();
ed9b544e 1571 server.lastsave = time(NULL);
1572 server.dirty = 0;
ed9b544e 1573 server.stat_numcommands = 0;
1574 server.stat_numconnections = 0;
1575 server.stat_starttime = time(NULL);
3a66edc7 1576 server.unixtime = time(NULL);
d8f8b666 1577 aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL);
996cb5f7 1578 if (aeCreateFileEvent(server.el, server.fd, AE_READABLE,
1579 acceptHandler, NULL) == AE_ERR) oom("creating file event");
44b38ef4 1580
1581 if (server.appendonly) {
71eba477 1582 server.appendfd = open(server.appendfilename,O_WRONLY|O_APPEND|O_CREAT,0644);
44b38ef4 1583 if (server.appendfd == -1) {
1584 redisLog(REDIS_WARNING, "Can't open the append-only file: %s",
1585 strerror(errno));
1586 exit(1);
1587 }
1588 }
75680a3c 1589
1590 if (server.vm_enabled) vmInit();
ed9b544e 1591}
1592
1593/* Empty the whole database */
ca37e9cd 1594static long long emptyDb() {
ed9b544e 1595 int j;
ca37e9cd 1596 long long removed = 0;
ed9b544e 1597
3305306f 1598 for (j = 0; j < server.dbnum; j++) {
ca37e9cd 1599 removed += dictSize(server.db[j].dict);
3305306f 1600 dictEmpty(server.db[j].dict);
1601 dictEmpty(server.db[j].expires);
1602 }
ca37e9cd 1603 return removed;
ed9b544e 1604}
1605
85dd2f3a 1606static int yesnotoi(char *s) {
1607 if (!strcasecmp(s,"yes")) return 1;
1608 else if (!strcasecmp(s,"no")) return 0;
1609 else return -1;
1610}
1611
ed9b544e 1612/* I agree, this is a very rudimental way to load a configuration...
1613 will improve later if the config gets more complex */
1614static void loadServerConfig(char *filename) {
c9a111ac 1615 FILE *fp;
ed9b544e 1616 char buf[REDIS_CONFIGLINE_MAX+1], *err = NULL;
1617 int linenum = 0;
1618 sds line = NULL;
c9a111ac 1619
1620 if (filename[0] == '-' && filename[1] == '\0')
1621 fp = stdin;
1622 else {
1623 if ((fp = fopen(filename,"r")) == NULL) {
1624 redisLog(REDIS_WARNING,"Fatal error, can't open config file");
1625 exit(1);
1626 }
ed9b544e 1627 }
c9a111ac 1628
ed9b544e 1629 while(fgets(buf,REDIS_CONFIGLINE_MAX+1,fp) != NULL) {
1630 sds *argv;
1631 int argc, j;
1632
1633 linenum++;
1634 line = sdsnew(buf);
1635 line = sdstrim(line," \t\r\n");
1636
1637 /* Skip comments and blank lines*/
1638 if (line[0] == '#' || line[0] == '\0') {
1639 sdsfree(line);
1640 continue;
1641 }
1642
1643 /* Split into arguments */
1644 argv = sdssplitlen(line,sdslen(line)," ",1,&argc);
1645 sdstolower(argv[0]);
1646
1647 /* Execute config directives */
bb0b03a3 1648 if (!strcasecmp(argv[0],"timeout") && argc == 2) {
ed9b544e 1649 server.maxidletime = atoi(argv[1]);
0150db36 1650 if (server.maxidletime < 0) {
ed9b544e 1651 err = "Invalid timeout value"; goto loaderr;
1652 }
bb0b03a3 1653 } else if (!strcasecmp(argv[0],"port") && argc == 2) {
ed9b544e 1654 server.port = atoi(argv[1]);
1655 if (server.port < 1 || server.port > 65535) {
1656 err = "Invalid port"; goto loaderr;
1657 }
bb0b03a3 1658 } else if (!strcasecmp(argv[0],"bind") && argc == 2) {
ed9b544e 1659 server.bindaddr = zstrdup(argv[1]);
bb0b03a3 1660 } else if (!strcasecmp(argv[0],"save") && argc == 3) {
ed9b544e 1661 int seconds = atoi(argv[1]);
1662 int changes = atoi(argv[2]);
1663 if (seconds < 1 || changes < 0) {
1664 err = "Invalid save parameters"; goto loaderr;
1665 }
1666 appendServerSaveParams(seconds,changes);
bb0b03a3 1667 } else if (!strcasecmp(argv[0],"dir") && argc == 2) {
ed9b544e 1668 if (chdir(argv[1]) == -1) {
1669 redisLog(REDIS_WARNING,"Can't chdir to '%s': %s",
1670 argv[1], strerror(errno));
1671 exit(1);
1672 }
bb0b03a3 1673 } else if (!strcasecmp(argv[0],"loglevel") && argc == 2) {
1674 if (!strcasecmp(argv[1],"debug")) server.verbosity = REDIS_DEBUG;
f870935d 1675 else if (!strcasecmp(argv[1],"verbose")) server.verbosity = REDIS_VERBOSE;
bb0b03a3 1676 else if (!strcasecmp(argv[1],"notice")) server.verbosity = REDIS_NOTICE;
1677 else if (!strcasecmp(argv[1],"warning")) server.verbosity = REDIS_WARNING;
ed9b544e 1678 else {
1679 err = "Invalid log level. Must be one of debug, notice, warning";
1680 goto loaderr;
1681 }
bb0b03a3 1682 } else if (!strcasecmp(argv[0],"logfile") && argc == 2) {
c9a111ac 1683 FILE *logfp;
ed9b544e 1684
1685 server.logfile = zstrdup(argv[1]);
bb0b03a3 1686 if (!strcasecmp(server.logfile,"stdout")) {
ed9b544e 1687 zfree(server.logfile);
1688 server.logfile = NULL;
1689 }
1690 if (server.logfile) {
1691 /* Test if we are able to open the file. The server will not
1692 * be able to abort just for this problem later... */
c9a111ac 1693 logfp = fopen(server.logfile,"a");
1694 if (logfp == NULL) {
ed9b544e 1695 err = sdscatprintf(sdsempty(),
1696 "Can't open the log file: %s", strerror(errno));
1697 goto loaderr;
1698 }
c9a111ac 1699 fclose(logfp);
ed9b544e 1700 }
bb0b03a3 1701 } else if (!strcasecmp(argv[0],"databases") && argc == 2) {
ed9b544e 1702 server.dbnum = atoi(argv[1]);
1703 if (server.dbnum < 1) {
1704 err = "Invalid number of databases"; goto loaderr;
1705 }
b3f83f12
JZ
1706 } else if (!strcasecmp(argv[0],"include") && argc == 2) {
1707 loadServerConfig(argv[1]);
285add55 1708 } else if (!strcasecmp(argv[0],"maxclients") && argc == 2) {
1709 server.maxclients = atoi(argv[1]);
3fd78bcd 1710 } else if (!strcasecmp(argv[0],"maxmemory") && argc == 2) {
d4465900 1711 server.maxmemory = strtoll(argv[1], NULL, 10);
bb0b03a3 1712 } else if (!strcasecmp(argv[0],"slaveof") && argc == 3) {
ed9b544e 1713 server.masterhost = sdsnew(argv[1]);
1714 server.masterport = atoi(argv[2]);
1715 server.replstate = REDIS_REPL_CONNECT;
d0ccebcf 1716 } else if (!strcasecmp(argv[0],"masterauth") && argc == 2) {
1717 server.masterauth = zstrdup(argv[1]);
bb0b03a3 1718 } else if (!strcasecmp(argv[0],"glueoutputbuf") && argc == 2) {
85dd2f3a 1719 if ((server.glueoutputbuf = yesnotoi(argv[1])) == -1) {
ed9b544e 1720 err = "argument must be 'yes' or 'no'"; goto loaderr;
1721 }
bb0b03a3 1722 } else if (!strcasecmp(argv[0],"shareobjects") && argc == 2) {
85dd2f3a 1723 if ((server.shareobjects = yesnotoi(argv[1])) == -1) {
10c43610 1724 err = "argument must be 'yes' or 'no'"; goto loaderr;
1725 }
121f70cf 1726 } else if (!strcasecmp(argv[0],"rdbcompression") && argc == 2) {
1727 if ((server.rdbcompression = yesnotoi(argv[1])) == -1) {
1728 err = "argument must be 'yes' or 'no'"; goto loaderr;
1729 }
e52c65b9 1730 } else if (!strcasecmp(argv[0],"shareobjectspoolsize") && argc == 2) {
1731 server.sharingpoolsize = atoi(argv[1]);
1732 if (server.sharingpoolsize < 1) {
1733 err = "invalid object sharing pool size"; goto loaderr;
1734 }
bb0b03a3 1735 } else if (!strcasecmp(argv[0],"daemonize") && argc == 2) {
85dd2f3a 1736 if ((server.daemonize = yesnotoi(argv[1])) == -1) {
ed9b544e 1737 err = "argument must be 'yes' or 'no'"; goto loaderr;
1738 }
44b38ef4 1739 } else if (!strcasecmp(argv[0],"appendonly") && argc == 2) {
1740 if ((server.appendonly = yesnotoi(argv[1])) == -1) {
1741 err = "argument must be 'yes' or 'no'"; goto loaderr;
1742 }
48f0308a 1743 } else if (!strcasecmp(argv[0],"appendfsync") && argc == 2) {
1766c6da 1744 if (!strcasecmp(argv[1],"no")) {
48f0308a 1745 server.appendfsync = APPENDFSYNC_NO;
1766c6da 1746 } else if (!strcasecmp(argv[1],"always")) {
48f0308a 1747 server.appendfsync = APPENDFSYNC_ALWAYS;
1766c6da 1748 } else if (!strcasecmp(argv[1],"everysec")) {
48f0308a 1749 server.appendfsync = APPENDFSYNC_EVERYSEC;
1750 } else {
1751 err = "argument must be 'no', 'always' or 'everysec'";
1752 goto loaderr;
1753 }
bb0b03a3 1754 } else if (!strcasecmp(argv[0],"requirepass") && argc == 2) {
054e426d 1755 server.requirepass = zstrdup(argv[1]);
bb0b03a3 1756 } else if (!strcasecmp(argv[0],"pidfile") && argc == 2) {
054e426d 1757 server.pidfile = zstrdup(argv[1]);
bb0b03a3 1758 } else if (!strcasecmp(argv[0],"dbfilename") && argc == 2) {
054e426d 1759 server.dbfilename = zstrdup(argv[1]);
75680a3c 1760 } else if (!strcasecmp(argv[0],"vm-enabled") && argc == 2) {
1761 if ((server.vm_enabled = yesnotoi(argv[1])) == -1) {
1762 err = "argument must be 'yes' or 'no'"; goto loaderr;
1763 }
054e426d 1764 } else if (!strcasecmp(argv[0],"vm-swap-file") && argc == 2) {
fefed597 1765 zfree(server.vm_swap_file);
054e426d 1766 server.vm_swap_file = zstrdup(argv[1]);
4ef8de8a 1767 } else if (!strcasecmp(argv[0],"vm-max-memory") && argc == 2) {
1768 server.vm_max_memory = strtoll(argv[1], NULL, 10);
1769 } else if (!strcasecmp(argv[0],"vm-page-size") && argc == 2) {
1770 server.vm_page_size = strtoll(argv[1], NULL, 10);
1771 } else if (!strcasecmp(argv[0],"vm-pages") && argc == 2) {
1772 server.vm_pages = strtoll(argv[1], NULL, 10);
92f8e882 1773 } else if (!strcasecmp(argv[0],"vm-max-threads") && argc == 2) {
1774 server.vm_max_threads = strtoll(argv[1], NULL, 10);
cbba7dd7 1775 } else if (!strcasecmp(argv[0],"hash-max-zipmap-entries") && argc == 2){
1776 server.hash_max_zipmap_entries = strtol(argv[1], NULL, 10);
1777 } else if (!strcasecmp(argv[0],"hash-max-zipmap-value") && argc == 2){
1778 server.hash_max_zipmap_value = strtol(argv[1], NULL, 10);
1779 } else if (!strcasecmp(argv[0],"vm-max-threads") && argc == 2) {
1780 server.vm_max_threads = strtoll(argv[1], NULL, 10);
ed9b544e 1781 } else {
1782 err = "Bad directive or wrong number of arguments"; goto loaderr;
1783 }
1784 for (j = 0; j < argc; j++)
1785 sdsfree(argv[j]);
1786 zfree(argv);
1787 sdsfree(line);
1788 }
c9a111ac 1789 if (fp != stdin) fclose(fp);
ed9b544e 1790 return;
1791
1792loaderr:
1793 fprintf(stderr, "\n*** FATAL CONFIG FILE ERROR ***\n");
1794 fprintf(stderr, "Reading the configuration file, at line %d\n", linenum);
1795 fprintf(stderr, ">>> '%s'\n", line);
1796 fprintf(stderr, "%s\n", err);
1797 exit(1);
1798}
1799
1800static void freeClientArgv(redisClient *c) {
1801 int j;
1802
1803 for (j = 0; j < c->argc; j++)
1804 decrRefCount(c->argv[j]);
e8a74421 1805 for (j = 0; j < c->mbargc; j++)
1806 decrRefCount(c->mbargv[j]);
ed9b544e 1807 c->argc = 0;
e8a74421 1808 c->mbargc = 0;
ed9b544e 1809}
1810
1811static void freeClient(redisClient *c) {
1812 listNode *ln;
1813
4409877e 1814 /* Note that if the client we are freeing is blocked into a blocking
b0d8747d 1815 * call, we have to set querybuf to NULL *before* to call
1816 * unblockClientWaitingData() to avoid processInputBuffer() will get
1817 * called. Also it is important to remove the file events after
1818 * this, because this call adds the READABLE event. */
4409877e 1819 sdsfree(c->querybuf);
1820 c->querybuf = NULL;
1821 if (c->flags & REDIS_BLOCKED)
b0d8747d 1822 unblockClientWaitingData(c);
4409877e 1823
ed9b544e 1824 aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
1825 aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
ed9b544e 1826 listRelease(c->reply);
1827 freeClientArgv(c);
1828 close(c->fd);
92f8e882 1829 /* Remove from the list of clients */
ed9b544e 1830 ln = listSearchKey(server.clients,c);
dfc5e96c 1831 redisAssert(ln != NULL);
ed9b544e 1832 listDelNode(server.clients,ln);
d5d55fc3 1833 /* Remove from the list of clients waiting for swapped keys */
1834 if (c->flags & REDIS_IO_WAIT && listLength(c->io_keys) == 0) {
1835 ln = listSearchKey(server.io_ready_clients,c);
1836 if (ln) {
1837 listDelNode(server.io_ready_clients,ln);
1838 server.vm_blocked_clients--;
1839 }
1840 }
1841 while (server.vm_enabled && listLength(c->io_keys)) {
1842 ln = listFirst(c->io_keys);
1843 dontWaitForSwappedKey(c,ln->value);
92f8e882 1844 }
b3e3d0d7 1845 listRelease(c->io_keys);
92f8e882 1846 /* Other cleanup */
ed9b544e 1847 if (c->flags & REDIS_SLAVE) {
6208b3a7 1848 if (c->replstate == REDIS_REPL_SEND_BULK && c->repldbfd != -1)
1849 close(c->repldbfd);
87eca727 1850 list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves;
1851 ln = listSearchKey(l,c);
dfc5e96c 1852 redisAssert(ln != NULL);
87eca727 1853 listDelNode(l,ln);
ed9b544e 1854 }
1855 if (c->flags & REDIS_MASTER) {
1856 server.master = NULL;
1857 server.replstate = REDIS_REPL_CONNECT;
1858 }
93ea3759 1859 zfree(c->argv);
e8a74421 1860 zfree(c->mbargv);
6e469882 1861 freeClientMultiState(c);
ed9b544e 1862 zfree(c);
1863}
1864
cc30e368 1865#define GLUEREPLY_UP_TO (1024)
ed9b544e 1866static void glueReplyBuffersIfNeeded(redisClient *c) {
c28b42ac 1867 int copylen = 0;
1868 char buf[GLUEREPLY_UP_TO];
6208b3a7 1869 listNode *ln;
c7df85a4 1870 listIter li;
ed9b544e 1871 robj *o;
1872
c7df85a4 1873 listRewind(c->reply,&li);
1874 while((ln = listNext(&li))) {
c28b42ac 1875 int objlen;
1876
ed9b544e 1877 o = ln->value;
c28b42ac 1878 objlen = sdslen(o->ptr);
1879 if (copylen + objlen <= GLUEREPLY_UP_TO) {
1880 memcpy(buf+copylen,o->ptr,objlen);
1881 copylen += objlen;
ed9b544e 1882 listDelNode(c->reply,ln);
c28b42ac 1883 } else {
1884 if (copylen == 0) return;
1885 break;
ed9b544e 1886 }
ed9b544e 1887 }
c28b42ac 1888 /* Now the output buffer is empty, add the new single element */
1889 o = createObject(REDIS_STRING,sdsnewlen(buf,copylen));
1890 listAddNodeHead(c->reply,o);
ed9b544e 1891}
1892
1893static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
1894 redisClient *c = privdata;
1895 int nwritten = 0, totwritten = 0, objlen;
1896 robj *o;
1897 REDIS_NOTUSED(el);
1898 REDIS_NOTUSED(mask);
1899
2895e862 1900 /* Use writev() if we have enough buffers to send */
7ea870c0 1901 if (!server.glueoutputbuf &&
1902 listLength(c->reply) > REDIS_WRITEV_THRESHOLD &&
1903 !(c->flags & REDIS_MASTER))
2895e862 1904 {
1905 sendReplyToClientWritev(el, fd, privdata, mask);
1906 return;
1907 }
2895e862 1908
ed9b544e 1909 while(listLength(c->reply)) {
c28b42ac 1910 if (server.glueoutputbuf && listLength(c->reply) > 1)
1911 glueReplyBuffersIfNeeded(c);
1912
ed9b544e 1913 o = listNodeValue(listFirst(c->reply));
1914 objlen = sdslen(o->ptr);
1915
1916 if (objlen == 0) {
1917 listDelNode(c->reply,listFirst(c->reply));
1918 continue;
1919 }
1920
1921 if (c->flags & REDIS_MASTER) {
6f376729 1922 /* Don't reply to a master */
ed9b544e 1923 nwritten = objlen - c->sentlen;
1924 } else {
a4d1ba9a 1925 nwritten = write(fd, ((char*)o->ptr)+c->sentlen, objlen - c->sentlen);
ed9b544e 1926 if (nwritten <= 0) break;
1927 }
1928 c->sentlen += nwritten;
1929 totwritten += nwritten;
1930 /* If we fully sent the object on head go to the next one */
1931 if (c->sentlen == objlen) {
1932 listDelNode(c->reply,listFirst(c->reply));
1933 c->sentlen = 0;
1934 }
6f376729 1935 /* Note that we avoid to send more thank REDIS_MAX_WRITE_PER_EVENT
12f9d551 1936 * bytes, in a single threaded server it's a good idea to serve
6f376729 1937 * other clients as well, even if a very large request comes from
1938 * super fast link that is always able to accept data (in real world
12f9d551 1939 * scenario think about 'KEYS *' against the loopback interfae) */
6f376729 1940 if (totwritten > REDIS_MAX_WRITE_PER_EVENT) break;
ed9b544e 1941 }
1942 if (nwritten == -1) {
1943 if (errno == EAGAIN) {
1944 nwritten = 0;
1945 } else {
f870935d 1946 redisLog(REDIS_VERBOSE,
ed9b544e 1947 "Error writing to client: %s", strerror(errno));
1948 freeClient(c);
1949 return;
1950 }
1951 }
1952 if (totwritten > 0) c->lastinteraction = time(NULL);
1953 if (listLength(c->reply) == 0) {
1954 c->sentlen = 0;
1955 aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
1956 }
1957}
1958
2895e862 1959static void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask)
1960{
1961 redisClient *c = privdata;
1962 int nwritten = 0, totwritten = 0, objlen, willwrite;
1963 robj *o;
1964 struct iovec iov[REDIS_WRITEV_IOVEC_COUNT];
1965 int offset, ion = 0;
1966 REDIS_NOTUSED(el);
1967 REDIS_NOTUSED(mask);
1968
1969 listNode *node;
1970 while (listLength(c->reply)) {
1971 offset = c->sentlen;
1972 ion = 0;
1973 willwrite = 0;
1974
1975 /* fill-in the iov[] array */
1976 for(node = listFirst(c->reply); node; node = listNextNode(node)) {
1977 o = listNodeValue(node);
1978 objlen = sdslen(o->ptr);
1979
1980 if (totwritten + objlen - offset > REDIS_MAX_WRITE_PER_EVENT)
1981 break;
1982
1983 if(ion == REDIS_WRITEV_IOVEC_COUNT)
1984 break; /* no more iovecs */
1985
1986 iov[ion].iov_base = ((char*)o->ptr) + offset;
1987 iov[ion].iov_len = objlen - offset;
1988 willwrite += objlen - offset;
1989 offset = 0; /* just for the first item */
1990 ion++;
1991 }
1992
1993 if(willwrite == 0)
1994 break;
1995
1996 /* write all collected blocks at once */
1997 if((nwritten = writev(fd, iov, ion)) < 0) {
1998 if (errno != EAGAIN) {
f870935d 1999 redisLog(REDIS_VERBOSE,
2895e862 2000 "Error writing to client: %s", strerror(errno));
2001 freeClient(c);
2002 return;
2003 }
2004 break;
2005 }
2006
2007 totwritten += nwritten;
2008 offset = c->sentlen;
2009
2010 /* remove written robjs from c->reply */
2011 while (nwritten && listLength(c->reply)) {
2012 o = listNodeValue(listFirst(c->reply));
2013 objlen = sdslen(o->ptr);
2014
2015 if(nwritten >= objlen - offset) {
2016 listDelNode(c->reply, listFirst(c->reply));
2017 nwritten -= objlen - offset;
2018 c->sentlen = 0;
2019 } else {
2020 /* partial write */
2021 c->sentlen += nwritten;
2022 break;
2023 }
2024 offset = 0;
2025 }
2026 }
2027
2028 if (totwritten > 0)
2029 c->lastinteraction = time(NULL);
2030
2031 if (listLength(c->reply) == 0) {
2032 c->sentlen = 0;
2033 aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
2034 }
2035}
2036
ed9b544e 2037static struct redisCommand *lookupCommand(char *name) {
2038 int j = 0;
2039 while(cmdTable[j].name != NULL) {
bb0b03a3 2040 if (!strcasecmp(name,cmdTable[j].name)) return &cmdTable[j];
ed9b544e 2041 j++;
2042 }
2043 return NULL;
2044}
2045
2046/* resetClient prepare the client to process the next command */
2047static void resetClient(redisClient *c) {
2048 freeClientArgv(c);
2049 c->bulklen = -1;
e8a74421 2050 c->multibulk = 0;
ed9b544e 2051}
2052
6e469882 2053/* Call() is the core of Redis execution of a command */
2054static void call(redisClient *c, struct redisCommand *cmd) {
2055 long long dirty;
2056
2057 dirty = server.dirty;
2058 cmd->proc(c);
2059 if (server.appendonly && server.dirty-dirty)
2060 feedAppendOnlyFile(cmd,c->db->id,c->argv,c->argc);
2061 if (server.dirty-dirty && listLength(server.slaves))
2062 replicationFeedSlaves(server.slaves,cmd,c->db->id,c->argv,c->argc);
2063 if (listLength(server.monitors))
2064 replicationFeedSlaves(server.monitors,cmd,c->db->id,c->argv,c->argc);
2065 server.stat_numcommands++;
2066}
2067
ed9b544e 2068/* If this function gets called we already read a whole
2069 * command, argments are in the client argv/argc fields.
2070 * processCommand() execute the command or prepare the
2071 * server for a bulk read from the client.
2072 *
2073 * If 1 is returned the client is still alive and valid and
2074 * and other operations can be performed by the caller. Otherwise
2075 * if 0 is returned the client was destroied (i.e. after QUIT). */
2076static int processCommand(redisClient *c) {
2077 struct redisCommand *cmd;
ed9b544e 2078
3fd78bcd 2079 /* Free some memory if needed (maxmemory setting) */
2080 if (server.maxmemory) freeMemoryIfNeeded();
2081
e8a74421 2082 /* Handle the multi bulk command type. This is an alternative protocol
2083 * supported by Redis in order to receive commands that are composed of
2084 * multiple binary-safe "bulk" arguments. The latency of processing is
2085 * a bit higher but this allows things like multi-sets, so if this
2086 * protocol is used only for MSET and similar commands this is a big win. */
2087 if (c->multibulk == 0 && c->argc == 1 && ((char*)(c->argv[0]->ptr))[0] == '*') {
2088 c->multibulk = atoi(((char*)c->argv[0]->ptr)+1);
2089 if (c->multibulk <= 0) {
2090 resetClient(c);
2091 return 1;
2092 } else {
2093 decrRefCount(c->argv[c->argc-1]);
2094 c->argc--;
2095 return 1;
2096 }
2097 } else if (c->multibulk) {
2098 if (c->bulklen == -1) {
2099 if (((char*)c->argv[0]->ptr)[0] != '$') {
2100 addReplySds(c,sdsnew("-ERR multi bulk protocol error\r\n"));
2101 resetClient(c);
2102 return 1;
2103 } else {
2104 int bulklen = atoi(((char*)c->argv[0]->ptr)+1);
2105 decrRefCount(c->argv[0]);
2106 if (bulklen < 0 || bulklen > 1024*1024*1024) {
2107 c->argc--;
2108 addReplySds(c,sdsnew("-ERR invalid bulk write count\r\n"));
2109 resetClient(c);
2110 return 1;
2111 }
2112 c->argc--;
2113 c->bulklen = bulklen+2; /* add two bytes for CR+LF */
2114 return 1;
2115 }
2116 } else {
2117 c->mbargv = zrealloc(c->mbargv,(sizeof(robj*))*(c->mbargc+1));
2118 c->mbargv[c->mbargc] = c->argv[0];
2119 c->mbargc++;
2120 c->argc--;
2121 c->multibulk--;
2122 if (c->multibulk == 0) {
2123 robj **auxargv;
2124 int auxargc;
2125
2126 /* Here we need to swap the multi-bulk argc/argv with the
2127 * normal argc/argv of the client structure. */
2128 auxargv = c->argv;
2129 c->argv = c->mbargv;
2130 c->mbargv = auxargv;
2131
2132 auxargc = c->argc;
2133 c->argc = c->mbargc;
2134 c->mbargc = auxargc;
2135
2136 /* We need to set bulklen to something different than -1
2137 * in order for the code below to process the command without
2138 * to try to read the last argument of a bulk command as
2139 * a special argument. */
2140 c->bulklen = 0;
2141 /* continue below and process the command */
2142 } else {
2143 c->bulklen = -1;
2144 return 1;
2145 }
2146 }
2147 }
2148 /* -- end of multi bulk commands processing -- */
2149
ed9b544e 2150 /* The QUIT command is handled as a special case. Normal command
2151 * procs are unable to close the client connection safely */
bb0b03a3 2152 if (!strcasecmp(c->argv[0]->ptr,"quit")) {
ed9b544e 2153 freeClient(c);
2154 return 0;
2155 }
d5d55fc3 2156
2157 /* Now lookup the command and check ASAP about trivial error conditions
2158 * such wrong arity, bad command name and so forth. */
ed9b544e 2159 cmd = lookupCommand(c->argv[0]->ptr);
2160 if (!cmd) {
2c14807b 2161 addReplySds(c,
2162 sdscatprintf(sdsempty(), "-ERR unknown command '%s'\r\n",
2163 (char*)c->argv[0]->ptr));
ed9b544e 2164 resetClient(c);
2165 return 1;
2166 } else if ((cmd->arity > 0 && cmd->arity != c->argc) ||
2167 (c->argc < -cmd->arity)) {
454d4e43 2168 addReplySds(c,
2169 sdscatprintf(sdsempty(),
2170 "-ERR wrong number of arguments for '%s' command\r\n",
2171 cmd->name));
ed9b544e 2172 resetClient(c);
2173 return 1;
3fd78bcd 2174 } else if (server.maxmemory && cmd->flags & REDIS_CMD_DENYOOM && zmalloc_used_memory() > server.maxmemory) {
2175 addReplySds(c,sdsnew("-ERR command not allowed when used memory > 'maxmemory'\r\n"));
2176 resetClient(c);
2177 return 1;
ed9b544e 2178 } else if (cmd->flags & REDIS_CMD_BULK && c->bulklen == -1) {
d5d55fc3 2179 /* This is a bulk command, we have to read the last argument yet. */
ed9b544e 2180 int bulklen = atoi(c->argv[c->argc-1]->ptr);
2181
2182 decrRefCount(c->argv[c->argc-1]);
2183 if (bulklen < 0 || bulklen > 1024*1024*1024) {
2184 c->argc--;
2185 addReplySds(c,sdsnew("-ERR invalid bulk write count\r\n"));
2186 resetClient(c);
2187 return 1;
2188 }
2189 c->argc--;
2190 c->bulklen = bulklen+2; /* add two bytes for CR+LF */
2191 /* It is possible that the bulk read is already in the
8d0490e7 2192 * buffer. Check this condition and handle it accordingly.
2193 * This is just a fast path, alternative to call processInputBuffer().
2194 * It's a good idea since the code is small and this condition
2195 * happens most of the times. */
ed9b544e 2196 if ((signed)sdslen(c->querybuf) >= c->bulklen) {
2197 c->argv[c->argc] = createStringObject(c->querybuf,c->bulklen-2);
2198 c->argc++;
2199 c->querybuf = sdsrange(c->querybuf,c->bulklen,-1);
2200 } else {
d5d55fc3 2201 /* Otherwise return... there is to read the last argument
2202 * from the socket. */
ed9b544e 2203 return 1;
2204 }
2205 }
10c43610 2206 /* Let's try to share objects on the command arguments vector */
2207 if (server.shareobjects) {
2208 int j;
2209 for(j = 1; j < c->argc; j++)
2210 c->argv[j] = tryObjectSharing(c->argv[j]);
2211 }
942a3961 2212 /* Let's try to encode the bulk object to save space. */
2213 if (cmd->flags & REDIS_CMD_BULK)
2214 tryObjectEncoding(c->argv[c->argc-1]);
2215
e63943a4 2216 /* Check if the user is authenticated */
2217 if (server.requirepass && !c->authenticated && cmd->proc != authCommand) {
2218 addReplySds(c,sdsnew("-ERR operation not permitted\r\n"));
2219 resetClient(c);
2220 return 1;
2221 }
2222
ed9b544e 2223 /* Exec the command */
18b6cb76 2224 if (c->flags & REDIS_MULTI && cmd->proc != execCommand && cmd->proc != discardCommand) {
6e469882 2225 queueMultiCommand(c,cmd);
2226 addReply(c,shared.queued);
2227 } else {
d5d55fc3 2228 if (server.vm_enabled && server.vm_max_threads > 0 &&
2229 blockClientOnSwappedKeys(cmd,c)) return 1;
6e469882 2230 call(c,cmd);
2231 }
ed9b544e 2232
2233 /* Prepare the client for the next command */
ed9b544e 2234 resetClient(c);
2235 return 1;
2236}
2237
87eca727 2238static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc) {
6208b3a7 2239 listNode *ln;
c7df85a4 2240 listIter li;
ed9b544e 2241 int outc = 0, j;
93ea3759 2242 robj **outv;
2243 /* (args*2)+1 is enough room for args, spaces, newlines */
2244 robj *static_outv[REDIS_STATIC_ARGS*2+1];
2245
2246 if (argc <= REDIS_STATIC_ARGS) {
2247 outv = static_outv;
2248 } else {
2249 outv = zmalloc(sizeof(robj*)*(argc*2+1));
93ea3759 2250 }
ed9b544e 2251
2252 for (j = 0; j < argc; j++) {
2253 if (j != 0) outv[outc++] = shared.space;
2254 if ((cmd->flags & REDIS_CMD_BULK) && j == argc-1) {
2255 robj *lenobj;
2256
2257 lenobj = createObject(REDIS_STRING,
682ac724 2258 sdscatprintf(sdsempty(),"%lu\r\n",
83c6a618 2259 (unsigned long) stringObjectLen(argv[j])));
ed9b544e 2260 lenobj->refcount = 0;
2261 outv[outc++] = lenobj;
2262 }
2263 outv[outc++] = argv[j];
2264 }
2265 outv[outc++] = shared.crlf;
2266
40d224a9 2267 /* Increment all the refcounts at start and decrement at end in order to
2268 * be sure to free objects if there is no slave in a replication state
2269 * able to be feed with commands */
2270 for (j = 0; j < outc; j++) incrRefCount(outv[j]);
c7df85a4 2271 listRewind(slaves,&li);
2272 while((ln = listNext(&li))) {
ed9b544e 2273 redisClient *slave = ln->value;
40d224a9 2274
2275 /* Don't feed slaves that are still waiting for BGSAVE to start */
6208b3a7 2276 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START) continue;
40d224a9 2277
2278 /* Feed all the other slaves, MONITORs and so on */
ed9b544e 2279 if (slave->slaveseldb != dictid) {
2280 robj *selectcmd;
2281
2282 switch(dictid) {
2283 case 0: selectcmd = shared.select0; break;
2284 case 1: selectcmd = shared.select1; break;
2285 case 2: selectcmd = shared.select2; break;
2286 case 3: selectcmd = shared.select3; break;
2287 case 4: selectcmd = shared.select4; break;
2288 case 5: selectcmd = shared.select5; break;
2289 case 6: selectcmd = shared.select6; break;
2290 case 7: selectcmd = shared.select7; break;
2291 case 8: selectcmd = shared.select8; break;
2292 case 9: selectcmd = shared.select9; break;
2293 default:
2294 selectcmd = createObject(REDIS_STRING,
2295 sdscatprintf(sdsempty(),"select %d\r\n",dictid));
2296 selectcmd->refcount = 0;
2297 break;
2298 }
2299 addReply(slave,selectcmd);
2300 slave->slaveseldb = dictid;
2301 }
2302 for (j = 0; j < outc; j++) addReply(slave,outv[j]);
ed9b544e 2303 }
40d224a9 2304 for (j = 0; j < outc; j++) decrRefCount(outv[j]);
93ea3759 2305 if (outv != static_outv) zfree(outv);
ed9b544e 2306}
2307
638e42ac 2308static void processInputBuffer(redisClient *c) {
ed9b544e 2309again:
4409877e 2310 /* Before to process the input buffer, make sure the client is not
2311 * waitig for a blocking operation such as BLPOP. Note that the first
2312 * iteration the client is never blocked, otherwise the processInputBuffer
2313 * would not be called at all, but after the execution of the first commands
2314 * in the input buffer the client may be blocked, and the "goto again"
2315 * will try to reiterate. The following line will make it return asap. */
92f8e882 2316 if (c->flags & REDIS_BLOCKED || c->flags & REDIS_IO_WAIT) return;
ed9b544e 2317 if (c->bulklen == -1) {
2318 /* Read the first line of the query */
2319 char *p = strchr(c->querybuf,'\n');
2320 size_t querylen;
644fafa3 2321
ed9b544e 2322 if (p) {
2323 sds query, *argv;
2324 int argc, j;
2325
2326 query = c->querybuf;
2327 c->querybuf = sdsempty();
2328 querylen = 1+(p-(query));
2329 if (sdslen(query) > querylen) {
2330 /* leave data after the first line of the query in the buffer */
2331 c->querybuf = sdscatlen(c->querybuf,query+querylen,sdslen(query)-querylen);
2332 }
2333 *p = '\0'; /* remove "\n" */
2334 if (*(p-1) == '\r') *(p-1) = '\0'; /* and "\r" if any */
2335 sdsupdatelen(query);
2336
2337 /* Now we can split the query in arguments */
ed9b544e 2338 argv = sdssplitlen(query,sdslen(query)," ",1,&argc);
93ea3759 2339 sdsfree(query);
2340
2341 if (c->argv) zfree(c->argv);
2342 c->argv = zmalloc(sizeof(robj*)*argc);
93ea3759 2343
2344 for (j = 0; j < argc; j++) {
ed9b544e 2345 if (sdslen(argv[j])) {
2346 c->argv[c->argc] = createObject(REDIS_STRING,argv[j]);
2347 c->argc++;
2348 } else {
2349 sdsfree(argv[j]);
2350 }
2351 }
2352 zfree(argv);
7c49733c 2353 if (c->argc) {
2354 /* Execute the command. If the client is still valid
2355 * after processCommand() return and there is something
2356 * on the query buffer try to process the next command. */
2357 if (processCommand(c) && sdslen(c->querybuf)) goto again;
2358 } else {
2359 /* Nothing to process, argc == 0. Just process the query
2360 * buffer if it's not empty or return to the caller */
2361 if (sdslen(c->querybuf)) goto again;
2362 }
ed9b544e 2363 return;
644fafa3 2364 } else if (sdslen(c->querybuf) >= REDIS_REQUEST_MAX_SIZE) {
f870935d 2365 redisLog(REDIS_VERBOSE, "Client protocol error");
ed9b544e 2366 freeClient(c);
2367 return;
2368 }
2369 } else {
2370 /* Bulk read handling. Note that if we are at this point
2371 the client already sent a command terminated with a newline,
2372 we are reading the bulk data that is actually the last
2373 argument of the command. */
2374 int qbl = sdslen(c->querybuf);
2375
2376 if (c->bulklen <= qbl) {
2377 /* Copy everything but the final CRLF as final argument */
2378 c->argv[c->argc] = createStringObject(c->querybuf,c->bulklen-2);
2379 c->argc++;
2380 c->querybuf = sdsrange(c->querybuf,c->bulklen,-1);
638e42ac 2381 /* Process the command. If the client is still valid after
2382 * the processing and there is more data in the buffer
2383 * try to parse it. */
2384 if (processCommand(c) && sdslen(c->querybuf)) goto again;
ed9b544e 2385 return;
2386 }
2387 }
2388}
2389
638e42ac 2390static void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
2391 redisClient *c = (redisClient*) privdata;
2392 char buf[REDIS_IOBUF_LEN];
2393 int nread;
2394 REDIS_NOTUSED(el);
2395 REDIS_NOTUSED(mask);
2396
2397 nread = read(fd, buf, REDIS_IOBUF_LEN);
2398 if (nread == -1) {
2399 if (errno == EAGAIN) {
2400 nread = 0;
2401 } else {
f870935d 2402 redisLog(REDIS_VERBOSE, "Reading from client: %s",strerror(errno));
638e42ac 2403 freeClient(c);
2404 return;
2405 }
2406 } else if (nread == 0) {
f870935d 2407 redisLog(REDIS_VERBOSE, "Client closed connection");
638e42ac 2408 freeClient(c);
2409 return;
2410 }
2411 if (nread) {
2412 c->querybuf = sdscatlen(c->querybuf, buf, nread);
2413 c->lastinteraction = time(NULL);
2414 } else {
2415 return;
2416 }
5921aa36 2417 if (!(c->flags & REDIS_BLOCKED))
2418 processInputBuffer(c);
638e42ac 2419}
2420
ed9b544e 2421static int selectDb(redisClient *c, int id) {
2422 if (id < 0 || id >= server.dbnum)
2423 return REDIS_ERR;
3305306f 2424 c->db = &server.db[id];
ed9b544e 2425 return REDIS_OK;
2426}
2427
40d224a9 2428static void *dupClientReplyValue(void *o) {
2429 incrRefCount((robj*)o);
12d090d2 2430 return o;
40d224a9 2431}
2432
ed9b544e 2433static redisClient *createClient(int fd) {
2434 redisClient *c = zmalloc(sizeof(*c));
2435
2436 anetNonBlock(NULL,fd);
2437 anetTcpNoDelay(NULL,fd);
2438 if (!c) return NULL;
2439 selectDb(c,0);
2440 c->fd = fd;
2441 c->querybuf = sdsempty();
2442 c->argc = 0;
93ea3759 2443 c->argv = NULL;
ed9b544e 2444 c->bulklen = -1;
e8a74421 2445 c->multibulk = 0;
2446 c->mbargc = 0;
2447 c->mbargv = NULL;
ed9b544e 2448 c->sentlen = 0;
2449 c->flags = 0;
2450 c->lastinteraction = time(NULL);
abcb223e 2451 c->authenticated = 0;
40d224a9 2452 c->replstate = REDIS_REPL_NONE;
6b47e12e 2453 c->reply = listCreate();
ed9b544e 2454 listSetFreeMethod(c->reply,decrRefCount);
40d224a9 2455 listSetDupMethod(c->reply,dupClientReplyValue);
92f8e882 2456 c->blockingkeys = NULL;
2457 c->blockingkeysnum = 0;
2458 c->io_keys = listCreate();
2459 listSetFreeMethod(c->io_keys,decrRefCount);
ed9b544e 2460 if (aeCreateFileEvent(server.el, c->fd, AE_READABLE,
266373b2 2461 readQueryFromClient, c) == AE_ERR) {
ed9b544e 2462 freeClient(c);
2463 return NULL;
2464 }
6b47e12e 2465 listAddNodeTail(server.clients,c);
6e469882 2466 initClientMultiState(c);
ed9b544e 2467 return c;
2468}
2469
2470static void addReply(redisClient *c, robj *obj) {
2471 if (listLength(c->reply) == 0 &&
6208b3a7 2472 (c->replstate == REDIS_REPL_NONE ||
2473 c->replstate == REDIS_REPL_ONLINE) &&
ed9b544e 2474 aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,
266373b2 2475 sendReplyToClient, c) == AE_ERR) return;
e3cadb8a 2476
2477 if (server.vm_enabled && obj->storage != REDIS_VM_MEMORY) {
2478 obj = dupStringObject(obj);
2479 obj->refcount = 0; /* getDecodedObject() will increment the refcount */
2480 }
9d65a1bb 2481 listAddNodeTail(c->reply,getDecodedObject(obj));
ed9b544e 2482}
2483
2484static void addReplySds(redisClient *c, sds s) {
2485 robj *o = createObject(REDIS_STRING,s);
2486 addReply(c,o);
2487 decrRefCount(o);
2488}
2489
e2665397 2490static void addReplyDouble(redisClient *c, double d) {
2491 char buf[128];
2492
2493 snprintf(buf,sizeof(buf),"%.17g",d);
682ac724 2494 addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n%s\r\n",
83c6a618 2495 (unsigned long) strlen(buf),buf));
e2665397 2496}
2497
f44dd428 2498static void addReplyLong(redisClient *c, long l) {
2499 char buf[128];
2500 size_t len;
2501
dd88747b 2502 if (l == 0) {
2503 addReply(c,shared.czero);
2504 return;
2505 } else if (l == 1) {
2506 addReply(c,shared.cone);
2507 return;
2508 }
f44dd428 2509 len = snprintf(buf,sizeof(buf),":%ld\r\n",l);
2510 addReplySds(c,sdsnewlen(buf,len));
2511}
2512
92b27fe9 2513static void addReplyUlong(redisClient *c, unsigned long ul) {
2514 char buf[128];
2515 size_t len;
2516
dd88747b 2517 if (ul == 0) {
2518 addReply(c,shared.czero);
2519 return;
2520 } else if (ul == 1) {
2521 addReply(c,shared.cone);
2522 return;
2523 }
92b27fe9 2524 len = snprintf(buf,sizeof(buf),":%lu\r\n",ul);
2525 addReplySds(c,sdsnewlen(buf,len));
2526}
2527
942a3961 2528static void addReplyBulkLen(redisClient *c, robj *obj) {
2529 size_t len;
2530
2531 if (obj->encoding == REDIS_ENCODING_RAW) {
2532 len = sdslen(obj->ptr);
2533 } else {
2534 long n = (long)obj->ptr;
2535
e054afda 2536 /* Compute how many bytes will take this integer as a radix 10 string */
942a3961 2537 len = 1;
2538 if (n < 0) {
2539 len++;
2540 n = -n;
2541 }
2542 while((n = n/10) != 0) {
2543 len++;
2544 }
2545 }
83c6a618 2546 addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",(unsigned long)len));
942a3961 2547}
2548
dd88747b 2549static void addReplyBulk(redisClient *c, robj *obj) {
2550 addReplyBulkLen(c,obj);
2551 addReply(c,obj);
2552 addReply(c,shared.crlf);
2553}
2554
ed9b544e 2555static void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
2556 int cport, cfd;
2557 char cip[128];
285add55 2558 redisClient *c;
ed9b544e 2559 REDIS_NOTUSED(el);
2560 REDIS_NOTUSED(mask);
2561 REDIS_NOTUSED(privdata);
2562
2563 cfd = anetAccept(server.neterr, fd, cip, &cport);
2564 if (cfd == AE_ERR) {
f870935d 2565 redisLog(REDIS_VERBOSE,"Accepting client connection: %s", server.neterr);
ed9b544e 2566 return;
2567 }
f870935d 2568 redisLog(REDIS_VERBOSE,"Accepted %s:%d", cip, cport);
285add55 2569 if ((c = createClient(cfd)) == NULL) {
ed9b544e 2570 redisLog(REDIS_WARNING,"Error allocating resoures for the client");
2571 close(cfd); /* May be already closed, just ingore errors */
2572 return;
2573 }
285add55 2574 /* If maxclient directive is set and this is one client more... close the
2575 * connection. Note that we create the client instead to check before
2576 * for this condition, since now the socket is already set in nonblocking
2577 * mode and we can send an error for free using the Kernel I/O */
2578 if (server.maxclients && listLength(server.clients) > server.maxclients) {
2579 char *err = "-ERR max number of clients reached\r\n";
2580
2581 /* That's a best effort error message, don't check write errors */
fee803ba 2582 if (write(c->fd,err,strlen(err)) == -1) {
2583 /* Nothing to do, Just to avoid the warning... */
2584 }
285add55 2585 freeClient(c);
2586 return;
2587 }
ed9b544e 2588 server.stat_numconnections++;
2589}
2590
2591/* ======================= Redis objects implementation ===================== */
2592
2593static robj *createObject(int type, void *ptr) {
2594 robj *o;
2595
a5819310 2596 if (server.vm_enabled) pthread_mutex_lock(&server.obj_freelist_mutex);
ed9b544e 2597 if (listLength(server.objfreelist)) {
2598 listNode *head = listFirst(server.objfreelist);
2599 o = listNodeValue(head);
2600 listDelNode(server.objfreelist,head);
a5819310 2601 if (server.vm_enabled) pthread_mutex_unlock(&server.obj_freelist_mutex);
ed9b544e 2602 } else {
75680a3c 2603 if (server.vm_enabled) {
a5819310 2604 pthread_mutex_unlock(&server.obj_freelist_mutex);
75680a3c 2605 o = zmalloc(sizeof(*o));
2606 } else {
2607 o = zmalloc(sizeof(*o)-sizeof(struct redisObjectVM));
2608 }
ed9b544e 2609 }
ed9b544e 2610 o->type = type;
942a3961 2611 o->encoding = REDIS_ENCODING_RAW;
ed9b544e 2612 o->ptr = ptr;
2613 o->refcount = 1;
3a66edc7 2614 if (server.vm_enabled) {
1064ef87 2615 /* Note that this code may run in the context of an I/O thread
2616 * and accessing to server.unixtime in theory is an error
2617 * (no locks). But in practice this is safe, and even if we read
2618 * garbage Redis will not fail, as it's just a statistical info */
3a66edc7 2619 o->vm.atime = server.unixtime;
2620 o->storage = REDIS_VM_MEMORY;
2621 }
ed9b544e 2622 return o;
2623}
2624
2625static robj *createStringObject(char *ptr, size_t len) {
2626 return createObject(REDIS_STRING,sdsnewlen(ptr,len));
2627}
2628
4ef8de8a 2629static robj *dupStringObject(robj *o) {
b9bc0eef 2630 assert(o->encoding == REDIS_ENCODING_RAW);
4ef8de8a 2631 return createStringObject(o->ptr,sdslen(o->ptr));
2632}
2633
ed9b544e 2634static robj *createListObject(void) {
2635 list *l = listCreate();
2636
ed9b544e 2637 listSetFreeMethod(l,decrRefCount);
2638 return createObject(REDIS_LIST,l);
2639}
2640
2641static robj *createSetObject(void) {
2642 dict *d = dictCreate(&setDictType,NULL);
ed9b544e 2643 return createObject(REDIS_SET,d);
2644}
2645
5234952b 2646static robj *createHashObject(void) {
2647 /* All the Hashes start as zipmaps. Will be automatically converted
2648 * into hash tables if there are enough elements or big elements
2649 * inside. */
2650 unsigned char *zm = zipmapNew();
2651 robj *o = createObject(REDIS_HASH,zm);
2652 o->encoding = REDIS_ENCODING_ZIPMAP;
2653 return o;
2654}
2655
1812e024 2656static robj *createZsetObject(void) {
6b47e12e 2657 zset *zs = zmalloc(sizeof(*zs));
2658
2659 zs->dict = dictCreate(&zsetDictType,NULL);
2660 zs->zsl = zslCreate();
2661 return createObject(REDIS_ZSET,zs);
1812e024 2662}
2663
ed9b544e 2664static void freeStringObject(robj *o) {
942a3961 2665 if (o->encoding == REDIS_ENCODING_RAW) {
2666 sdsfree(o->ptr);
2667 }
ed9b544e 2668}
2669
2670static void freeListObject(robj *o) {
2671 listRelease((list*) o->ptr);
2672}
2673
2674static void freeSetObject(robj *o) {
2675 dictRelease((dict*) o->ptr);
2676}
2677
fd8ccf44 2678static void freeZsetObject(robj *o) {
2679 zset *zs = o->ptr;
2680
2681 dictRelease(zs->dict);
2682 zslFree(zs->zsl);
2683 zfree(zs);
2684}
2685
ed9b544e 2686static void freeHashObject(robj *o) {
cbba7dd7 2687 switch (o->encoding) {
2688 case REDIS_ENCODING_HT:
2689 dictRelease((dict*) o->ptr);
2690 break;
2691 case REDIS_ENCODING_ZIPMAP:
2692 zfree(o->ptr);
2693 break;
2694 default:
2695 redisAssert(0);
2696 break;
2697 }
ed9b544e 2698}
2699
2700static void incrRefCount(robj *o) {
f2b8ab34 2701 redisAssert(!server.vm_enabled || o->storage == REDIS_VM_MEMORY);
ed9b544e 2702 o->refcount++;
2703}
2704
2705static void decrRefCount(void *obj) {
2706 robj *o = obj;
94754ccc 2707
970e10bb 2708 /* Object is a key of a swapped out value, or in the process of being
2709 * loaded. */
996cb5f7 2710 if (server.vm_enabled &&
2711 (o->storage == REDIS_VM_SWAPPED || o->storage == REDIS_VM_LOADING))
2712 {
2713 if (o->storage == REDIS_VM_SWAPPED || o->storage == REDIS_VM_LOADING) {
2714 redisAssert(o->refcount == 1);
2715 }
2716 if (o->storage == REDIS_VM_LOADING) vmCancelThreadedIOJob(obj);
f2b8ab34 2717 redisAssert(o->type == REDIS_STRING);
a35ddf12 2718 freeStringObject(o);
2719 vmMarkPagesFree(o->vm.page,o->vm.usedpages);
a5819310 2720 pthread_mutex_lock(&server.obj_freelist_mutex);
a35ddf12 2721 if (listLength(server.objfreelist) > REDIS_OBJFREELIST_MAX ||
2722 !listAddNodeHead(server.objfreelist,o))
2723 zfree(o);
a5819310 2724 pthread_mutex_unlock(&server.obj_freelist_mutex);
7d98e08c 2725 server.vm_stats_swapped_objects--;
a35ddf12 2726 return;
2727 }
996cb5f7 2728 /* Object is in memory, or in the process of being swapped out. */
ed9b544e 2729 if (--(o->refcount) == 0) {
996cb5f7 2730 if (server.vm_enabled && o->storage == REDIS_VM_SWAPPING)
2731 vmCancelThreadedIOJob(obj);
ed9b544e 2732 switch(o->type) {
2733 case REDIS_STRING: freeStringObject(o); break;
2734 case REDIS_LIST: freeListObject(o); break;
2735 case REDIS_SET: freeSetObject(o); break;
fd8ccf44 2736 case REDIS_ZSET: freeZsetObject(o); break;
ed9b544e 2737 case REDIS_HASH: freeHashObject(o); break;
78409a0f 2738 default: redisAssert(0); break;
ed9b544e 2739 }
a5819310 2740 if (server.vm_enabled) pthread_mutex_lock(&server.obj_freelist_mutex);
ed9b544e 2741 if (listLength(server.objfreelist) > REDIS_OBJFREELIST_MAX ||
2742 !listAddNodeHead(server.objfreelist,o))
2743 zfree(o);
a5819310 2744 if (server.vm_enabled) pthread_mutex_unlock(&server.obj_freelist_mutex);
ed9b544e 2745 }
2746}
2747
942a3961 2748static robj *lookupKey(redisDb *db, robj *key) {
2749 dictEntry *de = dictFind(db->dict,key);
3a66edc7 2750 if (de) {
55cf8433 2751 robj *key = dictGetEntryKey(de);
2752 robj *val = dictGetEntryVal(de);
3a66edc7 2753
55cf8433 2754 if (server.vm_enabled) {
996cb5f7 2755 if (key->storage == REDIS_VM_MEMORY ||
2756 key->storage == REDIS_VM_SWAPPING)
2757 {
2758 /* If we were swapping the object out, stop it, this key
2759 * was requested. */
2760 if (key->storage == REDIS_VM_SWAPPING)
2761 vmCancelThreadedIOJob(key);
55cf8433 2762 /* Update the access time of the key for the aging algorithm. */
2763 key->vm.atime = server.unixtime;
2764 } else {
d5d55fc3 2765 int notify = (key->storage == REDIS_VM_LOADING);
2766
55cf8433 2767 /* Our value was swapped on disk. Bring it at home. */
f2b8ab34 2768 redisAssert(val == NULL);
55cf8433 2769 val = vmLoadObject(key);
2770 dictGetEntryVal(de) = val;
d5d55fc3 2771
2772 /* Clients blocked by the VM subsystem may be waiting for
2773 * this key... */
2774 if (notify) handleClientsBlockedOnSwappedKey(db,key);
55cf8433 2775 }
2776 }
2777 return val;
3a66edc7 2778 } else {
2779 return NULL;
2780 }
942a3961 2781}
2782
2783static robj *lookupKeyRead(redisDb *db, robj *key) {
2784 expireIfNeeded(db,key);
2785 return lookupKey(db,key);
2786}
2787
2788static robj *lookupKeyWrite(redisDb *db, robj *key) {
2789 deleteIfVolatile(db,key);
2790 return lookupKey(db,key);
2791}
2792
92b27fe9 2793static robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply) {
2794 robj *o = lookupKeyRead(c->db, key);
2795 if (!o) addReply(c,reply);
2796 return o;
2797}
2798
2799static robj *lookupKeyWriteOrReply(redisClient *c, robj *key, robj *reply) {
2800 robj *o = lookupKeyWrite(c->db, key);
2801 if (!o) addReply(c,reply);
2802 return o;
2803}
2804
2805static int checkType(redisClient *c, robj *o, int type) {
2806 if (o->type != type) {
2807 addReply(c,shared.wrongtypeerr);
2808 return 1;
2809 }
2810 return 0;
2811}
2812
942a3961 2813static int deleteKey(redisDb *db, robj *key) {
2814 int retval;
2815
2816 /* We need to protect key from destruction: after the first dictDelete()
2817 * it may happen that 'key' is no longer valid if we don't increment
2818 * it's count. This may happen when we get the object reference directly
2819 * from the hash table with dictRandomKey() or dict iterators */
2820 incrRefCount(key);
2821 if (dictSize(db->expires)) dictDelete(db->expires,key);
2822 retval = dictDelete(db->dict,key);
2823 decrRefCount(key);
2824
2825 return retval == DICT_OK;
2826}
2827
10c43610 2828/* Try to share an object against the shared objects pool */
2829static robj *tryObjectSharing(robj *o) {
2830 struct dictEntry *de;
2831 unsigned long c;
2832
3305306f 2833 if (o == NULL || server.shareobjects == 0) return o;
10c43610 2834
dfc5e96c 2835 redisAssert(o->type == REDIS_STRING);
10c43610 2836 de = dictFind(server.sharingpool,o);
2837 if (de) {
2838 robj *shared = dictGetEntryKey(de);
2839
2840 c = ((unsigned long) dictGetEntryVal(de))+1;
2841 dictGetEntryVal(de) = (void*) c;
2842 incrRefCount(shared);
2843 decrRefCount(o);
2844 return shared;
2845 } else {
2846 /* Here we are using a stream algorihtm: Every time an object is
2847 * shared we increment its count, everytime there is a miss we
2848 * recrement the counter of a random object. If this object reaches
2849 * zero we remove the object and put the current object instead. */
3305306f 2850 if (dictSize(server.sharingpool) >=
10c43610 2851 server.sharingpoolsize) {
2852 de = dictGetRandomKey(server.sharingpool);
dfc5e96c 2853 redisAssert(de != NULL);
10c43610 2854 c = ((unsigned long) dictGetEntryVal(de))-1;
2855 dictGetEntryVal(de) = (void*) c;
2856 if (c == 0) {
2857 dictDelete(server.sharingpool,de->key);
2858 }
2859 } else {
2860 c = 0; /* If the pool is empty we want to add this object */
2861 }
2862 if (c == 0) {
2863 int retval;
2864
2865 retval = dictAdd(server.sharingpool,o,(void*)1);
dfc5e96c 2866 redisAssert(retval == DICT_OK);
10c43610 2867 incrRefCount(o);
2868 }
2869 return o;
2870 }
2871}
2872
724a51b1 2873/* Check if the nul-terminated string 's' can be represented by a long
2874 * (that is, is a number that fits into long without any other space or
2875 * character before or after the digits).
2876 *
2877 * If so, the function returns REDIS_OK and *longval is set to the value
2878 * of the number. Otherwise REDIS_ERR is returned */
f69f2cba 2879static int isStringRepresentableAsLong(sds s, long *longval) {
724a51b1 2880 char buf[32], *endptr;
2881 long value;
2882 int slen;
2883
2884 value = strtol(s, &endptr, 10);
2885 if (endptr[0] != '\0') return REDIS_ERR;
2886 slen = snprintf(buf,32,"%ld",value);
2887
2888 /* If the number converted back into a string is not identical
2889 * then it's not possible to encode the string as integer */
f69f2cba 2890 if (sdslen(s) != (unsigned)slen || memcmp(buf,s,slen)) return REDIS_ERR;
724a51b1 2891 if (longval) *longval = value;
2892 return REDIS_OK;
2893}
2894
942a3961 2895/* Try to encode a string object in order to save space */
2896static int tryObjectEncoding(robj *o) {
2897 long value;
942a3961 2898 sds s = o->ptr;
3305306f 2899
942a3961 2900 if (o->encoding != REDIS_ENCODING_RAW)
2901 return REDIS_ERR; /* Already encoded */
3305306f 2902
942a3961 2903 /* It's not save to encode shared objects: shared objects can be shared
2904 * everywhere in the "object space" of Redis. Encoded objects can only
2905 * appear as "values" (and not, for instance, as keys) */
2906 if (o->refcount > 1) return REDIS_ERR;
3305306f 2907
942a3961 2908 /* Currently we try to encode only strings */
dfc5e96c 2909 redisAssert(o->type == REDIS_STRING);
94754ccc 2910
724a51b1 2911 /* Check if we can represent this string as a long integer */
2912 if (isStringRepresentableAsLong(s,&value) == REDIS_ERR) return REDIS_ERR;
942a3961 2913
2914 /* Ok, this object can be encoded */
2915 o->encoding = REDIS_ENCODING_INT;
2916 sdsfree(o->ptr);
2917 o->ptr = (void*) value;
2918 return REDIS_OK;
2919}
2920
9d65a1bb 2921/* Get a decoded version of an encoded object (returned as a new object).
2922 * If the object is already raw-encoded just increment the ref count. */
2923static robj *getDecodedObject(robj *o) {
942a3961 2924 robj *dec;
2925
9d65a1bb 2926 if (o->encoding == REDIS_ENCODING_RAW) {
2927 incrRefCount(o);
2928 return o;
2929 }
942a3961 2930 if (o->type == REDIS_STRING && o->encoding == REDIS_ENCODING_INT) {
2931 char buf[32];
2932
2933 snprintf(buf,32,"%ld",(long)o->ptr);
2934 dec = createStringObject(buf,strlen(buf));
2935 return dec;
2936 } else {
dfc5e96c 2937 redisAssert(1 != 1);
942a3961 2938 }
3305306f 2939}
2940
d7f43c08 2941/* Compare two string objects via strcmp() or alike.
2942 * Note that the objects may be integer-encoded. In such a case we
2943 * use snprintf() to get a string representation of the numbers on the stack
1fd9bc8a 2944 * and compare the strings, it's much faster than calling getDecodedObject().
2945 *
2946 * Important note: if objects are not integer encoded, but binary-safe strings,
2947 * sdscmp() from sds.c will apply memcmp() so this function ca be considered
2948 * binary safe. */
724a51b1 2949static int compareStringObjects(robj *a, robj *b) {
dfc5e96c 2950 redisAssert(a->type == REDIS_STRING && b->type == REDIS_STRING);
d7f43c08 2951 char bufa[128], bufb[128], *astr, *bstr;
2952 int bothsds = 1;
724a51b1 2953
e197b441 2954 if (a == b) return 0;
d7f43c08 2955 if (a->encoding != REDIS_ENCODING_RAW) {
2956 snprintf(bufa,sizeof(bufa),"%ld",(long) a->ptr);
2957 astr = bufa;
2958 bothsds = 0;
724a51b1 2959 } else {
d7f43c08 2960 astr = a->ptr;
724a51b1 2961 }
d7f43c08 2962 if (b->encoding != REDIS_ENCODING_RAW) {
2963 snprintf(bufb,sizeof(bufb),"%ld",(long) b->ptr);
2964 bstr = bufb;
2965 bothsds = 0;
2966 } else {
2967 bstr = b->ptr;
2968 }
2969 return bothsds ? sdscmp(astr,bstr) : strcmp(astr,bstr);
724a51b1 2970}
2971
0ea663ea 2972static size_t stringObjectLen(robj *o) {
dfc5e96c 2973 redisAssert(o->type == REDIS_STRING);
0ea663ea 2974 if (o->encoding == REDIS_ENCODING_RAW) {
2975 return sdslen(o->ptr);
2976 } else {
2977 char buf[32];
2978
2979 return snprintf(buf,32,"%ld",(long)o->ptr);
2980 }
2981}
2982
06233c45 2983/*============================ RDB saving/loading =========================== */
ed9b544e 2984
f78fd11b 2985static int rdbSaveType(FILE *fp, unsigned char type) {
2986 if (fwrite(&type,1,1,fp) == 0) return -1;
2987 return 0;
2988}
2989
bb32ede5 2990static int rdbSaveTime(FILE *fp, time_t t) {
2991 int32_t t32 = (int32_t) t;
2992 if (fwrite(&t32,4,1,fp) == 0) return -1;
2993 return 0;
2994}
2995
e3566d4b 2996/* check rdbLoadLen() comments for more info */
f78fd11b 2997static int rdbSaveLen(FILE *fp, uint32_t len) {
2998 unsigned char buf[2];
2999
3000 if (len < (1<<6)) {
3001 /* Save a 6 bit len */
10c43610 3002 buf[0] = (len&0xFF)|(REDIS_RDB_6BITLEN<<6);
f78fd11b 3003 if (fwrite(buf,1,1,fp) == 0) return -1;
3004 } else if (len < (1<<14)) {
3005 /* Save a 14 bit len */
10c43610 3006 buf[0] = ((len>>8)&0xFF)|(REDIS_RDB_14BITLEN<<6);
f78fd11b 3007 buf[1] = len&0xFF;
17be1a4a 3008 if (fwrite(buf,2,1,fp) == 0) return -1;
f78fd11b 3009 } else {
3010 /* Save a 32 bit len */
10c43610 3011 buf[0] = (REDIS_RDB_32BITLEN<<6);
f78fd11b 3012 if (fwrite(buf,1,1,fp) == 0) return -1;
3013 len = htonl(len);
3014 if (fwrite(&len,4,1,fp) == 0) return -1;
3015 }
3016 return 0;
3017}
3018
e3566d4b 3019/* String objects in the form "2391" "-100" without any space and with a
3020 * range of values that can fit in an 8, 16 or 32 bit signed value can be
3021 * encoded as integers to save space */
b1befe6a 3022static int rdbTryIntegerEncoding(char *s, size_t len, unsigned char *enc) {
e3566d4b 3023 long long value;
3024 char *endptr, buf[32];
3025
3026 /* Check if it's possible to encode this value as a number */
3027 value = strtoll(s, &endptr, 10);
3028 if (endptr[0] != '\0') return 0;
3029 snprintf(buf,32,"%lld",value);
3030
3031 /* If the number converted back into a string is not identical
3032 * then it's not possible to encode the string as integer */
b1befe6a 3033 if (strlen(buf) != len || memcmp(buf,s,len)) return 0;
e3566d4b 3034
3035 /* Finally check if it fits in our ranges */
3036 if (value >= -(1<<7) && value <= (1<<7)-1) {
3037 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT8;
3038 enc[1] = value&0xFF;
3039 return 2;
3040 } else if (value >= -(1<<15) && value <= (1<<15)-1) {
3041 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT16;
3042 enc[1] = value&0xFF;
3043 enc[2] = (value>>8)&0xFF;
3044 return 3;
3045 } else if (value >= -((long long)1<<31) && value <= ((long long)1<<31)-1) {
3046 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT32;
3047 enc[1] = value&0xFF;
3048 enc[2] = (value>>8)&0xFF;
3049 enc[3] = (value>>16)&0xFF;
3050 enc[4] = (value>>24)&0xFF;
3051 return 5;
3052 } else {
3053 return 0;
3054 }
3055}
3056
b1befe6a 3057static int rdbSaveLzfStringObject(FILE *fp, unsigned char *s, size_t len) {
3058 size_t comprlen, outlen;
774e3047 3059 unsigned char byte;
3060 void *out;
3061
3062 /* We require at least four bytes compression for this to be worth it */
b1befe6a 3063 if (len <= 4) return 0;
3064 outlen = len-4;
3a2694c4 3065 if ((out = zmalloc(outlen+1)) == NULL) return 0;
b1befe6a 3066 comprlen = lzf_compress(s, len, out, outlen);
774e3047 3067 if (comprlen == 0) {
88e85998 3068 zfree(out);
774e3047 3069 return 0;
3070 }
3071 /* Data compressed! Let's save it on disk */
3072 byte = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_LZF;
3073 if (fwrite(&byte,1,1,fp) == 0) goto writeerr;
3074 if (rdbSaveLen(fp,comprlen) == -1) goto writeerr;
b1befe6a 3075 if (rdbSaveLen(fp,len) == -1) goto writeerr;
774e3047 3076 if (fwrite(out,comprlen,1,fp) == 0) goto writeerr;
88e85998 3077 zfree(out);
774e3047 3078 return comprlen;
3079
3080writeerr:
88e85998 3081 zfree(out);
774e3047 3082 return -1;
3083}
3084
e3566d4b 3085/* Save a string objet as [len][data] on disk. If the object is a string
3086 * representation of an integer value we try to safe it in a special form */
b1befe6a 3087static int rdbSaveRawString(FILE *fp, unsigned char *s, size_t len) {
e3566d4b 3088 int enclen;
10c43610 3089
774e3047 3090 /* Try integer encoding */
e3566d4b 3091 if (len <= 11) {
3092 unsigned char buf[5];
b1befe6a 3093 if ((enclen = rdbTryIntegerEncoding((char*)s,len,buf)) > 0) {
e3566d4b 3094 if (fwrite(buf,enclen,1,fp) == 0) return -1;
3095 return 0;
3096 }
3097 }
774e3047 3098
3099 /* Try LZF compression - under 20 bytes it's unable to compress even
88e85998 3100 * aaaaaaaaaaaaaaaaaa so skip it */
121f70cf 3101 if (server.rdbcompression && len > 20) {
774e3047 3102 int retval;
3103
b1befe6a 3104 retval = rdbSaveLzfStringObject(fp,s,len);
774e3047 3105 if (retval == -1) return -1;
3106 if (retval > 0) return 0;
3107 /* retval == 0 means data can't be compressed, save the old way */
3108 }
3109
3110 /* Store verbatim */
10c43610 3111 if (rdbSaveLen(fp,len) == -1) return -1;
b1befe6a 3112 if (len && fwrite(s,len,1,fp) == 0) return -1;
10c43610 3113 return 0;
3114}
3115
942a3961 3116/* Like rdbSaveStringObjectRaw() but handle encoded objects */
3117static int rdbSaveStringObject(FILE *fp, robj *obj) {
3118 int retval;
942a3961 3119
f2d9f50f 3120 /* Avoid incr/decr ref count business when possible.
3121 * This plays well with copy-on-write given that we are probably
3122 * in a child process (BGSAVE). Also this makes sure key objects
3123 * of swapped objects are not incRefCount-ed (an assert does not allow
3124 * this in order to avoid bugs) */
3125 if (obj->encoding != REDIS_ENCODING_RAW) {
996cb5f7 3126 obj = getDecodedObject(obj);
b1befe6a 3127 retval = rdbSaveRawString(fp,obj->ptr,sdslen(obj->ptr));
996cb5f7 3128 decrRefCount(obj);
3129 } else {
b1befe6a 3130 retval = rdbSaveRawString(fp,obj->ptr,sdslen(obj->ptr));
996cb5f7 3131 }
9d65a1bb 3132 return retval;
942a3961 3133}
3134
a7866db6 3135/* Save a double value. Doubles are saved as strings prefixed by an unsigned
3136 * 8 bit integer specifing the length of the representation.
3137 * This 8 bit integer has special values in order to specify the following
3138 * conditions:
3139 * 253: not a number
3140 * 254: + inf
3141 * 255: - inf
3142 */
3143static int rdbSaveDoubleValue(FILE *fp, double val) {
3144 unsigned char buf[128];
3145 int len;
3146
3147 if (isnan(val)) {
3148 buf[0] = 253;
3149 len = 1;
3150 } else if (!isfinite(val)) {
3151 len = 1;
3152 buf[0] = (val < 0) ? 255 : 254;
3153 } else {
eaa256ad 3154 snprintf((char*)buf+1,sizeof(buf)-1,"%.17g",val);
6c446631 3155 buf[0] = strlen((char*)buf+1);
a7866db6 3156 len = buf[0]+1;
3157 }
3158 if (fwrite(buf,len,1,fp) == 0) return -1;
3159 return 0;
3160}
3161
06233c45 3162/* Save a Redis object. */
3163static int rdbSaveObject(FILE *fp, robj *o) {
3164 if (o->type == REDIS_STRING) {
3165 /* Save a string value */
3166 if (rdbSaveStringObject(fp,o) == -1) return -1;
3167 } else if (o->type == REDIS_LIST) {
3168 /* Save a list value */
3169 list *list = o->ptr;
c7df85a4 3170 listIter li;
06233c45 3171 listNode *ln;
3172
06233c45 3173 if (rdbSaveLen(fp,listLength(list)) == -1) return -1;
c7df85a4 3174 listRewind(list,&li);
3175 while((ln = listNext(&li))) {
06233c45 3176 robj *eleobj = listNodeValue(ln);
3177
3178 if (rdbSaveStringObject(fp,eleobj) == -1) return -1;
3179 }
3180 } else if (o->type == REDIS_SET) {
3181 /* Save a set value */
3182 dict *set = o->ptr;
3183 dictIterator *di = dictGetIterator(set);
3184 dictEntry *de;
3185
3186 if (rdbSaveLen(fp,dictSize(set)) == -1) return -1;
3187 while((de = dictNext(di)) != NULL) {
3188 robj *eleobj = dictGetEntryKey(de);
3189
3190 if (rdbSaveStringObject(fp,eleobj) == -1) return -1;
3191 }
3192 dictReleaseIterator(di);
3193 } else if (o->type == REDIS_ZSET) {
3194 /* Save a set value */
3195 zset *zs = o->ptr;
3196 dictIterator *di = dictGetIterator(zs->dict);
3197 dictEntry *de;
3198
3199 if (rdbSaveLen(fp,dictSize(zs->dict)) == -1) return -1;
3200 while((de = dictNext(di)) != NULL) {
3201 robj *eleobj = dictGetEntryKey(de);
3202 double *score = dictGetEntryVal(de);
3203
3204 if (rdbSaveStringObject(fp,eleobj) == -1) return -1;
3205 if (rdbSaveDoubleValue(fp,*score) == -1) return -1;
3206 }
3207 dictReleaseIterator(di);
b1befe6a 3208 } else if (o->type == REDIS_HASH) {
3209 /* Save a hash value */
3210 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
3211 unsigned char *p = zipmapRewind(o->ptr);
3212 unsigned int count = zipmapLen(o->ptr);
3213 unsigned char *key, *val;
3214 unsigned int klen, vlen;
3215
3216 if (rdbSaveLen(fp,count) == -1) return -1;
3217 while((p = zipmapNext(p,&key,&klen,&val,&vlen)) != NULL) {
3218 if (rdbSaveRawString(fp,key,klen) == -1) return -1;
3219 if (rdbSaveRawString(fp,val,vlen) == -1) return -1;
3220 }
3221 } else {
3222 dictIterator *di = dictGetIterator(o->ptr);
3223 dictEntry *de;
3224
3225 if (rdbSaveLen(fp,dictSize((dict*)o->ptr)) == -1) return -1;
3226 while((de = dictNext(di)) != NULL) {
3227 robj *key = dictGetEntryKey(de);
3228 robj *val = dictGetEntryVal(de);
3229
3230 if (rdbSaveStringObject(fp,key) == -1) return -1;
3231 if (rdbSaveStringObject(fp,val) == -1) return -1;
3232 }
3233 dictReleaseIterator(di);
3234 }
06233c45 3235 } else {
78409a0f 3236 redisAssert(0);
06233c45 3237 }
3238 return 0;
3239}
3240
3241/* Return the length the object will have on disk if saved with
3242 * the rdbSaveObject() function. Currently we use a trick to get
3243 * this length with very little changes to the code. In the future
3244 * we could switch to a faster solution. */
b9bc0eef 3245static off_t rdbSavedObjectLen(robj *o, FILE *fp) {
3246 if (fp == NULL) fp = server.devnull;
06233c45 3247 rewind(fp);
3248 assert(rdbSaveObject(fp,o) != 1);
3249 return ftello(fp);
3250}
3251
06224fec 3252/* Return the number of pages required to save this object in the swap file */
b9bc0eef 3253static off_t rdbSavedObjectPages(robj *o, FILE *fp) {
3254 off_t bytes = rdbSavedObjectLen(o,fp);
06224fec 3255
3256 return (bytes+(server.vm_page_size-1))/server.vm_page_size;
3257}
3258
ed9b544e 3259/* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */
f78fd11b 3260static int rdbSave(char *filename) {
ed9b544e 3261 dictIterator *di = NULL;
3262 dictEntry *de;
ed9b544e 3263 FILE *fp;
3264 char tmpfile[256];
3265 int j;
bb32ede5 3266 time_t now = time(NULL);
ed9b544e 3267
2316bb3b 3268 /* Wait for I/O therads to terminate, just in case this is a
3269 * foreground-saving, to avoid seeking the swap file descriptor at the
3270 * same time. */
3271 if (server.vm_enabled)
3272 waitEmptyIOJobsQueue();
3273
a3b21203 3274 snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
ed9b544e 3275 fp = fopen(tmpfile,"w");
3276 if (!fp) {
3277 redisLog(REDIS_WARNING, "Failed saving the DB: %s", strerror(errno));
3278 return REDIS_ERR;
3279 }
f78fd11b 3280 if (fwrite("REDIS0001",9,1,fp) == 0) goto werr;
ed9b544e 3281 for (j = 0; j < server.dbnum; j++) {
bb32ede5 3282 redisDb *db = server.db+j;
3283 dict *d = db->dict;
3305306f 3284 if (dictSize(d) == 0) continue;
ed9b544e 3285 di = dictGetIterator(d);
3286 if (!di) {
3287 fclose(fp);
3288 return REDIS_ERR;
3289 }
3290
3291 /* Write the SELECT DB opcode */
f78fd11b 3292 if (rdbSaveType(fp,REDIS_SELECTDB) == -1) goto werr;
3293 if (rdbSaveLen(fp,j) == -1) goto werr;
ed9b544e 3294
3295 /* Iterate this DB writing every entry */
3296 while((de = dictNext(di)) != NULL) {
3297 robj *key = dictGetEntryKey(de);
3298 robj *o = dictGetEntryVal(de);
bb32ede5 3299 time_t expiretime = getExpire(db,key);
3300
3301 /* Save the expire time */
3302 if (expiretime != -1) {
3303 /* If this key is already expired skip it */
3304 if (expiretime < now) continue;
3305 if (rdbSaveType(fp,REDIS_EXPIRETIME) == -1) goto werr;
3306 if (rdbSaveTime(fp,expiretime) == -1) goto werr;
3307 }
7e69548d 3308 /* Save the key and associated value. This requires special
3309 * handling if the value is swapped out. */
996cb5f7 3310 if (!server.vm_enabled || key->storage == REDIS_VM_MEMORY ||
3311 key->storage == REDIS_VM_SWAPPING) {
7e69548d 3312 /* Save type, key, value */
3313 if (rdbSaveType(fp,o->type) == -1) goto werr;
3314 if (rdbSaveStringObject(fp,key) == -1) goto werr;
3315 if (rdbSaveObject(fp,o) == -1) goto werr;
3316 } else {
996cb5f7 3317 /* REDIS_VM_SWAPPED or REDIS_VM_LOADING */
b9bc0eef 3318 robj *po;
7e69548d 3319 /* Get a preview of the object in memory */
3320 po = vmPreviewObject(key);
7e69548d 3321 /* Save type, key, value */
3322 if (rdbSaveType(fp,key->vtype) == -1) goto werr;
b9bc0eef 3323 if (rdbSaveStringObject(fp,key) == -1) goto werr;
7e69548d 3324 if (rdbSaveObject(fp,po) == -1) goto werr;
3325 /* Remove the loaded object from memory */
3326 decrRefCount(po);
7e69548d 3327 }
ed9b544e 3328 }
3329 dictReleaseIterator(di);
3330 }
3331 /* EOF opcode */
f78fd11b 3332 if (rdbSaveType(fp,REDIS_EOF) == -1) goto werr;
3333
3334 /* Make sure data will not remain on the OS's output buffers */
ed9b544e 3335 fflush(fp);
3336 fsync(fileno(fp));
3337 fclose(fp);
3338
3339 /* Use RENAME to make sure the DB file is changed atomically only
3340 * if the generate DB file is ok. */
3341 if (rename(tmpfile,filename) == -1) {
325d1eb4 3342 redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno));
ed9b544e 3343 unlink(tmpfile);
3344 return REDIS_ERR;
3345 }
3346 redisLog(REDIS_NOTICE,"DB saved on disk");
3347 server.dirty = 0;
3348 server.lastsave = time(NULL);
3349 return REDIS_OK;
3350
3351werr:
3352 fclose(fp);
3353 unlink(tmpfile);
3354 redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
3355 if (di) dictReleaseIterator(di);
3356 return REDIS_ERR;
3357}
3358
f78fd11b 3359static int rdbSaveBackground(char *filename) {
ed9b544e 3360 pid_t childpid;
3361
9d65a1bb 3362 if (server.bgsavechildpid != -1) return REDIS_ERR;
054e426d 3363 if (server.vm_enabled) waitEmptyIOJobsQueue();
ed9b544e 3364 if ((childpid = fork()) == 0) {
3365 /* Child */
054e426d 3366 if (server.vm_enabled) vmReopenSwapFile();
ed9b544e 3367 close(server.fd);
f78fd11b 3368 if (rdbSave(filename) == REDIS_OK) {
478c2c6f 3369 _exit(0);
ed9b544e 3370 } else {
478c2c6f 3371 _exit(1);
ed9b544e 3372 }
3373 } else {
3374 /* Parent */
5a7c647e 3375 if (childpid == -1) {
3376 redisLog(REDIS_WARNING,"Can't save in background: fork: %s",
3377 strerror(errno));
3378 return REDIS_ERR;
3379 }
ed9b544e 3380 redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
9f3c422c 3381 server.bgsavechildpid = childpid;
ed9b544e 3382 return REDIS_OK;
3383 }
3384 return REDIS_OK; /* unreached */
3385}
3386
a3b21203 3387static void rdbRemoveTempFile(pid_t childpid) {
3388 char tmpfile[256];
3389
3390 snprintf(tmpfile,256,"temp-%d.rdb", (int) childpid);
3391 unlink(tmpfile);
3392}
3393
f78fd11b 3394static int rdbLoadType(FILE *fp) {
3395 unsigned char type;
7b45bfb2 3396 if (fread(&type,1,1,fp) == 0) return -1;
3397 return type;
3398}
3399
bb32ede5 3400static time_t rdbLoadTime(FILE *fp) {
3401 int32_t t32;
3402 if (fread(&t32,4,1,fp) == 0) return -1;
3403 return (time_t) t32;
3404}
3405
e3566d4b 3406/* Load an encoded length from the DB, see the REDIS_RDB_* defines on the top
3407 * of this file for a description of how this are stored on disk.
3408 *
3409 * isencoded is set to 1 if the readed length is not actually a length but
3410 * an "encoding type", check the above comments for more info */
c78a8ccc 3411static uint32_t rdbLoadLen(FILE *fp, int *isencoded) {
f78fd11b 3412 unsigned char buf[2];
3413 uint32_t len;
c78a8ccc 3414 int type;
f78fd11b 3415
e3566d4b 3416 if (isencoded) *isencoded = 0;
c78a8ccc 3417 if (fread(buf,1,1,fp) == 0) return REDIS_RDB_LENERR;
3418 type = (buf[0]&0xC0)>>6;
3419 if (type == REDIS_RDB_6BITLEN) {
3420 /* Read a 6 bit len */
3421 return buf[0]&0x3F;
3422 } else if (type == REDIS_RDB_ENCVAL) {
3423 /* Read a 6 bit len encoding type */
3424 if (isencoded) *isencoded = 1;
3425 return buf[0]&0x3F;
3426 } else if (type == REDIS_RDB_14BITLEN) {
3427 /* Read a 14 bit len */
3428 if (fread(buf+1,1,1,fp) == 0) return REDIS_RDB_LENERR;
3429 return ((buf[0]&0x3F)<<8)|buf[1];
3430 } else {
3431 /* Read a 32 bit len */
f78fd11b 3432 if (fread(&len,4,1,fp) == 0) return REDIS_RDB_LENERR;
3433 return ntohl(len);
f78fd11b 3434 }
f78fd11b 3435}
3436
e3566d4b 3437static robj *rdbLoadIntegerObject(FILE *fp, int enctype) {
3438 unsigned char enc[4];
3439 long long val;
3440
3441 if (enctype == REDIS_RDB_ENC_INT8) {
3442 if (fread(enc,1,1,fp) == 0) return NULL;
3443 val = (signed char)enc[0];
3444 } else if (enctype == REDIS_RDB_ENC_INT16) {
3445 uint16_t v;
3446 if (fread(enc,2,1,fp) == 0) return NULL;
3447 v = enc[0]|(enc[1]<<8);
3448 val = (int16_t)v;
3449 } else if (enctype == REDIS_RDB_ENC_INT32) {
3450 uint32_t v;
3451 if (fread(enc,4,1,fp) == 0) return NULL;
3452 v = enc[0]|(enc[1]<<8)|(enc[2]<<16)|(enc[3]<<24);
3453 val = (int32_t)v;
3454 } else {
3455 val = 0; /* anti-warning */
78409a0f 3456 redisAssert(0);
e3566d4b 3457 }
3458 return createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%lld",val));
3459}
3460
c78a8ccc 3461static robj *rdbLoadLzfStringObject(FILE*fp) {
88e85998 3462 unsigned int len, clen;
3463 unsigned char *c = NULL;
3464 sds val = NULL;
3465
c78a8ccc 3466 if ((clen = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL;
3467 if ((len = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL;
88e85998 3468 if ((c = zmalloc(clen)) == NULL) goto err;
3469 if ((val = sdsnewlen(NULL,len)) == NULL) goto err;
3470 if (fread(c,clen,1,fp) == 0) goto err;
3471 if (lzf_decompress(c,clen,val,len) == 0) goto err;
5109cdff 3472 zfree(c);
88e85998 3473 return createObject(REDIS_STRING,val);
3474err:
3475 zfree(c);
3476 sdsfree(val);
3477 return NULL;
3478}
3479
c78a8ccc 3480static robj *rdbLoadStringObject(FILE*fp) {
e3566d4b 3481 int isencoded;
3482 uint32_t len;
f78fd11b 3483 sds val;
3484
c78a8ccc 3485 len = rdbLoadLen(fp,&isencoded);
e3566d4b 3486 if (isencoded) {
3487 switch(len) {
3488 case REDIS_RDB_ENC_INT8:
3489 case REDIS_RDB_ENC_INT16:
3490 case REDIS_RDB_ENC_INT32:
3305306f 3491 return tryObjectSharing(rdbLoadIntegerObject(fp,len));
88e85998 3492 case REDIS_RDB_ENC_LZF:
c78a8ccc 3493 return tryObjectSharing(rdbLoadLzfStringObject(fp));
e3566d4b 3494 default:
78409a0f 3495 redisAssert(0);
e3566d4b 3496 }
3497 }
3498
f78fd11b 3499 if (len == REDIS_RDB_LENERR) return NULL;
3500 val = sdsnewlen(NULL,len);
3501 if (len && fread(val,len,1,fp) == 0) {
3502 sdsfree(val);
3503 return NULL;
3504 }
10c43610 3505 return tryObjectSharing(createObject(REDIS_STRING,val));
f78fd11b 3506}
3507
a7866db6 3508/* For information about double serialization check rdbSaveDoubleValue() */
3509static int rdbLoadDoubleValue(FILE *fp, double *val) {
3510 char buf[128];
3511 unsigned char len;
3512
3513 if (fread(&len,1,1,fp) == 0) return -1;
3514 switch(len) {
3515 case 255: *val = R_NegInf; return 0;
3516 case 254: *val = R_PosInf; return 0;
3517 case 253: *val = R_Nan; return 0;
3518 default:
3519 if (fread(buf,len,1,fp) == 0) return -1;
231d758e 3520 buf[len] = '\0';
a7866db6 3521 sscanf(buf, "%lg", val);
3522 return 0;
3523 }
3524}
3525
c78a8ccc 3526/* Load a Redis object of the specified type from the specified file.
3527 * On success a newly allocated object is returned, otherwise NULL. */
3528static robj *rdbLoadObject(int type, FILE *fp) {
3529 robj *o;
3530
bcd11906 3531 redisLog(REDIS_DEBUG,"LOADING OBJECT %d (at %d)\n",type,ftell(fp));
c78a8ccc 3532 if (type == REDIS_STRING) {
3533 /* Read string value */
3534 if ((o = rdbLoadStringObject(fp)) == NULL) return NULL;
3535 tryObjectEncoding(o);
3536 } else if (type == REDIS_LIST || type == REDIS_SET) {
3537 /* Read list/set value */
3538 uint32_t listlen;
3539
3540 if ((listlen = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL;
3541 o = (type == REDIS_LIST) ? createListObject() : createSetObject();
3c68de9b 3542 /* It's faster to expand the dict to the right size asap in order
3543 * to avoid rehashing */
3544 if (type == REDIS_SET && listlen > DICT_HT_INITIAL_SIZE)
3545 dictExpand(o->ptr,listlen);
c78a8ccc 3546 /* Load every single element of the list/set */
3547 while(listlen--) {
3548 robj *ele;
3549
3550 if ((ele = rdbLoadStringObject(fp)) == NULL) return NULL;
3551 tryObjectEncoding(ele);
3552 if (type == REDIS_LIST) {
3553 listAddNodeTail((list*)o->ptr,ele);
3554 } else {
3555 dictAdd((dict*)o->ptr,ele,NULL);
3556 }
3557 }
3558 } else if (type == REDIS_ZSET) {
3559 /* Read list/set value */
ada386b2 3560 size_t zsetlen;
c78a8ccc 3561 zset *zs;
3562
3563 if ((zsetlen = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL;
3564 o = createZsetObject();
3565 zs = o->ptr;
3566 /* Load every single element of the list/set */
3567 while(zsetlen--) {
3568 robj *ele;
3569 double *score = zmalloc(sizeof(double));
3570
3571 if ((ele = rdbLoadStringObject(fp)) == NULL) return NULL;
3572 tryObjectEncoding(ele);
3573 if (rdbLoadDoubleValue(fp,score) == -1) return NULL;
3574 dictAdd(zs->dict,ele,score);
3575 zslInsert(zs->zsl,*score,ele);
3576 incrRefCount(ele); /* added to skiplist */
3577 }
ada386b2 3578 } else if (type == REDIS_HASH) {
3579 size_t hashlen;
3580
3581 if ((hashlen = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL;
3582 o = createHashObject();
3583 /* Too many entries? Use an hash table. */
3584 if (hashlen > server.hash_max_zipmap_entries)
3585 convertToRealHash(o);
3586 /* Load every key/value, then set it into the zipmap or hash
3587 * table, as needed. */
3588 while(hashlen--) {
3589 robj *key, *val;
3590
3591 if ((key = rdbLoadStringObject(fp)) == NULL) return NULL;
3592 if ((val = rdbLoadStringObject(fp)) == NULL) return NULL;
3593 /* If we are using a zipmap and there are too big values
3594 * the object is converted to real hash table encoding. */
3595 if (o->encoding != REDIS_ENCODING_HT &&
3596 (sdslen(key->ptr) > server.hash_max_zipmap_value ||
3597 sdslen(val->ptr) > server.hash_max_zipmap_value))
3598 {
3599 convertToRealHash(o);
3600 }
3601
3602 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
3603 unsigned char *zm = o->ptr;
3604
3605 zm = zipmapSet(zm,key->ptr,sdslen(key->ptr),
3606 val->ptr,sdslen(val->ptr),NULL);
3607 o->ptr = zm;
3608 decrRefCount(key);
3609 decrRefCount(val);
3610 } else {
3611 tryObjectEncoding(key);
3612 tryObjectEncoding(val);
3613 dictAdd((dict*)o->ptr,key,val);
ada386b2 3614 }
3615 }
c78a8ccc 3616 } else {
78409a0f 3617 redisAssert(0);
c78a8ccc 3618 }
3619 return o;
3620}
3621
f78fd11b 3622static int rdbLoad(char *filename) {
ed9b544e 3623 FILE *fp;
f78fd11b 3624 robj *keyobj = NULL;
3625 uint32_t dbid;
bb32ede5 3626 int type, retval, rdbver;
3305306f 3627 dict *d = server.db[0].dict;
bb32ede5 3628 redisDb *db = server.db+0;
f78fd11b 3629 char buf[1024];
bb32ede5 3630 time_t expiretime = -1, now = time(NULL);
b492cf00 3631 long long loadedkeys = 0;
bb32ede5 3632
ed9b544e 3633 fp = fopen(filename,"r");
3634 if (!fp) return REDIS_ERR;
3635 if (fread(buf,9,1,fp) == 0) goto eoferr;
f78fd11b 3636 buf[9] = '\0';
3637 if (memcmp(buf,"REDIS",5) != 0) {
ed9b544e 3638 fclose(fp);
3639 redisLog(REDIS_WARNING,"Wrong signature trying to load DB from file");
3640 return REDIS_ERR;
3641 }
f78fd11b 3642 rdbver = atoi(buf+5);
c78a8ccc 3643 if (rdbver != 1) {
f78fd11b 3644 fclose(fp);
3645 redisLog(REDIS_WARNING,"Can't handle RDB format version %d",rdbver);
3646 return REDIS_ERR;
3647 }
ed9b544e 3648 while(1) {
3649 robj *o;
3650
3651 /* Read type. */
f78fd11b 3652 if ((type = rdbLoadType(fp)) == -1) goto eoferr;
bb32ede5 3653 if (type == REDIS_EXPIRETIME) {
3654 if ((expiretime = rdbLoadTime(fp)) == -1) goto eoferr;
3655 /* We read the time so we need to read the object type again */
3656 if ((type = rdbLoadType(fp)) == -1) goto eoferr;
3657 }
ed9b544e 3658 if (type == REDIS_EOF) break;
3659 /* Handle SELECT DB opcode as a special case */
3660 if (type == REDIS_SELECTDB) {
c78a8ccc 3661 if ((dbid = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR)
e3566d4b 3662 goto eoferr;
ed9b544e 3663 if (dbid >= (unsigned)server.dbnum) {
f78fd11b 3664 redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server.dbnum);
ed9b544e 3665 exit(1);
3666 }
bb32ede5 3667 db = server.db+dbid;
3668 d = db->dict;
ed9b544e 3669 continue;
3670 }
3671 /* Read key */
c78a8ccc 3672 if ((keyobj = rdbLoadStringObject(fp)) == NULL) goto eoferr;
3673 /* Read value */
3674 if ((o = rdbLoadObject(type,fp)) == NULL) goto eoferr;
ed9b544e 3675 /* Add the new object in the hash table */
f78fd11b 3676 retval = dictAdd(d,keyobj,o);
ed9b544e 3677 if (retval == DICT_ERR) {
f78fd11b 3678 redisLog(REDIS_WARNING,"Loading DB, duplicated key (%s) found! Unrecoverable error, exiting now.", keyobj->ptr);
ed9b544e 3679 exit(1);
3680 }
bb32ede5 3681 /* Set the expire time if needed */
3682 if (expiretime != -1) {
3683 setExpire(db,keyobj,expiretime);
3684 /* Delete this key if already expired */
3685 if (expiretime < now) deleteKey(db,keyobj);
3686 expiretime = -1;
3687 }
f78fd11b 3688 keyobj = o = NULL;
b492cf00 3689 /* Handle swapping while loading big datasets when VM is on */
3690 loadedkeys++;
3691 if (server.vm_enabled && (loadedkeys % 5000) == 0) {
3692 while (zmalloc_used_memory() > server.vm_max_memory) {
a69a0c9c 3693 if (vmSwapOneObjectBlocking() == REDIS_ERR) break;
b492cf00 3694 }
3695 }
ed9b544e 3696 }
3697 fclose(fp);
3698 return REDIS_OK;
3699
3700eoferr: /* unexpected end of file is handled here with a fatal exit */
e3566d4b 3701 if (keyobj) decrRefCount(keyobj);
f80dff62 3702 redisLog(REDIS_WARNING,"Short read or OOM loading DB. Unrecoverable error, aborting now.");
ed9b544e 3703 exit(1);
3704 return REDIS_ERR; /* Just to avoid warning */
3705}
3706
3707/*================================== Commands =============================== */
3708
abcb223e 3709static void authCommand(redisClient *c) {
2e77c2ee 3710 if (!server.requirepass || !strcmp(c->argv[1]->ptr, server.requirepass)) {
abcb223e
BH
3711 c->authenticated = 1;
3712 addReply(c,shared.ok);
3713 } else {
3714 c->authenticated = 0;
fa4c0aba 3715 addReplySds(c,sdscatprintf(sdsempty(),"-ERR invalid password\r\n"));
abcb223e
BH
3716 }
3717}
3718
ed9b544e 3719static void pingCommand(redisClient *c) {
3720 addReply(c,shared.pong);
3721}
3722
3723static void echoCommand(redisClient *c) {
dd88747b 3724 addReplyBulk(c,c->argv[1]);
ed9b544e 3725}
3726
3727/*=================================== Strings =============================== */
3728
3729static void setGenericCommand(redisClient *c, int nx) {
3730 int retval;
3731
333fd216 3732 if (nx) deleteIfVolatile(c->db,c->argv[1]);
3305306f 3733 retval = dictAdd(c->db->dict,c->argv[1],c->argv[2]);
ed9b544e 3734 if (retval == DICT_ERR) {
3735 if (!nx) {
1b03836c 3736 /* If the key is about a swapped value, we want a new key object
3737 * to overwrite the old. So we delete the old key in the database.
3738 * This will also make sure that swap pages about the old object
3739 * will be marked as free. */
ddfaca9d 3740 if (server.vm_enabled && deleteIfSwapped(c->db,c->argv[1]))
1b03836c 3741 incrRefCount(c->argv[1]);
3305306f 3742 dictReplace(c->db->dict,c->argv[1],c->argv[2]);
ed9b544e 3743 incrRefCount(c->argv[2]);
3744 } else {
c937aa89 3745 addReply(c,shared.czero);
ed9b544e 3746 return;
3747 }
3748 } else {
3749 incrRefCount(c->argv[1]);
3750 incrRefCount(c->argv[2]);
3751 }
3752 server.dirty++;
3305306f 3753 removeExpire(c->db,c->argv[1]);
c937aa89 3754 addReply(c, nx ? shared.cone : shared.ok);
ed9b544e 3755}
3756
3757static void setCommand(redisClient *c) {
a4d1ba9a 3758 setGenericCommand(c,0);
ed9b544e 3759}
3760
3761static void setnxCommand(redisClient *c) {
a4d1ba9a 3762 setGenericCommand(c,1);
ed9b544e 3763}
3764
322fc7d8 3765static int getGenericCommand(redisClient *c) {
dd88747b 3766 robj *o;
3767
3768 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
322fc7d8 3769 return REDIS_OK;
dd88747b 3770
3771 if (o->type != REDIS_STRING) {
3772 addReply(c,shared.wrongtypeerr);
3773 return REDIS_ERR;
ed9b544e 3774 } else {
dd88747b 3775 addReplyBulk(c,o);
3776 return REDIS_OK;
ed9b544e 3777 }
3778}
3779
322fc7d8 3780static void getCommand(redisClient *c) {
3781 getGenericCommand(c);
3782}
3783
f6b141c5 3784static void getsetCommand(redisClient *c) {
322fc7d8 3785 if (getGenericCommand(c) == REDIS_ERR) return;
a431eb74 3786 if (dictAdd(c->db->dict,c->argv[1],c->argv[2]) == DICT_ERR) {
3787 dictReplace(c->db->dict,c->argv[1],c->argv[2]);
3788 } else {
3789 incrRefCount(c->argv[1]);
3790 }
3791 incrRefCount(c->argv[2]);
3792 server.dirty++;
3793 removeExpire(c->db,c->argv[1]);
3794}
3795
70003d28 3796static void mgetCommand(redisClient *c) {
70003d28 3797 int j;
3798
c937aa89 3799 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->argc-1));
70003d28 3800 for (j = 1; j < c->argc; j++) {
3305306f 3801 robj *o = lookupKeyRead(c->db,c->argv[j]);
3802 if (o == NULL) {
c937aa89 3803 addReply(c,shared.nullbulk);
70003d28 3804 } else {
70003d28 3805 if (o->type != REDIS_STRING) {
c937aa89 3806 addReply(c,shared.nullbulk);
70003d28 3807 } else {
dd88747b 3808 addReplyBulk(c,o);
70003d28 3809 }
3810 }
3811 }
3812}
3813
6c446631 3814static void msetGenericCommand(redisClient *c, int nx) {
906573e7 3815 int j, busykeys = 0;
6c446631 3816
3817 if ((c->argc % 2) == 0) {
454d4e43 3818 addReplySds(c,sdsnew("-ERR wrong number of arguments for MSET\r\n"));
6c446631 3819 return;
3820 }
3821 /* Handle the NX flag. The MSETNX semantic is to return zero and don't
3822 * set nothing at all if at least one already key exists. */
3823 if (nx) {
3824 for (j = 1; j < c->argc; j += 2) {
906573e7 3825 if (lookupKeyWrite(c->db,c->argv[j]) != NULL) {
3826 busykeys++;
6c446631 3827 }
3828 }
3829 }
906573e7 3830 if (busykeys) {
3831 addReply(c, shared.czero);
3832 return;
3833 }
6c446631 3834
3835 for (j = 1; j < c->argc; j += 2) {
3836 int retval;
3837
17511391 3838 tryObjectEncoding(c->argv[j+1]);
6c446631 3839 retval = dictAdd(c->db->dict,c->argv[j],c->argv[j+1]);
3840 if (retval == DICT_ERR) {
3841 dictReplace(c->db->dict,c->argv[j],c->argv[j+1]);
3842 incrRefCount(c->argv[j+1]);
3843 } else {
3844 incrRefCount(c->argv[j]);
3845 incrRefCount(c->argv[j+1]);
3846 }
3847 removeExpire(c->db,c->argv[j]);
3848 }
3849 server.dirty += (c->argc-1)/2;
3850 addReply(c, nx ? shared.cone : shared.ok);
3851}
3852
3853static void msetCommand(redisClient *c) {
3854 msetGenericCommand(c,0);
3855}
3856
3857static void msetnxCommand(redisClient *c) {
3858 msetGenericCommand(c,1);
3859}
3860
d68ed120 3861static void incrDecrCommand(redisClient *c, long long incr) {
ed9b544e 3862 long long value;
3863 int retval;
3864 robj *o;
3865
3305306f 3866 o = lookupKeyWrite(c->db,c->argv[1]);
3867 if (o == NULL) {
ed9b544e 3868 value = 0;
3869 } else {
ed9b544e 3870 if (o->type != REDIS_STRING) {
3871 value = 0;
3872 } else {
3873 char *eptr;
3874
942a3961 3875 if (o->encoding == REDIS_ENCODING_RAW)
3876 value = strtoll(o->ptr, &eptr, 10);
3877 else if (o->encoding == REDIS_ENCODING_INT)
3878 value = (long)o->ptr;
3879 else
dfc5e96c 3880 redisAssert(1 != 1);
ed9b544e 3881 }
3882 }
3883
3884 value += incr;
3885 o = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%lld",value));
942a3961 3886 tryObjectEncoding(o);
3305306f 3887 retval = dictAdd(c->db->dict,c->argv[1],o);
ed9b544e 3888 if (retval == DICT_ERR) {
3305306f 3889 dictReplace(c->db->dict,c->argv[1],o);
3890 removeExpire(c->db,c->argv[1]);
ed9b544e 3891 } else {
3892 incrRefCount(c->argv[1]);
3893 }
3894 server.dirty++;
c937aa89 3895 addReply(c,shared.colon);
ed9b544e 3896 addReply(c,o);
3897 addReply(c,shared.crlf);
3898}
3899
3900static void incrCommand(redisClient *c) {
a4d1ba9a 3901 incrDecrCommand(c,1);
ed9b544e 3902}
3903
3904static void decrCommand(redisClient *c) {
a4d1ba9a 3905 incrDecrCommand(c,-1);
ed9b544e 3906}
3907
3908static void incrbyCommand(redisClient *c) {
d68ed120 3909 long long incr = strtoll(c->argv[2]->ptr, NULL, 10);
a4d1ba9a 3910 incrDecrCommand(c,incr);
ed9b544e 3911}
3912
3913static void decrbyCommand(redisClient *c) {
d68ed120 3914 long long incr = strtoll(c->argv[2]->ptr, NULL, 10);
a4d1ba9a 3915 incrDecrCommand(c,-incr);
ed9b544e 3916}
3917
4b00bebd 3918static void appendCommand(redisClient *c) {
3919 int retval;
3920 size_t totlen;
3921 robj *o;
3922
3923 o = lookupKeyWrite(c->db,c->argv[1]);
3924 if (o == NULL) {
3925 /* Create the key */
3926 retval = dictAdd(c->db->dict,c->argv[1],c->argv[2]);
3927 incrRefCount(c->argv[1]);
3928 incrRefCount(c->argv[2]);
3929 totlen = stringObjectLen(c->argv[2]);
3930 } else {
3931 dictEntry *de;
3932
3933 de = dictFind(c->db->dict,c->argv[1]);
3934 assert(de != NULL);
3935
3936 o = dictGetEntryVal(de);
3937 if (o->type != REDIS_STRING) {
3938 addReply(c,shared.wrongtypeerr);
3939 return;
3940 }
3941 /* If the object is specially encoded or shared we have to make
3942 * a copy */
3943 if (o->refcount != 1 || o->encoding != REDIS_ENCODING_RAW) {
3944 robj *decoded = getDecodedObject(o);
3945
3946 o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
3947 decrRefCount(decoded);
3948 dictReplace(c->db->dict,c->argv[1],o);
3949 }
3950 /* APPEND! */
3951 if (c->argv[2]->encoding == REDIS_ENCODING_RAW) {
3952 o->ptr = sdscatlen(o->ptr,
3953 c->argv[2]->ptr, sdslen(c->argv[2]->ptr));
3954 } else {
3955 o->ptr = sdscatprintf(o->ptr, "%ld",
3956 (unsigned long) c->argv[2]->ptr);
3957 }
3958 totlen = sdslen(o->ptr);
3959 }
3960 server.dirty++;
3961 addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n",(unsigned long)totlen));
3962}
3963
39191553 3964static void substrCommand(redisClient *c) {
3965 robj *o;
3966 long start = atoi(c->argv[2]->ptr);
3967 long end = atoi(c->argv[3]->ptr);
dd88747b 3968 size_t rangelen, strlen;
3969 sds range;
39191553 3970
dd88747b 3971 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
3972 checkType(c,o,REDIS_STRING)) return;
39191553 3973
dd88747b 3974 o = getDecodedObject(o);
3975 strlen = sdslen(o->ptr);
8fe7fad7 3976
dd88747b 3977 /* convert negative indexes */
3978 if (start < 0) start = strlen+start;
3979 if (end < 0) end = strlen+end;
3980 if (start < 0) start = 0;
3981 if (end < 0) end = 0;
39191553 3982
dd88747b 3983 /* indexes sanity checks */
3984 if (start > end || (size_t)start >= strlen) {
3985 /* Out of range start or start > end result in null reply */
3986 addReply(c,shared.nullbulk);
3987 decrRefCount(o);
3988 return;
39191553 3989 }
dd88747b 3990 if ((size_t)end >= strlen) end = strlen-1;
3991 rangelen = (end-start)+1;
3992
3993 /* Return the result */
3994 addReplySds(c,sdscatprintf(sdsempty(),"$%zu\r\n",rangelen));
3995 range = sdsnewlen((char*)o->ptr+start,rangelen);
3996 addReplySds(c,range);
3997 addReply(c,shared.crlf);
3998 decrRefCount(o);
39191553 3999}
4000
ed9b544e 4001/* ========================= Type agnostic commands ========================= */
4002
4003static void delCommand(redisClient *c) {
5109cdff 4004 int deleted = 0, j;
4005
4006 for (j = 1; j < c->argc; j++) {
4007 if (deleteKey(c->db,c->argv[j])) {
4008 server.dirty++;
4009 deleted++;
4010 }
4011 }
dd88747b 4012 addReplyLong(c,deleted);
ed9b544e 4013}
4014
4015static void existsCommand(redisClient *c) {
3305306f 4016 addReply(c,lookupKeyRead(c->db,c->argv[1]) ? shared.cone : shared.czero);
ed9b544e 4017}
4018
4019static void selectCommand(redisClient *c) {
4020 int id = atoi(c->argv[1]->ptr);
4021
4022 if (selectDb(c,id) == REDIS_ERR) {
774e3047 4023 addReplySds(c,sdsnew("-ERR invalid DB index\r\n"));
ed9b544e 4024 } else {
4025 addReply(c,shared.ok);
4026 }
4027}
4028
4029static void randomkeyCommand(redisClient *c) {
4030 dictEntry *de;
3305306f 4031
4032 while(1) {
4033 de = dictGetRandomKey(c->db->dict);
ce7bef07 4034 if (!de || expireIfNeeded(c->db,dictGetEntryKey(de)) == 0) break;
3305306f 4035 }
ed9b544e 4036 if (de == NULL) {
ce7bef07 4037 addReply(c,shared.plus);
ed9b544e 4038 addReply(c,shared.crlf);
4039 } else {
c937aa89 4040 addReply(c,shared.plus);
ed9b544e 4041 addReply(c,dictGetEntryKey(de));
4042 addReply(c,shared.crlf);
4043 }
4044}
4045
4046static void keysCommand(redisClient *c) {
4047 dictIterator *di;
4048 dictEntry *de;
4049 sds pattern = c->argv[1]->ptr;
4050 int plen = sdslen(pattern);
a3f9eec2 4051 unsigned long numkeys = 0;
ed9b544e 4052 robj *lenobj = createObject(REDIS_STRING,NULL);
4053
3305306f 4054 di = dictGetIterator(c->db->dict);
ed9b544e 4055 addReply(c,lenobj);
4056 decrRefCount(lenobj);
4057 while((de = dictNext(di)) != NULL) {
4058 robj *keyobj = dictGetEntryKey(de);
3305306f 4059
ed9b544e 4060 sds key = keyobj->ptr;
4061 if ((pattern[0] == '*' && pattern[1] == '\0') ||
4062 stringmatchlen(pattern,plen,key,sdslen(key),0)) {
3305306f 4063 if (expireIfNeeded(c->db,keyobj) == 0) {
dd88747b 4064 addReplyBulk(c,keyobj);
3305306f 4065 numkeys++;
3305306f 4066 }
ed9b544e 4067 }
4068 }
4069 dictReleaseIterator(di);
a3f9eec2 4070 lenobj->ptr = sdscatprintf(sdsempty(),"*%lu\r\n",numkeys);
ed9b544e 4071}
4072
4073static void dbsizeCommand(redisClient *c) {
4074 addReplySds(c,
3305306f 4075 sdscatprintf(sdsempty(),":%lu\r\n",dictSize(c->db->dict)));
ed9b544e 4076}
4077
4078static void lastsaveCommand(redisClient *c) {
4079 addReplySds(c,
c937aa89 4080 sdscatprintf(sdsempty(),":%lu\r\n",server.lastsave));
ed9b544e 4081}
4082
4083static void typeCommand(redisClient *c) {
3305306f 4084 robj *o;
ed9b544e 4085 char *type;
3305306f 4086
4087 o = lookupKeyRead(c->db,c->argv[1]);
4088 if (o == NULL) {
c937aa89 4089 type = "+none";
ed9b544e 4090 } else {
ed9b544e 4091 switch(o->type) {
c937aa89 4092 case REDIS_STRING: type = "+string"; break;
4093 case REDIS_LIST: type = "+list"; break;
4094 case REDIS_SET: type = "+set"; break;
412a8bce 4095 case REDIS_ZSET: type = "+zset"; break;
ada386b2 4096 case REDIS_HASH: type = "+hash"; break;
4097 default: type = "+unknown"; break;
ed9b544e 4098 }
4099 }
4100 addReplySds(c,sdsnew(type));
4101 addReply(c,shared.crlf);
4102}
4103
4104static void saveCommand(redisClient *c) {
9d65a1bb 4105 if (server.bgsavechildpid != -1) {
05557f6d 4106 addReplySds(c,sdsnew("-ERR background save in progress\r\n"));
4107 return;
4108 }
f78fd11b 4109 if (rdbSave(server.dbfilename) == REDIS_OK) {
ed9b544e 4110 addReply(c,shared.ok);
4111 } else {
4112 addReply(c,shared.err);
4113 }
4114}
4115
4116static void bgsaveCommand(redisClient *c) {
9d65a1bb 4117 if (server.bgsavechildpid != -1) {
ed9b544e 4118 addReplySds(c,sdsnew("-ERR background save already in progress\r\n"));
4119 return;
4120 }
f78fd11b 4121 if (rdbSaveBackground(server.dbfilename) == REDIS_OK) {
49b99ab4 4122 char *status = "+Background saving started\r\n";
4123 addReplySds(c,sdsnew(status));
ed9b544e 4124 } else {
4125 addReply(c,shared.err);
4126 }
4127}
4128
4129static void shutdownCommand(redisClient *c) {
4130 redisLog(REDIS_WARNING,"User requested shutdown, saving DB...");
a3b21203 4131 /* Kill the saving child if there is a background saving in progress.
4132 We want to avoid race conditions, for instance our saving child may
4133 overwrite the synchronous saving did by SHUTDOWN. */
9d65a1bb 4134 if (server.bgsavechildpid != -1) {
9f3c422c 4135 redisLog(REDIS_WARNING,"There is a live saving child. Killing it!");
4136 kill(server.bgsavechildpid,SIGKILL);
a3b21203 4137 rdbRemoveTempFile(server.bgsavechildpid);
9f3c422c 4138 }
ac945e2d 4139 if (server.appendonly) {
4140 /* Append only file: fsync() the AOF and exit */
4141 fsync(server.appendfd);
054e426d 4142 if (server.vm_enabled) unlink(server.vm_swap_file);
ac945e2d 4143 exit(0);
ed9b544e 4144 } else {
ac945e2d 4145 /* Snapshotting. Perform a SYNC SAVE and exit */
4146 if (rdbSave(server.dbfilename) == REDIS_OK) {
4147 if (server.daemonize)
4148 unlink(server.pidfile);
4149 redisLog(REDIS_WARNING,"%zu bytes used at exit",zmalloc_used_memory());
4150 redisLog(REDIS_WARNING,"Server exit now, bye bye...");
054e426d 4151 if (server.vm_enabled) unlink(server.vm_swap_file);
ac945e2d 4152 exit(0);
4153 } else {
dd88747b 4154 /* Ooops.. error saving! The best we can do is to continue
4155 * operating. Note that if there was a background saving process,
4156 * in the next cron() Redis will be notified that the background
4157 * saving aborted, handling special stuff like slaves pending for
4158 * synchronization... */
ac945e2d 4159 redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit");
dd88747b 4160 addReplySds(c,
4161 sdsnew("-ERR can't quit, problems saving the DB\r\n"));
ac945e2d 4162 }
ed9b544e 4163 }
4164}
4165
4166static void renameGenericCommand(redisClient *c, int nx) {
ed9b544e 4167 robj *o;
4168
4169 /* To use the same key as src and dst is probably an error */
4170 if (sdscmp(c->argv[1]->ptr,c->argv[2]->ptr) == 0) {
c937aa89 4171 addReply(c,shared.sameobjecterr);
ed9b544e 4172 return;
4173 }
4174
dd88747b 4175 if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr)) == NULL)
ed9b544e 4176 return;
dd88747b 4177
ed9b544e 4178 incrRefCount(o);
3305306f 4179 deleteIfVolatile(c->db,c->argv[2]);
4180 if (dictAdd(c->db->dict,c->argv[2],o) == DICT_ERR) {
ed9b544e 4181 if (nx) {
4182 decrRefCount(o);
c937aa89 4183 addReply(c,shared.czero);
ed9b544e 4184 return;
4185 }
3305306f 4186 dictReplace(c->db->dict,c->argv[2],o);
ed9b544e 4187 } else {
4188 incrRefCount(c->argv[2]);
4189 }
3305306f 4190 deleteKey(c->db,c->argv[1]);
ed9b544e 4191 server.dirty++;
c937aa89 4192 addReply(c,nx ? shared.cone : shared.ok);
ed9b544e 4193}
4194
4195static void renameCommand(redisClient *c) {
4196 renameGenericCommand(c,0);
4197}
4198
4199static void renamenxCommand(redisClient *c) {
4200 renameGenericCommand(c,1);
4201}
4202
4203static void moveCommand(redisClient *c) {
3305306f 4204 robj *o;
4205 redisDb *src, *dst;
ed9b544e 4206 int srcid;
4207
4208 /* Obtain source and target DB pointers */
3305306f 4209 src = c->db;
4210 srcid = c->db->id;
ed9b544e 4211 if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) {
c937aa89 4212 addReply(c,shared.outofrangeerr);
ed9b544e 4213 return;
4214 }
3305306f 4215 dst = c->db;
4216 selectDb(c,srcid); /* Back to the source DB */
ed9b544e 4217
4218 /* If the user is moving using as target the same
4219 * DB as the source DB it is probably an error. */
4220 if (src == dst) {
c937aa89 4221 addReply(c,shared.sameobjecterr);
ed9b544e 4222 return;
4223 }
4224
4225 /* Check if the element exists and get a reference */
3305306f 4226 o = lookupKeyWrite(c->db,c->argv[1]);
4227 if (!o) {
c937aa89 4228 addReply(c,shared.czero);
ed9b544e 4229 return;
4230 }
4231
4232 /* Try to add the element to the target DB */
3305306f 4233 deleteIfVolatile(dst,c->argv[1]);
4234 if (dictAdd(dst->dict,c->argv[1],o) == DICT_ERR) {
c937aa89 4235 addReply(c,shared.czero);
ed9b544e 4236 return;
4237 }
3305306f 4238 incrRefCount(c->argv[1]);
ed9b544e 4239 incrRefCount(o);
4240
4241 /* OK! key moved, free the entry in the source DB */
3305306f 4242 deleteKey(src,c->argv[1]);
ed9b544e 4243 server.dirty++;
c937aa89 4244 addReply(c,shared.cone);
ed9b544e 4245}
4246
4247/* =================================== Lists ================================ */
4248static void pushGenericCommand(redisClient *c, int where) {
4249 robj *lobj;
ed9b544e 4250 list *list;
3305306f 4251
4252 lobj = lookupKeyWrite(c->db,c->argv[1]);
4253 if (lobj == NULL) {
95242ab5 4254 if (handleClientsWaitingListPush(c,c->argv[1],c->argv[2])) {
520b5a33 4255 addReply(c,shared.cone);
95242ab5 4256 return;
4257 }
ed9b544e 4258 lobj = createListObject();
4259 list = lobj->ptr;
4260 if (where == REDIS_HEAD) {
6b47e12e 4261 listAddNodeHead(list,c->argv[2]);
ed9b544e 4262 } else {
6b47e12e 4263 listAddNodeTail(list,c->argv[2]);
ed9b544e 4264 }
3305306f 4265 dictAdd(c->db->dict,c->argv[1],lobj);
ed9b544e 4266 incrRefCount(c->argv[1]);
4267 incrRefCount(c->argv[2]);
4268 } else {
ed9b544e 4269 if (lobj->type != REDIS_LIST) {
4270 addReply(c,shared.wrongtypeerr);
4271 return;
4272 }
95242ab5 4273 if (handleClientsWaitingListPush(c,c->argv[1],c->argv[2])) {
520b5a33 4274 addReply(c,shared.cone);
95242ab5 4275 return;
4276 }
ed9b544e 4277 list = lobj->ptr;
4278 if (where == REDIS_HEAD) {
6b47e12e 4279 listAddNodeHead(list,c->argv[2]);
ed9b544e 4280 } else {
6b47e12e 4281 listAddNodeTail(list,c->argv[2]);
ed9b544e 4282 }
4283 incrRefCount(c->argv[2]);
4284 }
4285 server.dirty++;
520b5a33 4286 addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",listLength(list)));
ed9b544e 4287}
4288
4289static void lpushCommand(redisClient *c) {
4290 pushGenericCommand(c,REDIS_HEAD);
4291}
4292
4293static void rpushCommand(redisClient *c) {
4294 pushGenericCommand(c,REDIS_TAIL);
4295}
4296
4297static void llenCommand(redisClient *c) {
3305306f 4298 robj *o;
ed9b544e 4299 list *l;
dd88747b 4300
4301 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
4302 checkType(c,o,REDIS_LIST)) return;
ed9b544e 4303
dd88747b 4304 l = o->ptr;
4305 addReplyUlong(c,listLength(l));
ed9b544e 4306}
4307
4308static void lindexCommand(redisClient *c) {
3305306f 4309 robj *o;
ed9b544e 4310 int index = atoi(c->argv[2]->ptr);
dd88747b 4311 list *list;
4312 listNode *ln;
4313
4314 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
4315 checkType(c,o,REDIS_LIST)) return;
4316 list = o->ptr;
4317
4318 ln = listIndex(list, index);
4319 if (ln == NULL) {
c937aa89 4320 addReply(c,shared.nullbulk);
ed9b544e 4321 } else {
dd88747b 4322 robj *ele = listNodeValue(ln);
4323 addReplyBulk(c,ele);
ed9b544e 4324 }
4325}
4326
4327static void lsetCommand(redisClient *c) {
3305306f 4328 robj *o;
ed9b544e 4329 int index = atoi(c->argv[2]->ptr);
dd88747b 4330 list *list;
4331 listNode *ln;
4332
4333 if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr)) == NULL ||
4334 checkType(c,o,REDIS_LIST)) return;
4335 list = o->ptr;
4336
4337 ln = listIndex(list, index);
4338 if (ln == NULL) {
4339 addReply(c,shared.outofrangeerr);
ed9b544e 4340 } else {
dd88747b 4341 robj *ele = listNodeValue(ln);
ed9b544e 4342
dd88747b 4343 decrRefCount(ele);
4344 listNodeValue(ln) = c->argv[3];
4345 incrRefCount(c->argv[3]);
4346 addReply(c,shared.ok);
4347 server.dirty++;
ed9b544e 4348 }
4349}
4350
4351static void popGenericCommand(redisClient *c, int where) {
3305306f 4352 robj *o;
dd88747b 4353 list *list;
4354 listNode *ln;
3305306f 4355
dd88747b 4356 if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
4357 checkType(c,o,REDIS_LIST)) return;
4358 list = o->ptr;
ed9b544e 4359
dd88747b 4360 if (where == REDIS_HEAD)
4361 ln = listFirst(list);
4362 else
4363 ln = listLast(list);
ed9b544e 4364
dd88747b 4365 if (ln == NULL) {
4366 addReply(c,shared.nullbulk);
4367 } else {
4368 robj *ele = listNodeValue(ln);
4369 addReplyBulk(c,ele);
4370 listDelNode(list,ln);
4371 server.dirty++;
ed9b544e 4372 }
4373}
4374
4375static void lpopCommand(redisClient *c) {
4376 popGenericCommand(c,REDIS_HEAD);
4377}
4378
4379static void rpopCommand(redisClient *c) {
4380 popGenericCommand(c,REDIS_TAIL);
4381}
4382
4383static void lrangeCommand(redisClient *c) {
3305306f 4384 robj *o;
ed9b544e 4385 int start = atoi(c->argv[2]->ptr);
4386 int end = atoi(c->argv[3]->ptr);
dd88747b 4387 int llen;
4388 int rangelen, j;
4389 list *list;
4390 listNode *ln;
4391 robj *ele;
4392
4393 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullmultibulk)) == NULL ||
4394 checkType(c,o,REDIS_LIST)) return;
4395 list = o->ptr;
4396 llen = listLength(list);
4397
4398 /* convert negative indexes */
4399 if (start < 0) start = llen+start;
4400 if (end < 0) end = llen+end;
4401 if (start < 0) start = 0;
4402 if (end < 0) end = 0;
4403
4404 /* indexes sanity checks */
4405 if (start > end || start >= llen) {
4406 /* Out of range start or start > end result in empty list */
4407 addReply(c,shared.emptymultibulk);
4408 return;
4409 }
4410 if (end >= llen) end = llen-1;
4411 rangelen = (end-start)+1;
3305306f 4412
dd88747b 4413 /* Return the result in form of a multi-bulk reply */
4414 ln = listIndex(list, start);
4415 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",rangelen));
4416 for (j = 0; j < rangelen; j++) {
4417 ele = listNodeValue(ln);
4418 addReplyBulk(c,ele);
4419 ln = ln->next;
ed9b544e 4420 }
4421}
4422
4423static void ltrimCommand(redisClient *c) {
3305306f 4424 robj *o;
ed9b544e 4425 int start = atoi(c->argv[2]->ptr);
4426 int end = atoi(c->argv[3]->ptr);
dd88747b 4427 int llen;
4428 int j, ltrim, rtrim;
4429 list *list;
4430 listNode *ln;
4431
4432 if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.ok)) == NULL ||
4433 checkType(c,o,REDIS_LIST)) return;
4434 list = o->ptr;
4435 llen = listLength(list);
4436
4437 /* convert negative indexes */
4438 if (start < 0) start = llen+start;
4439 if (end < 0) end = llen+end;
4440 if (start < 0) start = 0;
4441 if (end < 0) end = 0;
4442
4443 /* indexes sanity checks */
4444 if (start > end || start >= llen) {
4445 /* Out of range start or start > end result in empty list */
4446 ltrim = llen;
4447 rtrim = 0;
ed9b544e 4448 } else {
dd88747b 4449 if (end >= llen) end = llen-1;
4450 ltrim = start;
4451 rtrim = llen-end-1;
4452 }
ed9b544e 4453
dd88747b 4454 /* Remove list elements to perform the trim */
4455 for (j = 0; j < ltrim; j++) {
4456 ln = listFirst(list);
4457 listDelNode(list,ln);
4458 }
4459 for (j = 0; j < rtrim; j++) {
4460 ln = listLast(list);
4461 listDelNode(list,ln);
ed9b544e 4462 }
dd88747b 4463 server.dirty++;
4464 addReply(c,shared.ok);
ed9b544e 4465}
4466
4467static void lremCommand(redisClient *c) {
3305306f 4468 robj *o;
dd88747b 4469 list *list;
4470 listNode *ln, *next;
4471 int toremove = atoi(c->argv[2]->ptr);
4472 int removed = 0;
4473 int fromtail = 0;
a4d1ba9a 4474
dd88747b 4475 if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
4476 checkType(c,o,REDIS_LIST)) return;
4477 list = o->ptr;
4478
4479 if (toremove < 0) {
4480 toremove = -toremove;
4481 fromtail = 1;
4482 }
4483 ln = fromtail ? list->tail : list->head;
4484 while (ln) {
4485 robj *ele = listNodeValue(ln);
4486
4487 next = fromtail ? ln->prev : ln->next;
4488 if (compareStringObjects(ele,c->argv[3]) == 0) {
4489 listDelNode(list,ln);
4490 server.dirty++;
4491 removed++;
4492 if (toremove && removed == toremove) break;
ed9b544e 4493 }
dd88747b 4494 ln = next;
ed9b544e 4495 }
dd88747b 4496 addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",removed));
ed9b544e 4497}
4498
12f9d551 4499/* This is the semantic of this command:
0f5f7e9a 4500 * RPOPLPUSH srclist dstlist:
12f9d551 4501 * IF LLEN(srclist) > 0
4502 * element = RPOP srclist
4503 * LPUSH dstlist element
4504 * RETURN element
4505 * ELSE
4506 * RETURN nil
4507 * END
4508 * END
4509 *
4510 * The idea is to be able to get an element from a list in a reliable way
4511 * since the element is not just returned but pushed against another list
4512 * as well. This command was originally proposed by Ezra Zygmuntowicz.
4513 */
0f5f7e9a 4514static void rpoplpushcommand(redisClient *c) {
12f9d551 4515 robj *sobj;
dd88747b 4516 list *srclist;
4517 listNode *ln;
4518
4519 if ((sobj = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
4520 checkType(c,sobj,REDIS_LIST)) return;
4521 srclist = sobj->ptr;
4522 ln = listLast(srclist);
12f9d551 4523
dd88747b 4524 if (ln == NULL) {
12f9d551 4525 addReply(c,shared.nullbulk);
4526 } else {
dd88747b 4527 robj *dobj = lookupKeyWrite(c->db,c->argv[2]);
4528 robj *ele = listNodeValue(ln);
4529 list *dstlist;
e20fb74f 4530
dd88747b 4531 if (dobj && dobj->type != REDIS_LIST) {
4532 addReply(c,shared.wrongtypeerr);
4533 return;
4534 }
12f9d551 4535
dd88747b 4536 /* Add the element to the target list (unless it's directly
4537 * passed to some BLPOP-ing client */
4538 if (!handleClientsWaitingListPush(c,c->argv[2],ele)) {
4539 if (dobj == NULL) {
4540 /* Create the list if the key does not exist */
4541 dobj = createListObject();
4542 dictAdd(c->db->dict,c->argv[2],dobj);
4543 incrRefCount(c->argv[2]);
12f9d551 4544 }
dd88747b 4545 dstlist = dobj->ptr;
4546 listAddNodeHead(dstlist,ele);
4547 incrRefCount(ele);
12f9d551 4548 }
dd88747b 4549
4550 /* Send the element to the client as reply as well */
4551 addReplyBulk(c,ele);
4552
4553 /* Finally remove the element from the source list */
4554 listDelNode(srclist,ln);
4555 server.dirty++;
12f9d551 4556 }
4557}
4558
ed9b544e 4559/* ==================================== Sets ================================ */
4560
4561static void saddCommand(redisClient *c) {
ed9b544e 4562 robj *set;
4563
3305306f 4564 set = lookupKeyWrite(c->db,c->argv[1]);
4565 if (set == NULL) {
ed9b544e 4566 set = createSetObject();
3305306f 4567 dictAdd(c->db->dict,c->argv[1],set);
ed9b544e 4568 incrRefCount(c->argv[1]);
4569 } else {
ed9b544e 4570 if (set->type != REDIS_SET) {
c937aa89 4571 addReply(c,shared.wrongtypeerr);
ed9b544e 4572 return;
4573 }
4574 }
4575 if (dictAdd(set->ptr,c->argv[2],NULL) == DICT_OK) {
4576 incrRefCount(c->argv[2]);
4577 server.dirty++;
c937aa89 4578 addReply(c,shared.cone);
ed9b544e 4579 } else {
c937aa89 4580 addReply(c,shared.czero);
ed9b544e 4581 }
4582}
4583
4584static void sremCommand(redisClient *c) {
3305306f 4585 robj *set;
ed9b544e 4586
dd88747b 4587 if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
4588 checkType(c,set,REDIS_SET)) return;
4589
4590 if (dictDelete(set->ptr,c->argv[2]) == DICT_OK) {
4591 server.dirty++;
4592 if (htNeedsResize(set->ptr)) dictResize(set->ptr);
4593 addReply(c,shared.cone);
ed9b544e 4594 } else {
dd88747b 4595 addReply(c,shared.czero);
ed9b544e 4596 }
4597}
4598
a4460ef4 4599static void smoveCommand(redisClient *c) {
4600 robj *srcset, *dstset;
4601
4602 srcset = lookupKeyWrite(c->db,c->argv[1]);
4603 dstset = lookupKeyWrite(c->db,c->argv[2]);
4604
4605 /* If the source key does not exist return 0, if it's of the wrong type
4606 * raise an error */
4607 if (srcset == NULL || srcset->type != REDIS_SET) {
4608 addReply(c, srcset ? shared.wrongtypeerr : shared.czero);
4609 return;
4610 }
4611 /* Error if the destination key is not a set as well */
4612 if (dstset && dstset->type != REDIS_SET) {
4613 addReply(c,shared.wrongtypeerr);
4614 return;
4615 }
4616 /* Remove the element from the source set */
4617 if (dictDelete(srcset->ptr,c->argv[3]) == DICT_ERR) {
4618 /* Key not found in the src set! return zero */
4619 addReply(c,shared.czero);
4620 return;
4621 }
4622 server.dirty++;
4623 /* Add the element to the destination set */
4624 if (!dstset) {
4625 dstset = createSetObject();
4626 dictAdd(c->db->dict,c->argv[2],dstset);
4627 incrRefCount(c->argv[2]);
4628 }
4629 if (dictAdd(dstset->ptr,c->argv[3],NULL) == DICT_OK)
4630 incrRefCount(c->argv[3]);
4631 addReply(c,shared.cone);
4632}
4633
ed9b544e 4634static void sismemberCommand(redisClient *c) {
3305306f 4635 robj *set;
ed9b544e 4636
dd88747b 4637 if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
4638 checkType(c,set,REDIS_SET)) return;
4639
4640 if (dictFind(set->ptr,c->argv[2]))
4641 addReply(c,shared.cone);
4642 else
c937aa89 4643 addReply(c,shared.czero);
ed9b544e 4644}
4645
4646static void scardCommand(redisClient *c) {
3305306f 4647 robj *o;
ed9b544e 4648 dict *s;
dd88747b 4649
4650 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
4651 checkType(c,o,REDIS_SET)) return;
ed9b544e 4652
dd88747b 4653 s = o->ptr;
4654 addReplyUlong(c,dictSize(s));
ed9b544e 4655}
4656
12fea928 4657static void spopCommand(redisClient *c) {
4658 robj *set;
4659 dictEntry *de;
4660
dd88747b 4661 if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
4662 checkType(c,set,REDIS_SET)) return;
4663
4664 de = dictGetRandomKey(set->ptr);
4665 if (de == NULL) {
12fea928 4666 addReply(c,shared.nullbulk);
4667 } else {
dd88747b 4668 robj *ele = dictGetEntryKey(de);
12fea928 4669
dd88747b 4670 addReplyBulk(c,ele);
4671 dictDelete(set->ptr,ele);
4672 if (htNeedsResize(set->ptr)) dictResize(set->ptr);
4673 server.dirty++;
12fea928 4674 }
4675}
4676
2abb95a9 4677static void srandmemberCommand(redisClient *c) {
4678 robj *set;
4679 dictEntry *de;
4680
dd88747b 4681 if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
4682 checkType(c,set,REDIS_SET)) return;
4683
4684 de = dictGetRandomKey(set->ptr);
4685 if (de == NULL) {
2abb95a9 4686 addReply(c,shared.nullbulk);
4687 } else {
dd88747b 4688 robj *ele = dictGetEntryKey(de);
2abb95a9 4689
dd88747b 4690 addReplyBulk(c,ele);
2abb95a9 4691 }
4692}
4693
ed9b544e 4694static int qsortCompareSetsByCardinality(const void *s1, const void *s2) {
4695 dict **d1 = (void*) s1, **d2 = (void*) s2;
4696
3305306f 4697 return dictSize(*d1)-dictSize(*d2);
ed9b544e 4698}
4699
682ac724 4700static void sinterGenericCommand(redisClient *c, robj **setskeys, unsigned long setsnum, robj *dstkey) {
ed9b544e 4701 dict **dv = zmalloc(sizeof(dict*)*setsnum);
4702 dictIterator *di;
4703 dictEntry *de;
4704 robj *lenobj = NULL, *dstset = NULL;
682ac724 4705 unsigned long j, cardinality = 0;
ed9b544e 4706
ed9b544e 4707 for (j = 0; j < setsnum; j++) {
4708 robj *setobj;
3305306f 4709
4710 setobj = dstkey ?
4711 lookupKeyWrite(c->db,setskeys[j]) :
4712 lookupKeyRead(c->db,setskeys[j]);
4713 if (!setobj) {
ed9b544e 4714 zfree(dv);
5faa6025 4715 if (dstkey) {
fdcaae84 4716 if (deleteKey(c->db,dstkey))
4717 server.dirty++;
0d36ded0 4718 addReply(c,shared.czero);
5faa6025 4719 } else {
4720 addReply(c,shared.nullmultibulk);
4721 }
ed9b544e 4722 return;
4723 }
ed9b544e 4724 if (setobj->type != REDIS_SET) {
4725 zfree(dv);
c937aa89 4726 addReply(c,shared.wrongtypeerr);
ed9b544e 4727 return;
4728 }
4729 dv[j] = setobj->ptr;
4730 }
4731 /* Sort sets from the smallest to largest, this will improve our
4732 * algorithm's performace */
4733 qsort(dv,setsnum,sizeof(dict*),qsortCompareSetsByCardinality);
4734
4735 /* The first thing we should output is the total number of elements...
4736 * since this is a multi-bulk write, but at this stage we don't know
4737 * the intersection set size, so we use a trick, append an empty object
4738 * to the output list and save the pointer to later modify it with the
4739 * right length */
4740 if (!dstkey) {
4741 lenobj = createObject(REDIS_STRING,NULL);
4742 addReply(c,lenobj);
4743 decrRefCount(lenobj);
4744 } else {
4745 /* If we have a target key where to store the resulting set
4746 * create this key with an empty set inside */
4747 dstset = createSetObject();
ed9b544e 4748 }
4749
4750 /* Iterate all the elements of the first (smallest) set, and test
4751 * the element against all the other sets, if at least one set does
4752 * not include the element it is discarded */
4753 di = dictGetIterator(dv[0]);
ed9b544e 4754
4755 while((de = dictNext(di)) != NULL) {
4756 robj *ele;
4757
4758 for (j = 1; j < setsnum; j++)
4759 if (dictFind(dv[j],dictGetEntryKey(de)) == NULL) break;
4760 if (j != setsnum)
4761 continue; /* at least one set does not contain the member */
4762 ele = dictGetEntryKey(de);
4763 if (!dstkey) {
dd88747b 4764 addReplyBulk(c,ele);
ed9b544e 4765 cardinality++;
4766 } else {
4767 dictAdd(dstset->ptr,ele,NULL);
4768 incrRefCount(ele);
4769 }
4770 }
4771 dictReleaseIterator(di);
4772
83cdfe18
AG
4773 if (dstkey) {
4774 /* Store the resulting set into the target */
4775 deleteKey(c->db,dstkey);
4776 dictAdd(c->db->dict,dstkey,dstset);
4777 incrRefCount(dstkey);
4778 }
4779
40d224a9 4780 if (!dstkey) {
682ac724 4781 lenobj->ptr = sdscatprintf(sdsempty(),"*%lu\r\n",cardinality);
40d224a9 4782 } else {
682ac724 4783 addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n",
03fd01c7 4784 dictSize((dict*)dstset->ptr)));
40d224a9 4785 server.dirty++;
4786 }
ed9b544e 4787 zfree(dv);
4788}
4789
4790static void sinterCommand(redisClient *c) {
4791 sinterGenericCommand(c,c->argv+1,c->argc-1,NULL);
4792}
4793
4794static void sinterstoreCommand(redisClient *c) {
4795 sinterGenericCommand(c,c->argv+2,c->argc-2,c->argv[1]);
4796}
4797
f4f56e1d 4798#define REDIS_OP_UNION 0
4799#define REDIS_OP_DIFF 1
2830ca53 4800#define REDIS_OP_INTER 2
f4f56e1d 4801
4802static void sunionDiffGenericCommand(redisClient *c, robj **setskeys, int setsnum, robj *dstkey, int op) {
40d224a9 4803 dict **dv = zmalloc(sizeof(dict*)*setsnum);
4804 dictIterator *di;
4805 dictEntry *de;
f4f56e1d 4806 robj *dstset = NULL;
40d224a9 4807 int j, cardinality = 0;
4808
40d224a9 4809 for (j = 0; j < setsnum; j++) {
4810 robj *setobj;
4811
4812 setobj = dstkey ?
4813 lookupKeyWrite(c->db,setskeys[j]) :
4814 lookupKeyRead(c->db,setskeys[j]);
4815 if (!setobj) {
4816 dv[j] = NULL;
4817 continue;
4818 }
4819 if (setobj->type != REDIS_SET) {
4820 zfree(dv);
4821 addReply(c,shared.wrongtypeerr);
4822 return;
4823 }
4824 dv[j] = setobj->ptr;
4825 }
4826
4827 /* We need a temp set object to store our union. If the dstkey
4828 * is not NULL (that is, we are inside an SUNIONSTORE operation) then
4829 * this set object will be the resulting object to set into the target key*/
4830 dstset = createSetObject();
4831
40d224a9 4832 /* Iterate all the elements of all the sets, add every element a single
4833 * time to the result set */
4834 for (j = 0; j < setsnum; j++) {
51829ed3 4835 if (op == REDIS_OP_DIFF && j == 0 && !dv[j]) break; /* result set is empty */
40d224a9 4836 if (!dv[j]) continue; /* non existing keys are like empty sets */
4837
4838 di = dictGetIterator(dv[j]);
40d224a9 4839
4840 while((de = dictNext(di)) != NULL) {
4841 robj *ele;
4842
4843 /* dictAdd will not add the same element multiple times */
4844 ele = dictGetEntryKey(de);
f4f56e1d 4845 if (op == REDIS_OP_UNION || j == 0) {
4846 if (dictAdd(dstset->ptr,ele,NULL) == DICT_OK) {
4847 incrRefCount(ele);
40d224a9 4848 cardinality++;
4849 }
f4f56e1d 4850 } else if (op == REDIS_OP_DIFF) {
4851 if (dictDelete(dstset->ptr,ele) == DICT_OK) {
4852 cardinality--;
4853 }
40d224a9 4854 }
4855 }
4856 dictReleaseIterator(di);
51829ed3
AG
4857
4858 if (op == REDIS_OP_DIFF && cardinality == 0) break; /* result set is empty */
40d224a9 4859 }
4860
f4f56e1d 4861 /* Output the content of the resulting set, if not in STORE mode */
4862 if (!dstkey) {
4863 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",cardinality));
4864 di = dictGetIterator(dstset->ptr);
f4f56e1d 4865 while((de = dictNext(di)) != NULL) {
4866 robj *ele;
4867
4868 ele = dictGetEntryKey(de);
dd88747b 4869 addReplyBulk(c,ele);
f4f56e1d 4870 }
4871 dictReleaseIterator(di);
83cdfe18
AG
4872 } else {
4873 /* If we have a target key where to store the resulting set
4874 * create this key with the result set inside */
4875 deleteKey(c->db,dstkey);
4876 dictAdd(c->db->dict,dstkey,dstset);
4877 incrRefCount(dstkey);
f4f56e1d 4878 }
4879
4880 /* Cleanup */
40d224a9 4881 if (!dstkey) {
40d224a9 4882 decrRefCount(dstset);
4883 } else {
682ac724 4884 addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n",
03fd01c7 4885 dictSize((dict*)dstset->ptr)));
40d224a9 4886 server.dirty++;
4887 }
4888 zfree(dv);
4889}
4890
4891static void sunionCommand(redisClient *c) {
f4f56e1d 4892 sunionDiffGenericCommand(c,c->argv+1,c->argc-1,NULL,REDIS_OP_UNION);
40d224a9 4893}
4894
4895static void sunionstoreCommand(redisClient *c) {
f4f56e1d 4896 sunionDiffGenericCommand(c,c->argv+2,c->argc-2,c->argv[1],REDIS_OP_UNION);
4897}
4898
4899static void sdiffCommand(redisClient *c) {
4900 sunionDiffGenericCommand(c,c->argv+1,c->argc-1,NULL,REDIS_OP_DIFF);
4901}
4902
4903static void sdiffstoreCommand(redisClient *c) {
4904 sunionDiffGenericCommand(c,c->argv+2,c->argc-2,c->argv[1],REDIS_OP_DIFF);
40d224a9 4905}
4906
6b47e12e 4907/* ==================================== ZSets =============================== */
4908
4909/* ZSETs are ordered sets using two data structures to hold the same elements
4910 * in order to get O(log(N)) INSERT and REMOVE operations into a sorted
4911 * data structure.
4912 *
4913 * The elements are added to an hash table mapping Redis objects to scores.
4914 * At the same time the elements are added to a skip list mapping scores
4915 * to Redis objects (so objects are sorted by scores in this "view"). */
4916
4917/* This skiplist implementation is almost a C translation of the original
4918 * algorithm described by William Pugh in "Skip Lists: A Probabilistic
4919 * Alternative to Balanced Trees", modified in three ways:
4920 * a) this implementation allows for repeated values.
4921 * b) the comparison is not just by key (our 'score') but by satellite data.
4922 * c) there is a back pointer, so it's a doubly linked list with the back
4923 * pointers being only at "level 1". This allows to traverse the list
4924 * from tail to head, useful for ZREVRANGE. */
4925
4926static zskiplistNode *zslCreateNode(int level, double score, robj *obj) {
4927 zskiplistNode *zn = zmalloc(sizeof(*zn));
4928
4929 zn->forward = zmalloc(sizeof(zskiplistNode*) * level);
2b37892e
PN
4930 if (level > 0)
4931 zn->span = zmalloc(sizeof(unsigned int) * (level - 1));
6b47e12e 4932 zn->score = score;
4933 zn->obj = obj;
4934 return zn;
4935}
4936
4937static zskiplist *zslCreate(void) {
4938 int j;
4939 zskiplist *zsl;
4940
4941 zsl = zmalloc(sizeof(*zsl));
4942 zsl->level = 1;
cc812361 4943 zsl->length = 0;
6b47e12e 4944 zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL);
69d95c3e 4945 for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
6b47e12e 4946 zsl->header->forward[j] = NULL;
94e543b5 4947
4948 /* span has space for ZSKIPLIST_MAXLEVEL-1 elements */
4949 if (j < ZSKIPLIST_MAXLEVEL-1)
4950 zsl->header->span[j] = 0;
69d95c3e 4951 }
e3870fab 4952 zsl->header->backward = NULL;
4953 zsl->tail = NULL;
6b47e12e 4954 return zsl;
4955}
4956
fd8ccf44 4957static void zslFreeNode(zskiplistNode *node) {
4958 decrRefCount(node->obj);
ad807e6f 4959 zfree(node->forward);
69d95c3e 4960 zfree(node->span);
fd8ccf44 4961 zfree(node);
4962}
4963
4964static void zslFree(zskiplist *zsl) {
ad807e6f 4965 zskiplistNode *node = zsl->header->forward[0], *next;
fd8ccf44 4966
ad807e6f 4967 zfree(zsl->header->forward);
69d95c3e 4968 zfree(zsl->header->span);
ad807e6f 4969 zfree(zsl->header);
fd8ccf44 4970 while(node) {
599379dd 4971 next = node->forward[0];
fd8ccf44 4972 zslFreeNode(node);
4973 node = next;
4974 }
ad807e6f 4975 zfree(zsl);
fd8ccf44 4976}
4977
6b47e12e 4978static int zslRandomLevel(void) {
4979 int level = 1;
4980 while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
4981 level += 1;
4982 return level;
4983}
4984
4985static void zslInsert(zskiplist *zsl, double score, robj *obj) {
4986 zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
2b37892e 4987 unsigned int rank[ZSKIPLIST_MAXLEVEL];
6b47e12e 4988 int i, level;
4989
4990 x = zsl->header;
4991 for (i = zsl->level-1; i >= 0; i--) {
2b37892e
PN
4992 /* store rank that is crossed to reach the insert position */
4993 rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
69d95c3e 4994
9d60e6e4 4995 while (x->forward[i] &&
4996 (x->forward[i]->score < score ||
4997 (x->forward[i]->score == score &&
69d95c3e 4998 compareStringObjects(x->forward[i]->obj,obj) < 0))) {
a50ea45c 4999 rank[i] += i > 0 ? x->span[i-1] : 1;
6b47e12e 5000 x = x->forward[i];
69d95c3e 5001 }
6b47e12e 5002 update[i] = x;
5003 }
6b47e12e 5004 /* we assume the key is not already inside, since we allow duplicated
5005 * scores, and the re-insertion of score and redis object should never
5006 * happpen since the caller of zslInsert() should test in the hash table
5007 * if the element is already inside or not. */
5008 level = zslRandomLevel();
5009 if (level > zsl->level) {
69d95c3e 5010 for (i = zsl->level; i < level; i++) {
2b37892e 5011 rank[i] = 0;
6b47e12e 5012 update[i] = zsl->header;
2b37892e 5013 update[i]->span[i-1] = zsl->length;
69d95c3e 5014 }
6b47e12e 5015 zsl->level = level;
5016 }
5017 x = zslCreateNode(level,score,obj);
5018 for (i = 0; i < level; i++) {
5019 x->forward[i] = update[i]->forward[i];
5020 update[i]->forward[i] = x;
69d95c3e
PN
5021
5022 /* update span covered by update[i] as x is inserted here */
2b37892e
PN
5023 if (i > 0) {
5024 x->span[i-1] = update[i]->span[i-1] - (rank[0] - rank[i]);
5025 update[i]->span[i-1] = (rank[0] - rank[i]) + 1;
5026 }
6b47e12e 5027 }
69d95c3e
PN
5028
5029 /* increment span for untouched levels */
5030 for (i = level; i < zsl->level; i++) {
2b37892e 5031 update[i]->span[i-1]++;
69d95c3e
PN
5032 }
5033
bb975144 5034 x->backward = (update[0] == zsl->header) ? NULL : update[0];
e3870fab 5035 if (x->forward[0])
5036 x->forward[0]->backward = x;
5037 else
5038 zsl->tail = x;
cc812361 5039 zsl->length++;
6b47e12e 5040}
5041
84105336
PN
5042/* Internal function used by zslDelete, zslDeleteByScore and zslDeleteByRank */
5043void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
5044 int i;
5045 for (i = 0; i < zsl->level; i++) {
5046 if (update[i]->forward[i] == x) {
5047 if (i > 0) {
5048 update[i]->span[i-1] += x->span[i-1] - 1;
5049 }
5050 update[i]->forward[i] = x->forward[i];
5051 } else {
5052 /* invariant: i > 0, because update[0]->forward[0]
5053 * is always equal to x */
5054 update[i]->span[i-1] -= 1;
5055 }
5056 }
5057 if (x->forward[0]) {
5058 x->forward[0]->backward = x->backward;
5059 } else {
5060 zsl->tail = x->backward;
5061 }
5062 while(zsl->level > 1 && zsl->header->forward[zsl->level-1] == NULL)
5063 zsl->level--;
5064 zsl->length--;
5065}
5066
50c55df5 5067/* Delete an element with matching score/object from the skiplist. */
fd8ccf44 5068static int zslDelete(zskiplist *zsl, double score, robj *obj) {
e197b441 5069 zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
5070 int i;
5071
5072 x = zsl->header;
5073 for (i = zsl->level-1; i >= 0; i--) {
9d60e6e4 5074 while (x->forward[i] &&
5075 (x->forward[i]->score < score ||
5076 (x->forward[i]->score == score &&
5077 compareStringObjects(x->forward[i]->obj,obj) < 0)))
e197b441 5078 x = x->forward[i];
5079 update[i] = x;
5080 }
5081 /* We may have multiple elements with the same score, what we need
5082 * is to find the element with both the right score and object. */
5083 x = x->forward[0];
50c55df5 5084 if (x && score == x->score && compareStringObjects(x->obj,obj) == 0) {
84105336 5085 zslDeleteNode(zsl, x, update);
9d60e6e4 5086 zslFreeNode(x);
9d60e6e4 5087 return 1;
5088 } else {
5089 return 0; /* not found */
e197b441 5090 }
5091 return 0; /* not found */
fd8ccf44 5092}
5093
1807985b 5094/* Delete all the elements with score between min and max from the skiplist.
5095 * Min and mx are inclusive, so a score >= min || score <= max is deleted.
5096 * Note that this function takes the reference to the hash table view of the
5097 * sorted set, in order to remove the elements from the hash table too. */
f84d3933 5098static unsigned long zslDeleteRangeByScore(zskiplist *zsl, double min, double max, dict *dict) {
1807985b 5099 zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
5100 unsigned long removed = 0;
5101 int i;
5102
5103 x = zsl->header;
5104 for (i = zsl->level-1; i >= 0; i--) {
5105 while (x->forward[i] && x->forward[i]->score < min)
5106 x = x->forward[i];
5107 update[i] = x;
5108 }
5109 /* We may have multiple elements with the same score, what we need
5110 * is to find the element with both the right score and object. */
5111 x = x->forward[0];
5112 while (x && x->score <= max) {
84105336
PN
5113 zskiplistNode *next = x->forward[0];
5114 zslDeleteNode(zsl, x, update);
1807985b 5115 dictDelete(dict,x->obj);
5116 zslFreeNode(x);
1807985b 5117 removed++;
5118 x = next;
5119 }
5120 return removed; /* not found */
5121}
1807985b 5122
9212eafd 5123/* Delete all the elements with rank between start and end from the skiplist.
2424490f 5124 * Start and end are inclusive. Note that start and end need to be 1-based */
9212eafd
PN
5125static unsigned long zslDeleteRangeByRank(zskiplist *zsl, unsigned int start, unsigned int end, dict *dict) {
5126 zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
5127 unsigned long traversed = 0, removed = 0;
5128 int i;
5129
9212eafd
PN
5130 x = zsl->header;
5131 for (i = zsl->level-1; i >= 0; i--) {
5132 while (x->forward[i] && (traversed + (i > 0 ? x->span[i-1] : 1)) < start) {
5133 traversed += i > 0 ? x->span[i-1] : 1;
5134 x = x->forward[i];
1807985b 5135 }
9212eafd
PN
5136 update[i] = x;
5137 }
5138
5139 traversed++;
5140 x = x->forward[0];
5141 while (x && traversed <= end) {
84105336
PN
5142 zskiplistNode *next = x->forward[0];
5143 zslDeleteNode(zsl, x, update);
1807985b 5144 dictDelete(dict,x->obj);
5145 zslFreeNode(x);
1807985b 5146 removed++;
9212eafd 5147 traversed++;
1807985b 5148 x = next;
5149 }
9212eafd 5150 return removed;
1807985b 5151}
5152
50c55df5 5153/* Find the first node having a score equal or greater than the specified one.
5154 * Returns NULL if there is no match. */
5155static zskiplistNode *zslFirstWithScore(zskiplist *zsl, double score) {
5156 zskiplistNode *x;
5157 int i;
5158
5159 x = zsl->header;
5160 for (i = zsl->level-1; i >= 0; i--) {
5161 while (x->forward[i] && x->forward[i]->score < score)
5162 x = x->forward[i];
5163 }
5164 /* We may have multiple elements with the same score, what we need
5165 * is to find the element with both the right score and object. */
5166 return x->forward[0];
5167}
5168
27b0ccca
PN
5169/* Find the rank for an element by both score and key.
5170 * Returns 0 when the element cannot be found, rank otherwise.
5171 * Note that the rank is 1-based due to the span of zsl->header to the
5172 * first element. */
5173static unsigned long zslGetRank(zskiplist *zsl, double score, robj *o) {
5174 zskiplistNode *x;
5175 unsigned long rank = 0;
5176 int i;
5177
5178 x = zsl->header;
5179 for (i = zsl->level-1; i >= 0; i--) {
5180 while (x->forward[i] &&
5181 (x->forward[i]->score < score ||
5182 (x->forward[i]->score == score &&
5183 compareStringObjects(x->forward[i]->obj,o) <= 0))) {
a50ea45c 5184 rank += i > 0 ? x->span[i-1] : 1;
27b0ccca
PN
5185 x = x->forward[i];
5186 }
5187
5188 /* x might be equal to zsl->header, so test if obj is non-NULL */
5189 if (x->obj && compareStringObjects(x->obj,o) == 0) {
5190 return rank;
5191 }
5192 }
5193 return 0;
5194}
5195
e74825c2
PN
5196/* Finds an element by its rank. The rank argument needs to be 1-based. */
5197zskiplistNode* zslGetElementByRank(zskiplist *zsl, unsigned long rank) {
5198 zskiplistNode *x;
5199 unsigned long traversed = 0;
5200 int i;
5201
5202 x = zsl->header;
5203 for (i = zsl->level-1; i >= 0; i--) {
dd88747b 5204 while (x->forward[i] && (traversed + (i>0 ? x->span[i-1] : 1)) <= rank)
5205 {
a50ea45c 5206 traversed += i > 0 ? x->span[i-1] : 1;
e74825c2
PN
5207 x = x->forward[i];
5208 }
e74825c2
PN
5209 if (traversed == rank) {
5210 return x;
5211 }
5212 }
5213 return NULL;
5214}
5215
fd8ccf44 5216/* The actual Z-commands implementations */
5217
7db723ad 5218/* This generic command implements both ZADD and ZINCRBY.
e2665397 5219 * scoreval is the score if the operation is a ZADD (doincrement == 0) or
7db723ad 5220 * the increment if the operation is a ZINCRBY (doincrement == 1). */
e2665397 5221static void zaddGenericCommand(redisClient *c, robj *key, robj *ele, double scoreval, int doincrement) {
fd8ccf44 5222 robj *zsetobj;
5223 zset *zs;
5224 double *score;
5225
e2665397 5226 zsetobj = lookupKeyWrite(c->db,key);
fd8ccf44 5227 if (zsetobj == NULL) {
5228 zsetobj = createZsetObject();
e2665397 5229 dictAdd(c->db->dict,key,zsetobj);
5230 incrRefCount(key);
fd8ccf44 5231 } else {
5232 if (zsetobj->type != REDIS_ZSET) {
5233 addReply(c,shared.wrongtypeerr);
5234 return;
5235 }
5236 }
fd8ccf44 5237 zs = zsetobj->ptr;
e2665397 5238
7db723ad 5239 /* Ok now since we implement both ZADD and ZINCRBY here the code
e2665397 5240 * needs to handle the two different conditions. It's all about setting
5241 * '*score', that is, the new score to set, to the right value. */
5242 score = zmalloc(sizeof(double));
5243 if (doincrement) {
5244 dictEntry *de;
5245
5246 /* Read the old score. If the element was not present starts from 0 */
5247 de = dictFind(zs->dict,ele);
5248 if (de) {
5249 double *oldscore = dictGetEntryVal(de);
5250 *score = *oldscore + scoreval;
5251 } else {
5252 *score = scoreval;
5253 }
5254 } else {
5255 *score = scoreval;
5256 }
5257
5258 /* What follows is a simple remove and re-insert operation that is common
7db723ad 5259 * to both ZADD and ZINCRBY... */
e2665397 5260 if (dictAdd(zs->dict,ele,score) == DICT_OK) {
fd8ccf44 5261 /* case 1: New element */
e2665397 5262 incrRefCount(ele); /* added to hash */
5263 zslInsert(zs->zsl,*score,ele);
5264 incrRefCount(ele); /* added to skiplist */
fd8ccf44 5265 server.dirty++;
e2665397 5266 if (doincrement)
e2665397 5267 addReplyDouble(c,*score);
91d71bfc 5268 else
5269 addReply(c,shared.cone);
fd8ccf44 5270 } else {
5271 dictEntry *de;
5272 double *oldscore;
5273
5274 /* case 2: Score update operation */
e2665397 5275 de = dictFind(zs->dict,ele);
dfc5e96c 5276 redisAssert(de != NULL);
fd8ccf44 5277 oldscore = dictGetEntryVal(de);
5278 if (*score != *oldscore) {
5279 int deleted;
5280
e2665397 5281 /* Remove and insert the element in the skip list with new score */
5282 deleted = zslDelete(zs->zsl,*oldscore,ele);
dfc5e96c 5283 redisAssert(deleted != 0);
e2665397 5284 zslInsert(zs->zsl,*score,ele);
5285 incrRefCount(ele);
5286 /* Update the score in the hash table */
5287 dictReplace(zs->dict,ele,score);
fd8ccf44 5288 server.dirty++;
2161a965 5289 } else {
5290 zfree(score);
fd8ccf44 5291 }
e2665397 5292 if (doincrement)
5293 addReplyDouble(c,*score);
5294 else
5295 addReply(c,shared.czero);
fd8ccf44 5296 }
5297}
5298
e2665397 5299static void zaddCommand(redisClient *c) {
5300 double scoreval;
5301
5302 scoreval = strtod(c->argv[2]->ptr,NULL);
5303 zaddGenericCommand(c,c->argv[1],c->argv[3],scoreval,0);
5304}
5305
7db723ad 5306static void zincrbyCommand(redisClient *c) {
e2665397 5307 double scoreval;
5308
5309 scoreval = strtod(c->argv[2]->ptr,NULL);
5310 zaddGenericCommand(c,c->argv[1],c->argv[3],scoreval,1);
5311}
5312
1b7106e7 5313static void zremCommand(redisClient *c) {
5314 robj *zsetobj;
5315 zset *zs;
dd88747b 5316 dictEntry *de;
5317 double *oldscore;
5318 int deleted;
1b7106e7 5319
dd88747b 5320 if ((zsetobj = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
5321 checkType(c,zsetobj,REDIS_ZSET)) return;
1b7106e7 5322
dd88747b 5323 zs = zsetobj->ptr;
5324 de = dictFind(zs->dict,c->argv[2]);
5325 if (de == NULL) {
5326 addReply(c,shared.czero);
5327 return;
1b7106e7 5328 }
dd88747b 5329 /* Delete from the skiplist */
5330 oldscore = dictGetEntryVal(de);
5331 deleted = zslDelete(zs->zsl,*oldscore,c->argv[2]);
5332 redisAssert(deleted != 0);
5333
5334 /* Delete from the hash table */
5335 dictDelete(zs->dict,c->argv[2]);
5336 if (htNeedsResize(zs->dict)) dictResize(zs->dict);
5337 server.dirty++;
5338 addReply(c,shared.cone);
1b7106e7 5339}
5340
1807985b 5341static void zremrangebyscoreCommand(redisClient *c) {
5342 double min = strtod(c->argv[2]->ptr,NULL);
5343 double max = strtod(c->argv[3]->ptr,NULL);
dd88747b 5344 long deleted;
1807985b 5345 robj *zsetobj;
5346 zset *zs;
5347
dd88747b 5348 if ((zsetobj = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
5349 checkType(c,zsetobj,REDIS_ZSET)) return;
1807985b 5350
dd88747b 5351 zs = zsetobj->ptr;
5352 deleted = zslDeleteRangeByScore(zs->zsl,min,max,zs->dict);
5353 if (htNeedsResize(zs->dict)) dictResize(zs->dict);
5354 server.dirty += deleted;
5355 addReplyLong(c,deleted);
1807985b 5356}
5357
9212eafd
PN
5358static void zremrangebyrankCommand(redisClient *c) {
5359 int start = atoi(c->argv[2]->ptr);
5360 int end = atoi(c->argv[3]->ptr);
dd88747b 5361 int llen;
5362 long deleted;
9212eafd
PN
5363 robj *zsetobj;
5364 zset *zs;
5365
dd88747b 5366 if ((zsetobj = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
5367 checkType(c,zsetobj,REDIS_ZSET)) return;
5368 zs = zsetobj->ptr;
5369 llen = zs->zsl->length;
9212eafd 5370
dd88747b 5371 /* convert negative indexes */
5372 if (start < 0) start = llen+start;
5373 if (end < 0) end = llen+end;
5374 if (start < 0) start = 0;
5375 if (end < 0) end = 0;
9212eafd 5376
dd88747b 5377 /* indexes sanity checks */
5378 if (start > end || start >= llen) {
5379 addReply(c,shared.czero);
5380 return;
9212eafd 5381 }
dd88747b 5382 if (end >= llen) end = llen-1;
5383
5384 /* increment start and end because zsl*Rank functions
5385 * use 1-based rank */
5386 deleted = zslDeleteRangeByRank(zs->zsl,start+1,end+1,zs->dict);
5387 if (htNeedsResize(zs->dict)) dictResize(zs->dict);
5388 server.dirty += deleted;
5389 addReplyLong(c, deleted);
9212eafd
PN
5390}
5391
8f92e768
PN
5392typedef struct {
5393 dict *dict;
5394 double weight;
5395} zsetopsrc;
5396
5397static int qsortCompareZsetopsrcByCardinality(const void *s1, const void *s2) {
5398 zsetopsrc *d1 = (void*) s1, *d2 = (void*) s2;
5399 unsigned long size1, size2;
5400 size1 = d1->dict ? dictSize(d1->dict) : 0;
5401 size2 = d2->dict ? dictSize(d2->dict) : 0;
5402 return size1 - size2;
5403}
5404
d2764cd6
PN
5405#define REDIS_AGGR_SUM 1
5406#define REDIS_AGGR_MIN 2
5407#define REDIS_AGGR_MAX 3
5408
5409inline static void zunionInterAggregate(double *target, double val, int aggregate) {
5410 if (aggregate == REDIS_AGGR_SUM) {
5411 *target = *target + val;
5412 } else if (aggregate == REDIS_AGGR_MIN) {
5413 *target = val < *target ? val : *target;
5414 } else if (aggregate == REDIS_AGGR_MAX) {
5415 *target = val > *target ? val : *target;
5416 } else {
5417 /* safety net */
5418 redisAssert(0 != 0);
5419 }
5420}
5421
2830ca53 5422static void zunionInterGenericCommand(redisClient *c, robj *dstkey, int op) {
8f92e768 5423 int i, j, zsetnum;
d2764cd6 5424 int aggregate = REDIS_AGGR_SUM;
8f92e768 5425 zsetopsrc *src;
2830ca53
PN
5426 robj *dstobj;
5427 zset *dstzset;
b287c9bb
PN
5428 dictIterator *di;
5429 dictEntry *de;
5430
2830ca53
PN
5431 /* expect zsetnum input keys to be given */
5432 zsetnum = atoi(c->argv[2]->ptr);
5433 if (zsetnum < 1) {
5434 addReplySds(c,sdsnew("-ERR at least 1 input key is needed for ZUNION/ZINTER\r\n"));
5435 return;
b287c9bb 5436 }
2830ca53
PN
5437
5438 /* test if the expected number of keys would overflow */
5439 if (3+zsetnum > c->argc) {
b287c9bb
PN
5440 addReply(c,shared.syntaxerr);
5441 return;
5442 }
5443
2830ca53 5444 /* read keys to be used for input */
b9eed483 5445 src = zmalloc(sizeof(zsetopsrc) * zsetnum);
2830ca53 5446 for (i = 0, j = 3; i < zsetnum; i++, j++) {
b287c9bb
PN
5447 robj *zsetobj = lookupKeyWrite(c->db,c->argv[j]);
5448 if (!zsetobj) {
8f92e768 5449 src[i].dict = NULL;
b287c9bb
PN
5450 } else {
5451 if (zsetobj->type != REDIS_ZSET) {
8f92e768 5452 zfree(src);
b287c9bb
PN
5453 addReply(c,shared.wrongtypeerr);
5454 return;
5455 }
8f92e768 5456 src[i].dict = ((zset*)zsetobj->ptr)->dict;
b287c9bb 5457 }
2830ca53
PN
5458
5459 /* default all weights to 1 */
8f92e768 5460 src[i].weight = 1.0;
b287c9bb
PN
5461 }
5462
2830ca53
PN
5463 /* parse optional extra arguments */
5464 if (j < c->argc) {
d2764cd6 5465 int remaining = c->argc - j;
b287c9bb 5466
2830ca53 5467 while (remaining) {
d2764cd6 5468 if (remaining >= (zsetnum + 1) && !strcasecmp(c->argv[j]->ptr,"weights")) {
2830ca53 5469 j++; remaining--;
2830ca53 5470 for (i = 0; i < zsetnum; i++, j++, remaining--) {
8f92e768 5471 src[i].weight = strtod(c->argv[j]->ptr, NULL);
2830ca53 5472 }
d2764cd6
PN
5473 } else if (remaining >= 2 && !strcasecmp(c->argv[j]->ptr,"aggregate")) {
5474 j++; remaining--;
5475 if (!strcasecmp(c->argv[j]->ptr,"sum")) {
5476 aggregate = REDIS_AGGR_SUM;
5477 } else if (!strcasecmp(c->argv[j]->ptr,"min")) {
5478 aggregate = REDIS_AGGR_MIN;
5479 } else if (!strcasecmp(c->argv[j]->ptr,"max")) {
5480 aggregate = REDIS_AGGR_MAX;
5481 } else {
5482 zfree(src);
5483 addReply(c,shared.syntaxerr);
5484 return;
5485 }
5486 j++; remaining--;
2830ca53 5487 } else {
8f92e768 5488 zfree(src);
2830ca53
PN
5489 addReply(c,shared.syntaxerr);
5490 return;
5491 }
5492 }
5493 }
b287c9bb 5494
d2764cd6
PN
5495 /* sort sets from the smallest to largest, this will improve our
5496 * algorithm's performance */
5497 qsort(src,zsetnum,sizeof(zsetopsrc), qsortCompareZsetopsrcByCardinality);
5498
2830ca53
PN
5499 dstobj = createZsetObject();
5500 dstzset = dstobj->ptr;
5501
5502 if (op == REDIS_OP_INTER) {
8f92e768
PN
5503 /* skip going over all entries if the smallest zset is NULL or empty */
5504 if (src[0].dict && dictSize(src[0].dict) > 0) {
5505 /* precondition: as src[0].dict is non-empty and the zsets are ordered
5506 * from small to large, all src[i > 0].dict are non-empty too */
5507 di = dictGetIterator(src[0].dict);
2830ca53 5508 while((de = dictNext(di)) != NULL) {
d2764cd6
PN
5509 double *score = zmalloc(sizeof(double)), value;
5510 *score = src[0].weight * (*(double*)dictGetEntryVal(de));
2830ca53 5511
d2764cd6
PN
5512 for (j = 1; j < zsetnum; j++) {
5513 dictEntry *other = dictFind(src[j].dict,dictGetEntryKey(de));
2830ca53 5514 if (other) {
d2764cd6
PN
5515 value = src[j].weight * (*(double*)dictGetEntryVal(other));
5516 zunionInterAggregate(score, value, aggregate);
2830ca53
PN
5517 } else {
5518 break;
5519 }
5520 }
b287c9bb 5521
2830ca53 5522 /* skip entry when not present in every source dict */
8f92e768 5523 if (j != zsetnum) {
2830ca53
PN
5524 zfree(score);
5525 } else {
5526 robj *o = dictGetEntryKey(de);
5527 dictAdd(dstzset->dict,o,score);
5528 incrRefCount(o); /* added to dictionary */
5529 zslInsert(dstzset->zsl,*score,o);
5530 incrRefCount(o); /* added to skiplist */
b287c9bb
PN
5531 }
5532 }
2830ca53
PN
5533 dictReleaseIterator(di);
5534 }
5535 } else if (op == REDIS_OP_UNION) {
5536 for (i = 0; i < zsetnum; i++) {
8f92e768 5537 if (!src[i].dict) continue;
2830ca53 5538
8f92e768 5539 di = dictGetIterator(src[i].dict);
2830ca53
PN
5540 while((de = dictNext(di)) != NULL) {
5541 /* skip key when already processed */
5542 if (dictFind(dstzset->dict,dictGetEntryKey(de)) != NULL) continue;
5543
d2764cd6
PN
5544 double *score = zmalloc(sizeof(double)), value;
5545 *score = src[i].weight * (*(double*)dictGetEntryVal(de));
2830ca53 5546
d2764cd6
PN
5547 /* because the zsets are sorted by size, its only possible
5548 * for sets at larger indices to hold this entry */
5549 for (j = (i+1); j < zsetnum; j++) {
5550 dictEntry *other = dictFind(src[j].dict,dictGetEntryKey(de));
2830ca53 5551 if (other) {
d2764cd6
PN
5552 value = src[j].weight * (*(double*)dictGetEntryVal(other));
5553 zunionInterAggregate(score, value, aggregate);
2830ca53
PN
5554 }
5555 }
b287c9bb 5556
2830ca53
PN
5557 robj *o = dictGetEntryKey(de);
5558 dictAdd(dstzset->dict,o,score);
5559 incrRefCount(o); /* added to dictionary */
5560 zslInsert(dstzset->zsl,*score,o);
5561 incrRefCount(o); /* added to skiplist */
5562 }
5563 dictReleaseIterator(di);
b287c9bb 5564 }
2830ca53
PN
5565 } else {
5566 /* unknown operator */
5567 redisAssert(op == REDIS_OP_INTER || op == REDIS_OP_UNION);
b287c9bb
PN
5568 }
5569
5570 deleteKey(c->db,dstkey);
5571 dictAdd(c->db->dict,dstkey,dstobj);
5572 incrRefCount(dstkey);
5573
2830ca53 5574 addReplyLong(c, dstzset->zsl->length);
b287c9bb 5575 server.dirty++;
8f92e768 5576 zfree(src);
b287c9bb
PN
5577}
5578
2830ca53
PN
5579static void zunionCommand(redisClient *c) {
5580 zunionInterGenericCommand(c,c->argv[1], REDIS_OP_UNION);
b287c9bb
PN
5581}
5582
2830ca53
PN
5583static void zinterCommand(redisClient *c) {
5584 zunionInterGenericCommand(c,c->argv[1], REDIS_OP_INTER);
b287c9bb
PN
5585}
5586
e3870fab 5587static void zrangeGenericCommand(redisClient *c, int reverse) {
cc812361 5588 robj *o;
5589 int start = atoi(c->argv[2]->ptr);
5590 int end = atoi(c->argv[3]->ptr);
752da584 5591 int withscores = 0;
dd88747b 5592 int llen;
5593 int rangelen, j;
5594 zset *zsetobj;
5595 zskiplist *zsl;
5596 zskiplistNode *ln;
5597 robj *ele;
752da584 5598
5599 if (c->argc == 5 && !strcasecmp(c->argv[4]->ptr,"withscores")) {
5600 withscores = 1;
5601 } else if (c->argc >= 5) {
5602 addReply(c,shared.syntaxerr);
5603 return;
5604 }
cc812361 5605
dd88747b 5606 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullmultibulk)) == NULL ||
5607 checkType(c,o,REDIS_ZSET)) return;
5608 zsetobj = o->ptr;
5609 zsl = zsetobj->zsl;
5610 llen = zsl->length;
cc812361 5611
dd88747b 5612 /* convert negative indexes */
5613 if (start < 0) start = llen+start;
5614 if (end < 0) end = llen+end;
5615 if (start < 0) start = 0;
5616 if (end < 0) end = 0;
cc812361 5617
dd88747b 5618 /* indexes sanity checks */
5619 if (start > end || start >= llen) {
5620 /* Out of range start or start > end result in empty list */
5621 addReply(c,shared.emptymultibulk);
5622 return;
5623 }
5624 if (end >= llen) end = llen-1;
5625 rangelen = (end-start)+1;
cc812361 5626
dd88747b 5627 /* check if starting point is trivial, before searching
5628 * the element in log(N) time */
5629 if (reverse) {
5630 ln = start == 0 ? zsl->tail : zslGetElementByRank(zsl, llen-start);
5631 } else {
5632 ln = start == 0 ?
5633 zsl->header->forward[0] : zslGetElementByRank(zsl, start+1);
5634 }
cc812361 5635
dd88747b 5636 /* Return the result in form of a multi-bulk reply */
5637 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",
5638 withscores ? (rangelen*2) : rangelen));
5639 for (j = 0; j < rangelen; j++) {
5640 ele = ln->obj;
5641 addReplyBulk(c,ele);
5642 if (withscores)
5643 addReplyDouble(c,ln->score);
5644 ln = reverse ? ln->backward : ln->forward[0];
cc812361 5645 }
5646}
5647
e3870fab 5648static void zrangeCommand(redisClient *c) {
5649 zrangeGenericCommand(c,0);
5650}
5651
5652static void zrevrangeCommand(redisClient *c) {
5653 zrangeGenericCommand(c,1);
5654}
5655
f44dd428 5656/* This command implements both ZRANGEBYSCORE and ZCOUNT.
5657 * If justcount is non-zero, just the count is returned. */
5658static void genericZrangebyscoreCommand(redisClient *c, int justcount) {
50c55df5 5659 robj *o;
f44dd428 5660 double min, max;
5661 int minex = 0, maxex = 0; /* are min or max exclusive? */
80181f78 5662 int offset = 0, limit = -1;
0500ef27
SH
5663 int withscores = 0;
5664 int badsyntax = 0;
5665
f44dd428 5666 /* Parse the min-max interval. If one of the values is prefixed
5667 * by the "(" character, it's considered "open". For instance
5668 * ZRANGEBYSCORE zset (1.5 (2.5 will match min < x < max
5669 * ZRANGEBYSCORE zset 1.5 2.5 will instead match min <= x <= max */
5670 if (((char*)c->argv[2]->ptr)[0] == '(') {
5671 min = strtod((char*)c->argv[2]->ptr+1,NULL);
5672 minex = 1;
5673 } else {
5674 min = strtod(c->argv[2]->ptr,NULL);
5675 }
5676 if (((char*)c->argv[3]->ptr)[0] == '(') {
5677 max = strtod((char*)c->argv[3]->ptr+1,NULL);
5678 maxex = 1;
5679 } else {
5680 max = strtod(c->argv[3]->ptr,NULL);
5681 }
5682
5683 /* Parse "WITHSCORES": note that if the command was called with
5684 * the name ZCOUNT then we are sure that c->argc == 4, so we'll never
5685 * enter the following paths to parse WITHSCORES and LIMIT. */
0500ef27 5686 if (c->argc == 5 || c->argc == 8) {
3a3978b1 5687 if (strcasecmp(c->argv[c->argc-1]->ptr,"withscores") == 0)
5688 withscores = 1;
5689 else
5690 badsyntax = 1;
0500ef27 5691 }
3a3978b1 5692 if (c->argc != (4 + withscores) && c->argc != (7 + withscores))
0500ef27 5693 badsyntax = 1;
0500ef27 5694 if (badsyntax) {
454d4e43 5695 addReplySds(c,
5696 sdsnew("-ERR wrong number of arguments for ZRANGEBYSCORE\r\n"));
80181f78 5697 return;
0500ef27
SH
5698 }
5699
f44dd428 5700 /* Parse "LIMIT" */
0500ef27 5701 if (c->argc == (7 + withscores) && strcasecmp(c->argv[4]->ptr,"limit")) {
80181f78 5702 addReply(c,shared.syntaxerr);
5703 return;
0500ef27 5704 } else if (c->argc == (7 + withscores)) {
80181f78 5705 offset = atoi(c->argv[5]->ptr);
5706 limit = atoi(c->argv[6]->ptr);
0b13687c 5707 if (offset < 0) offset = 0;
80181f78 5708 }
50c55df5 5709
f44dd428 5710 /* Ok, lookup the key and get the range */
50c55df5 5711 o = lookupKeyRead(c->db,c->argv[1]);
5712 if (o == NULL) {
f44dd428 5713 addReply(c,justcount ? shared.czero : shared.nullmultibulk);
50c55df5 5714 } else {
5715 if (o->type != REDIS_ZSET) {
5716 addReply(c,shared.wrongtypeerr);
5717 } else {
5718 zset *zsetobj = o->ptr;
5719 zskiplist *zsl = zsetobj->zsl;
5720 zskiplistNode *ln;
f44dd428 5721 robj *ele, *lenobj = NULL;
5722 unsigned long rangelen = 0;
50c55df5 5723
f44dd428 5724 /* Get the first node with the score >= min, or with
5725 * score > min if 'minex' is true. */
50c55df5 5726 ln = zslFirstWithScore(zsl,min);
f44dd428 5727 while (minex && ln && ln->score == min) ln = ln->forward[0];
5728
50c55df5 5729 if (ln == NULL) {
5730 /* No element matching the speciifed interval */
f44dd428 5731 addReply(c,justcount ? shared.czero : shared.emptymultibulk);
50c55df5 5732 return;
5733 }
5734
5735 /* We don't know in advance how many matching elements there
5736 * are in the list, so we push this object that will represent
5737 * the multi-bulk length in the output buffer, and will "fix"
5738 * it later */
f44dd428 5739 if (!justcount) {
5740 lenobj = createObject(REDIS_STRING,NULL);
5741 addReply(c,lenobj);
5742 decrRefCount(lenobj);
5743 }
50c55df5 5744
f44dd428 5745 while(ln && (maxex ? (ln->score < max) : (ln->score <= max))) {
80181f78 5746 if (offset) {
5747 offset--;
5748 ln = ln->forward[0];
5749 continue;
5750 }
5751 if (limit == 0) break;
f44dd428 5752 if (!justcount) {
5753 ele = ln->obj;
dd88747b 5754 addReplyBulk(c,ele);
f44dd428 5755 if (withscores)
5756 addReplyDouble(c,ln->score);
5757 }
50c55df5 5758 ln = ln->forward[0];
5759 rangelen++;
80181f78 5760 if (limit > 0) limit--;
50c55df5 5761 }
f44dd428 5762 if (justcount) {
5763 addReplyLong(c,(long)rangelen);
5764 } else {
5765 lenobj->ptr = sdscatprintf(sdsempty(),"*%lu\r\n",
5766 withscores ? (rangelen*2) : rangelen);
5767 }
50c55df5 5768 }
5769 }
5770}
5771
f44dd428 5772static void zrangebyscoreCommand(redisClient *c) {
5773 genericZrangebyscoreCommand(c,0);
5774}
5775
5776static void zcountCommand(redisClient *c) {
5777 genericZrangebyscoreCommand(c,1);
5778}
5779
3c41331e 5780static void zcardCommand(redisClient *c) {
e197b441 5781 robj *o;
5782 zset *zs;
dd88747b 5783
5784 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
5785 checkType(c,o,REDIS_ZSET)) return;
5786
5787 zs = o->ptr;
5788 addReplyUlong(c,zs->zsl->length);
e197b441 5789}
5790
6e333bbe 5791static void zscoreCommand(redisClient *c) {
5792 robj *o;
5793 zset *zs;
dd88747b 5794 dictEntry *de;
5795
5796 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
5797 checkType(c,o,REDIS_ZSET)) return;
5798
5799 zs = o->ptr;
5800 de = dictFind(zs->dict,c->argv[2]);
5801 if (!de) {
96d8b4ee 5802 addReply(c,shared.nullbulk);
6e333bbe 5803 } else {
dd88747b 5804 double *score = dictGetEntryVal(de);
6e333bbe 5805
dd88747b 5806 addReplyDouble(c,*score);
6e333bbe 5807 }
5808}
5809
798d9e55 5810static void zrankGenericCommand(redisClient *c, int reverse) {
69d95c3e 5811 robj *o;
dd88747b 5812 zset *zs;
5813 zskiplist *zsl;
5814 dictEntry *de;
5815 unsigned long rank;
5816 double *score;
5817
5818 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
5819 checkType(c,o,REDIS_ZSET)) return;
5820
5821 zs = o->ptr;
5822 zsl = zs->zsl;
5823 de = dictFind(zs->dict,c->argv[2]);
5824 if (!de) {
69d95c3e
PN
5825 addReply(c,shared.nullbulk);
5826 return;
5827 }
69d95c3e 5828
dd88747b 5829 score = dictGetEntryVal(de);
5830 rank = zslGetRank(zsl, *score, c->argv[2]);
5831 if (rank) {
5832 if (reverse) {
5833 addReplyLong(c, zsl->length - rank);
27b0ccca 5834 } else {
dd88747b 5835 addReplyLong(c, rank-1);
69d95c3e 5836 }
dd88747b 5837 } else {
5838 addReply(c,shared.nullbulk);
978c2c94 5839 }
5840}
5841
798d9e55
PN
5842static void zrankCommand(redisClient *c) {
5843 zrankGenericCommand(c, 0);
5844}
5845
5846static void zrevrankCommand(redisClient *c) {
5847 zrankGenericCommand(c, 1);
5848}
5849
cbba7dd7 5850/* =================================== Hashes =============================== */
978c2c94 5851static void hsetCommand(redisClient *c) {
5852 int update = 0;
5853 robj *o = lookupKeyWrite(c->db,c->argv[1]);
5854
5855 if (o == NULL) {
5856 o = createHashObject();
5857 dictAdd(c->db->dict,c->argv[1],o);
5858 incrRefCount(c->argv[1]);
5859 } else {
5860 if (o->type != REDIS_HASH) {
5861 addReply(c,shared.wrongtypeerr);
5862 return;
5863 }
5864 }
bae2c7ec 5865 /* We want to convert the zipmap into an hash table right now if the
5866 * entry to be added is too big. Note that we check if the object
5867 * is integer encoded before to try fetching the length in the test below.
5868 * This is because integers are small, but currently stringObjectLen()
5869 * performs a slow conversion: not worth it. */
5870 if (o->encoding == REDIS_ENCODING_ZIPMAP &&
5871 ((c->argv[2]->encoding == REDIS_ENCODING_RAW &&
5872 sdslen(c->argv[2]->ptr) > server.hash_max_zipmap_value) ||
5873 (c->argv[3]->encoding == REDIS_ENCODING_RAW &&
5874 sdslen(c->argv[3]->ptr) > server.hash_max_zipmap_value)))
5875 {
5876 convertToRealHash(o);
5877 }
5878
978c2c94 5879 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
5880 unsigned char *zm = o->ptr;
b1befe6a 5881 robj *valobj = getDecodedObject(c->argv[3]);
978c2c94 5882
5883 zm = zipmapSet(zm,c->argv[2]->ptr,sdslen(c->argv[2]->ptr),
b1befe6a 5884 valobj->ptr,sdslen(valobj->ptr),&update);
5885 decrRefCount(valobj);
cbba7dd7 5886 o->ptr = zm;
bae2c7ec 5887
5888 /* And here there is the second check for hash conversion...
5889 * we want to do it only if the operation was not just an update as
5890 * zipmapLen() is O(N). */
5891 if (!update && zipmapLen(zm) > server.hash_max_zipmap_entries)
5892 convertToRealHash(o);
978c2c94 5893 } else {
bae2c7ec 5894 tryObjectEncoding(c->argv[2]);
5895 /* note that c->argv[3] is already encoded, as the latest arg
5896 * of a bulk command is always integer encoded if possible. */
2069d06a 5897 if (dictReplace(o->ptr,c->argv[2],c->argv[3])) {
978c2c94 5898 incrRefCount(c->argv[2]);
5899 } else {
5900 update = 1;
5901 }
5902 incrRefCount(c->argv[3]);
5903 }
5904 server.dirty++;
5905 addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",update == 0));
5906}
5907
5908static void hgetCommand(redisClient *c) {
dd88747b 5909 robj *o;
978c2c94 5910
dd88747b 5911 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
5912 checkType(c,o,REDIS_HASH)) return;
5913
5914 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
5915 unsigned char *zm = o->ptr;
5916 unsigned char *val;
5917 unsigned int vlen;
164ee595 5918 robj *field;
dd88747b 5919
164ee595 5920 field = getDecodedObject(c->argv[2]);
5921 if (zipmapGet(zm,field->ptr,sdslen(field->ptr), &val,&vlen)) {
dd88747b 5922 addReplySds(c,sdscatprintf(sdsempty(),"$%u\r\n", vlen));
5923 addReplySds(c,sdsnewlen(val,vlen));
5924 addReply(c,shared.crlf);
164ee595 5925 decrRefCount(field);
dd88747b 5926 return;
5927 } else {
5928 addReply(c,shared.nullbulk);
164ee595 5929 decrRefCount(field);
bcd11906 5930 return;
5931 }
dd88747b 5932 } else {
5933 struct dictEntry *de;
bcd11906 5934
dd88747b 5935 de = dictFind(o->ptr,c->argv[2]);
5936 if (de == NULL) {
5937 addReply(c,shared.nullbulk);
978c2c94 5938 } else {
dd88747b 5939 robj *e = dictGetEntryVal(de);
978c2c94 5940
dd88747b 5941 addReplyBulk(c,e);
978c2c94 5942 }
69d95c3e 5943 }
69d95c3e
PN
5944}
5945
07efaf74 5946static void hdelCommand(redisClient *c) {
dd88747b 5947 robj *o;
5948 int deleted = 0;
07efaf74 5949
dd88747b 5950 if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
5951 checkType(c,o,REDIS_HASH)) return;
07efaf74 5952
dd88747b 5953 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
2a1198b4 5954 robj *field = getDecodedObject(c->argv[2]);
5955
dd88747b 5956 o->ptr = zipmapDel((unsigned char*) o->ptr,
2a1198b4 5957 (unsigned char*) field->ptr,
5958 sdslen(field->ptr), &deleted);
5959 decrRefCount(field);
dd88747b 5960 } else {
5961 deleted = dictDelete((dict*)o->ptr,c->argv[2]) == DICT_OK;
07efaf74 5962 }
c77169b7 5963 if (deleted) server.dirty++;
dd88747b 5964 addReply(c,deleted ? shared.cone : shared.czero);
07efaf74 5965}
5966
92b27fe9 5967static void hlenCommand(redisClient *c) {
5968 robj *o;
5969 unsigned long len;
5970
dd88747b 5971 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
92b27fe9 5972 checkType(c,o,REDIS_HASH)) return;
5973
5974 len = (o->encoding == REDIS_ENCODING_ZIPMAP) ?
5975 zipmapLen((unsigned char*)o->ptr) : dictSize((dict*)o->ptr);
5976 addReplyUlong(c,len);
5977}
5978
78409a0f 5979#define REDIS_GETALL_KEYS 1
5980#define REDIS_GETALL_VALS 2
5981static void genericHgetallCommand(redisClient *c, int flags) {
5982 robj *o, *lenobj;
5983 unsigned long count = 0;
5984
5985 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullmultibulk)) == NULL
5986 || checkType(c,o,REDIS_HASH)) return;
5987
5988 lenobj = createObject(REDIS_STRING,NULL);
5989 addReply(c,lenobj);
5990 decrRefCount(lenobj);
5991
5992 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
5993 unsigned char *p = zipmapRewind(o->ptr);
5994 unsigned char *field, *val;
5995 unsigned int flen, vlen;
5996
5997 while((p = zipmapNext(p,&field,&flen,&val,&vlen)) != NULL) {
5998 robj *aux;
5999
6000 if (flags & REDIS_GETALL_KEYS) {
6001 aux = createStringObject((char*)field,flen);
6002 addReplyBulk(c,aux);
6003 decrRefCount(aux);
6004 count++;
6005 }
6006 if (flags & REDIS_GETALL_VALS) {
6007 aux = createStringObject((char*)val,vlen);
6008 addReplyBulk(c,aux);
6009 decrRefCount(aux);
6010 count++;
6011 }
6012 }
6013 } else {
6014 dictIterator *di = dictGetIterator(o->ptr);
6015 dictEntry *de;
6016
6017 while((de = dictNext(di)) != NULL) {
6018 robj *fieldobj = dictGetEntryKey(de);
6019 robj *valobj = dictGetEntryVal(de);
6020
6021 if (flags & REDIS_GETALL_KEYS) {
6022 addReplyBulk(c,fieldobj);
6023 count++;
6024 }
6025 if (flags & REDIS_GETALL_VALS) {
6026 addReplyBulk(c,valobj);
6027 count++;
6028 }
6029 }
6030 dictReleaseIterator(di);
6031 }
6032 lenobj->ptr = sdscatprintf(sdsempty(),"*%lu\r\n",count);
6033}
6034
6035static void hkeysCommand(redisClient *c) {
6036 genericHgetallCommand(c,REDIS_GETALL_KEYS);
6037}
6038
6039static void hvalsCommand(redisClient *c) {
6040 genericHgetallCommand(c,REDIS_GETALL_VALS);
6041}
6042
6043static void hgetallCommand(redisClient *c) {
6044 genericHgetallCommand(c,REDIS_GETALL_KEYS|REDIS_GETALL_VALS);
6045}
6046
a86f14b1 6047static void hexistsCommand(redisClient *c) {
6048 robj *o;
6049 int exists = 0;
6050
6051 if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
6052 checkType(c,o,REDIS_HASH)) return;
6053
6054 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
6055 robj *field;
6056 unsigned char *zm = o->ptr;
6057
6058 field = getDecodedObject(c->argv[2]);
6059 exists = zipmapExists(zm,field->ptr,sdslen(field->ptr));
6060 decrRefCount(field);
6061 } else {
6062 exists = dictFind(o->ptr,c->argv[2]) != NULL;
6063 }
6064 addReply(c,exists ? shared.cone : shared.czero);
6065}
6066
ada386b2 6067static void convertToRealHash(robj *o) {
6068 unsigned char *key, *val, *p, *zm = o->ptr;
6069 unsigned int klen, vlen;
6070 dict *dict = dictCreate(&hashDictType,NULL);
6071
6072 assert(o->type == REDIS_HASH && o->encoding != REDIS_ENCODING_HT);
6073 p = zipmapRewind(zm);
6074 while((p = zipmapNext(p,&key,&klen,&val,&vlen)) != NULL) {
6075 robj *keyobj, *valobj;
6076
6077 keyobj = createStringObject((char*)key,klen);
6078 valobj = createStringObject((char*)val,vlen);
6079 tryObjectEncoding(keyobj);
6080 tryObjectEncoding(valobj);
6081 dictAdd(dict,keyobj,valobj);
6082 }
6083 o->encoding = REDIS_ENCODING_HT;
6084 o->ptr = dict;
6085 zfree(zm);
6086}
6087
6b47e12e 6088/* ========================= Non type-specific commands ==================== */
6089
ed9b544e 6090static void flushdbCommand(redisClient *c) {
ca37e9cd 6091 server.dirty += dictSize(c->db->dict);
3305306f 6092 dictEmpty(c->db->dict);
6093 dictEmpty(c->db->expires);
ed9b544e 6094 addReply(c,shared.ok);
ed9b544e 6095}
6096
6097static void flushallCommand(redisClient *c) {
ca37e9cd 6098 server.dirty += emptyDb();
ed9b544e 6099 addReply(c,shared.ok);
f78fd11b 6100 rdbSave(server.dbfilename);
ca37e9cd 6101 server.dirty++;
ed9b544e 6102}
6103
56906eef 6104static redisSortOperation *createSortOperation(int type, robj *pattern) {
ed9b544e 6105 redisSortOperation *so = zmalloc(sizeof(*so));
ed9b544e 6106 so->type = type;
6107 so->pattern = pattern;
6108 return so;
6109}
6110
6111/* Return the value associated to the key with a name obtained
6112 * substituting the first occurence of '*' in 'pattern' with 'subst' */
56906eef 6113static robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) {
ed9b544e 6114 char *p;
6115 sds spat, ssub;
6116 robj keyobj;
6117 int prefixlen, sublen, postfixlen;
ed9b544e 6118 /* Expoit the internal sds representation to create a sds string allocated on the stack in order to make this function faster */
6119 struct {
f1017b3f 6120 long len;
6121 long free;
ed9b544e 6122 char buf[REDIS_SORTKEY_MAX+1];
6123 } keyname;
6124
28173a49 6125 /* If the pattern is "#" return the substitution object itself in order
6126 * to implement the "SORT ... GET #" feature. */
6127 spat = pattern->ptr;
6128 if (spat[0] == '#' && spat[1] == '\0') {
6129 return subst;
6130 }
6131
6132 /* The substitution object may be specially encoded. If so we create
9d65a1bb 6133 * a decoded object on the fly. Otherwise getDecodedObject will just
6134 * increment the ref count, that we'll decrement later. */
6135 subst = getDecodedObject(subst);
942a3961 6136
ed9b544e 6137 ssub = subst->ptr;
6138 if (sdslen(spat)+sdslen(ssub)-1 > REDIS_SORTKEY_MAX) return NULL;
6139 p = strchr(spat,'*');
ed5a857a 6140 if (!p) {
6141 decrRefCount(subst);
6142 return NULL;
6143 }
ed9b544e 6144
6145 prefixlen = p-spat;
6146 sublen = sdslen(ssub);
6147 postfixlen = sdslen(spat)-(prefixlen+1);
6148 memcpy(keyname.buf,spat,prefixlen);
6149 memcpy(keyname.buf+prefixlen,ssub,sublen);
6150 memcpy(keyname.buf+prefixlen+sublen,p+1,postfixlen);
6151 keyname.buf[prefixlen+sublen+postfixlen] = '\0';
6152 keyname.len = prefixlen+sublen+postfixlen;
6153
dfc5e96c 6154 initStaticStringObject(keyobj,((char*)&keyname)+(sizeof(long)*2))
942a3961 6155 decrRefCount(subst);
6156
a4d1ba9a 6157 /* printf("lookup '%s' => %p\n", keyname.buf,de); */
3305306f 6158 return lookupKeyRead(db,&keyobj);
ed9b544e 6159}
6160
6161/* sortCompare() is used by qsort in sortCommand(). Given that qsort_r with
6162 * the additional parameter is not standard but a BSD-specific we have to
6163 * pass sorting parameters via the global 'server' structure */
6164static int sortCompare(const void *s1, const void *s2) {
6165 const redisSortObject *so1 = s1, *so2 = s2;
6166 int cmp;
6167
6168 if (!server.sort_alpha) {
6169 /* Numeric sorting. Here it's trivial as we precomputed scores */
6170 if (so1->u.score > so2->u.score) {
6171 cmp = 1;
6172 } else if (so1->u.score < so2->u.score) {
6173 cmp = -1;
6174 } else {
6175 cmp = 0;
6176 }
6177 } else {
6178 /* Alphanumeric sorting */
6179 if (server.sort_bypattern) {
6180 if (!so1->u.cmpobj || !so2->u.cmpobj) {
6181 /* At least one compare object is NULL */
6182 if (so1->u.cmpobj == so2->u.cmpobj)
6183 cmp = 0;
6184 else if (so1->u.cmpobj == NULL)
6185 cmp = -1;
6186 else
6187 cmp = 1;
6188 } else {
6189 /* We have both the objects, use strcoll */
6190 cmp = strcoll(so1->u.cmpobj->ptr,so2->u.cmpobj->ptr);
6191 }
6192 } else {
6193 /* Compare elements directly */
9d65a1bb 6194 robj *dec1, *dec2;
6195
6196 dec1 = getDecodedObject(so1->obj);
6197 dec2 = getDecodedObject(so2->obj);
6198 cmp = strcoll(dec1->ptr,dec2->ptr);
6199 decrRefCount(dec1);
6200 decrRefCount(dec2);
ed9b544e 6201 }
6202 }
6203 return server.sort_desc ? -cmp : cmp;
6204}
6205
6206/* The SORT command is the most complex command in Redis. Warning: this code
6207 * is optimized for speed and a bit less for readability */
6208static void sortCommand(redisClient *c) {
ed9b544e 6209 list *operations;
6210 int outputlen = 0;
6211 int desc = 0, alpha = 0;
6212 int limit_start = 0, limit_count = -1, start, end;
6213 int j, dontsort = 0, vectorlen;
6214 int getop = 0; /* GET operation counter */
443c6409 6215 robj *sortval, *sortby = NULL, *storekey = NULL;
ed9b544e 6216 redisSortObject *vector; /* Resulting vector to sort */
6217
6218 /* Lookup the key to sort. It must be of the right types */
3305306f 6219 sortval = lookupKeyRead(c->db,c->argv[1]);
6220 if (sortval == NULL) {
d922ae65 6221 addReply(c,shared.nullmultibulk);
ed9b544e 6222 return;
6223 }
a5eb649b 6224 if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST &&
6225 sortval->type != REDIS_ZSET)
6226 {
c937aa89 6227 addReply(c,shared.wrongtypeerr);
ed9b544e 6228 return;
6229 }
6230
6231 /* Create a list of operations to perform for every sorted element.
6232 * Operations can be GET/DEL/INCR/DECR */
6233 operations = listCreate();
092dac2a 6234 listSetFreeMethod(operations,zfree);
ed9b544e 6235 j = 2;
6236
6237 /* Now we need to protect sortval incrementing its count, in the future
6238 * SORT may have options able to overwrite/delete keys during the sorting
6239 * and the sorted key itself may get destroied */
6240 incrRefCount(sortval);
6241
6242 /* The SORT command has an SQL-alike syntax, parse it */
6243 while(j < c->argc) {
6244 int leftargs = c->argc-j-1;
6245 if (!strcasecmp(c->argv[j]->ptr,"asc")) {
6246 desc = 0;
6247 } else if (!strcasecmp(c->argv[j]->ptr,"desc")) {
6248 desc = 1;
6249 } else if (!strcasecmp(c->argv[j]->ptr,"alpha")) {
6250 alpha = 1;
6251 } else if (!strcasecmp(c->argv[j]->ptr,"limit") && leftargs >= 2) {
6252 limit_start = atoi(c->argv[j+1]->ptr);
6253 limit_count = atoi(c->argv[j+2]->ptr);
6254 j+=2;
443c6409 6255 } else if (!strcasecmp(c->argv[j]->ptr,"store") && leftargs >= 1) {
6256 storekey = c->argv[j+1];
6257 j++;
ed9b544e 6258 } else if (!strcasecmp(c->argv[j]->ptr,"by") && leftargs >= 1) {
6259 sortby = c->argv[j+1];
6260 /* If the BY pattern does not contain '*', i.e. it is constant,
6261 * we don't need to sort nor to lookup the weight keys. */
6262 if (strchr(c->argv[j+1]->ptr,'*') == NULL) dontsort = 1;
6263 j++;
6264 } else if (!strcasecmp(c->argv[j]->ptr,"get") && leftargs >= 1) {
6265 listAddNodeTail(operations,createSortOperation(
6266 REDIS_SORT_GET,c->argv[j+1]));
6267 getop++;
6268 j++;
ed9b544e 6269 } else {
6270 decrRefCount(sortval);
6271 listRelease(operations);
c937aa89 6272 addReply(c,shared.syntaxerr);
ed9b544e 6273 return;
6274 }
6275 j++;
6276 }
6277
6278 /* Load the sorting vector with all the objects to sort */
a5eb649b 6279 switch(sortval->type) {
6280 case REDIS_LIST: vectorlen = listLength((list*)sortval->ptr); break;
6281 case REDIS_SET: vectorlen = dictSize((dict*)sortval->ptr); break;
6282 case REDIS_ZSET: vectorlen = dictSize(((zset*)sortval->ptr)->dict); break;
dfc5e96c 6283 default: vectorlen = 0; redisAssert(0); /* Avoid GCC warning */
a5eb649b 6284 }
ed9b544e 6285 vector = zmalloc(sizeof(redisSortObject)*vectorlen);
ed9b544e 6286 j = 0;
a5eb649b 6287
ed9b544e 6288 if (sortval->type == REDIS_LIST) {
6289 list *list = sortval->ptr;
6208b3a7 6290 listNode *ln;
c7df85a4 6291 listIter li;
6208b3a7 6292
c7df85a4 6293 listRewind(list,&li);
6294 while((ln = listNext(&li))) {
ed9b544e 6295 robj *ele = ln->value;
6296 vector[j].obj = ele;
6297 vector[j].u.score = 0;
6298 vector[j].u.cmpobj = NULL;
ed9b544e 6299 j++;
6300 }
6301 } else {
a5eb649b 6302 dict *set;
ed9b544e 6303 dictIterator *di;
6304 dictEntry *setele;
6305
a5eb649b 6306 if (sortval->type == REDIS_SET) {
6307 set = sortval->ptr;
6308 } else {
6309 zset *zs = sortval->ptr;
6310 set = zs->dict;
6311 }
6312
ed9b544e 6313 di = dictGetIterator(set);
ed9b544e 6314 while((setele = dictNext(di)) != NULL) {
6315 vector[j].obj = dictGetEntryKey(setele);
6316 vector[j].u.score = 0;
6317 vector[j].u.cmpobj = NULL;
6318 j++;
6319 }
6320 dictReleaseIterator(di);
6321 }
dfc5e96c 6322 redisAssert(j == vectorlen);
ed9b544e 6323
6324 /* Now it's time to load the right scores in the sorting vector */
6325 if (dontsort == 0) {
6326 for (j = 0; j < vectorlen; j++) {
6327 if (sortby) {
6328 robj *byval;
6329
3305306f 6330 byval = lookupKeyByPattern(c->db,sortby,vector[j].obj);
ed9b544e 6331 if (!byval || byval->type != REDIS_STRING) continue;
6332 if (alpha) {
9d65a1bb 6333 vector[j].u.cmpobj = getDecodedObject(byval);
ed9b544e 6334 } else {
942a3961 6335 if (byval->encoding == REDIS_ENCODING_RAW) {
6336 vector[j].u.score = strtod(byval->ptr,NULL);
6337 } else {
9d65a1bb 6338 /* Don't need to decode the object if it's
6339 * integer-encoded (the only encoding supported) so
6340 * far. We can just cast it */
f1017b3f 6341 if (byval->encoding == REDIS_ENCODING_INT) {
942a3961 6342 vector[j].u.score = (long)byval->ptr;
f1017b3f 6343 } else
dfc5e96c 6344 redisAssert(1 != 1);
942a3961 6345 }
ed9b544e 6346 }
6347 } else {
942a3961 6348 if (!alpha) {
6349 if (vector[j].obj->encoding == REDIS_ENCODING_RAW)
6350 vector[j].u.score = strtod(vector[j].obj->ptr,NULL);
6351 else {
6352 if (vector[j].obj->encoding == REDIS_ENCODING_INT)
6353 vector[j].u.score = (long) vector[j].obj->ptr;
6354 else
dfc5e96c 6355 redisAssert(1 != 1);
942a3961 6356 }
6357 }
ed9b544e 6358 }
6359 }
6360 }
6361
6362 /* We are ready to sort the vector... perform a bit of sanity check
6363 * on the LIMIT option too. We'll use a partial version of quicksort. */
6364 start = (limit_start < 0) ? 0 : limit_start;
6365 end = (limit_count < 0) ? vectorlen-1 : start+limit_count-1;
6366 if (start >= vectorlen) {
6367 start = vectorlen-1;
6368 end = vectorlen-2;
6369 }
6370 if (end >= vectorlen) end = vectorlen-1;
6371
6372 if (dontsort == 0) {
6373 server.sort_desc = desc;
6374 server.sort_alpha = alpha;
6375 server.sort_bypattern = sortby ? 1 : 0;
5f5b9840 6376 if (sortby && (start != 0 || end != vectorlen-1))
6377 pqsort(vector,vectorlen,sizeof(redisSortObject),sortCompare, start,end);
6378 else
6379 qsort(vector,vectorlen,sizeof(redisSortObject),sortCompare);
ed9b544e 6380 }
6381
6382 /* Send command output to the output buffer, performing the specified
6383 * GET/DEL/INCR/DECR operations if any. */
6384 outputlen = getop ? getop*(end-start+1) : end-start+1;
443c6409 6385 if (storekey == NULL) {
6386 /* STORE option not specified, sent the sorting result to client */
6387 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen));
6388 for (j = start; j <= end; j++) {
6389 listNode *ln;
c7df85a4 6390 listIter li;
6391
dd88747b 6392 if (!getop) addReplyBulk(c,vector[j].obj);
c7df85a4 6393 listRewind(operations,&li);
6394 while((ln = listNext(&li))) {
443c6409 6395 redisSortOperation *sop = ln->value;
6396 robj *val = lookupKeyByPattern(c->db,sop->pattern,
6397 vector[j].obj);
6398
6399 if (sop->type == REDIS_SORT_GET) {
6400 if (!val || val->type != REDIS_STRING) {
6401 addReply(c,shared.nullbulk);
6402 } else {
dd88747b 6403 addReplyBulk(c,val);
443c6409 6404 }
6405 } else {
dfc5e96c 6406 redisAssert(sop->type == REDIS_SORT_GET); /* always fails */
443c6409 6407 }
6408 }
ed9b544e 6409 }
443c6409 6410 } else {
6411 robj *listObject = createListObject();
6412 list *listPtr = (list*) listObject->ptr;
6413
6414 /* STORE option specified, set the sorting result as a List object */
6415 for (j = start; j <= end; j++) {
6416 listNode *ln;
c7df85a4 6417 listIter li;
6418
443c6409 6419 if (!getop) {
6420 listAddNodeTail(listPtr,vector[j].obj);
6421 incrRefCount(vector[j].obj);
6422 }
c7df85a4 6423 listRewind(operations,&li);
6424 while((ln = listNext(&li))) {
443c6409 6425 redisSortOperation *sop = ln->value;
6426 robj *val = lookupKeyByPattern(c->db,sop->pattern,
6427 vector[j].obj);
6428
6429 if (sop->type == REDIS_SORT_GET) {
6430 if (!val || val->type != REDIS_STRING) {
6431 listAddNodeTail(listPtr,createStringObject("",0));
6432 } else {
6433 listAddNodeTail(listPtr,val);
6434 incrRefCount(val);
6435 }
ed9b544e 6436 } else {
dfc5e96c 6437 redisAssert(sop->type == REDIS_SORT_GET); /* always fails */
ed9b544e 6438 }
ed9b544e 6439 }
ed9b544e 6440 }
121796f7 6441 if (dictReplace(c->db->dict,storekey,listObject)) {
6442 incrRefCount(storekey);
6443 }
443c6409 6444 /* Note: we add 1 because the DB is dirty anyway since even if the
6445 * SORT result is empty a new key is set and maybe the old content
6446 * replaced. */
6447 server.dirty += 1+outputlen;
6448 addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",outputlen));
ed9b544e 6449 }
6450
6451 /* Cleanup */
6452 decrRefCount(sortval);
6453 listRelease(operations);
6454 for (j = 0; j < vectorlen; j++) {
6455 if (sortby && alpha && vector[j].u.cmpobj)
6456 decrRefCount(vector[j].u.cmpobj);
6457 }
6458 zfree(vector);
6459}
6460
ec6c7a1d 6461/* Convert an amount of bytes into a human readable string in the form
6462 * of 100B, 2G, 100M, 4K, and so forth. */
6463static void bytesToHuman(char *s, unsigned long long n) {
6464 double d;
6465
6466 if (n < 1024) {
6467 /* Bytes */
6468 sprintf(s,"%lluB",n);
6469 return;
6470 } else if (n < (1024*1024)) {
6471 d = (double)n/(1024);
6472 sprintf(s,"%.2fK",d);
6473 } else if (n < (1024LL*1024*1024)) {
6474 d = (double)n/(1024*1024);
6475 sprintf(s,"%.2fM",d);
6476 } else if (n < (1024LL*1024*1024*1024)) {
6477 d = (double)n/(1024LL*1024*1024);
b72f6a4b 6478 sprintf(s,"%.2fG",d);
ec6c7a1d 6479 }
6480}
6481
1c85b79f 6482/* Create the string returned by the INFO command. This is decoupled
6483 * by the INFO command itself as we need to report the same information
6484 * on memory corruption problems. */
6485static sds genRedisInfoString(void) {
ed9b544e 6486 sds info;
6487 time_t uptime = time(NULL)-server.stat_starttime;
c3cb078d 6488 int j;
ec6c7a1d 6489 char hmem[64];
55a8298f 6490
b72f6a4b 6491 bytesToHuman(hmem,zmalloc_used_memory());
ed9b544e 6492 info = sdscatprintf(sdsempty(),
6493 "redis_version:%s\r\n"
f1017b3f 6494 "arch_bits:%s\r\n"
7a932b74 6495 "multiplexing_api:%s\r\n"
0d7170a4 6496 "process_id:%ld\r\n"
682ac724 6497 "uptime_in_seconds:%ld\r\n"
6498 "uptime_in_days:%ld\r\n"
ed9b544e 6499 "connected_clients:%d\r\n"
6500 "connected_slaves:%d\r\n"
f86a74e9 6501 "blocked_clients:%d\r\n"
5fba9f71 6502 "used_memory:%zu\r\n"
ec6c7a1d 6503 "used_memory_human:%s\r\n"
ed9b544e 6504 "changes_since_last_save:%lld\r\n"
be2bb6b0 6505 "bgsave_in_progress:%d\r\n"
682ac724 6506 "last_save_time:%ld\r\n"
b3fad521 6507 "bgrewriteaof_in_progress:%d\r\n"
ed9b544e 6508 "total_connections_received:%lld\r\n"
6509 "total_commands_processed:%lld\r\n"
55a8298f 6510 "hash_max_zipmap_entries:%ld\r\n"
6511 "hash_max_zipmap_value:%ld\r\n"
7d98e08c 6512 "vm_enabled:%d\r\n"
a0f643ea 6513 "role:%s\r\n"
ed9b544e 6514 ,REDIS_VERSION,
f1017b3f 6515 (sizeof(long) == 8) ? "64" : "32",
7a932b74 6516 aeGetApiName(),
0d7170a4 6517 (long) getpid(),
a0f643ea 6518 uptime,
6519 uptime/(3600*24),
ed9b544e 6520 listLength(server.clients)-listLength(server.slaves),
6521 listLength(server.slaves),
d5d55fc3 6522 server.blpop_blocked_clients,
b72f6a4b 6523 zmalloc_used_memory(),
ec6c7a1d 6524 hmem,
ed9b544e 6525 server.dirty,
9d65a1bb 6526 server.bgsavechildpid != -1,
ed9b544e 6527 server.lastsave,
b3fad521 6528 server.bgrewritechildpid != -1,
ed9b544e 6529 server.stat_numconnections,
6530 server.stat_numcommands,
55a8298f 6531 server.hash_max_zipmap_entries,
6532 server.hash_max_zipmap_value,
7d98e08c 6533 server.vm_enabled != 0,
a0f643ea 6534 server.masterhost == NULL ? "master" : "slave"
ed9b544e 6535 );
a0f643ea 6536 if (server.masterhost) {
6537 info = sdscatprintf(info,
6538 "master_host:%s\r\n"
6539 "master_port:%d\r\n"
6540 "master_link_status:%s\r\n"
6541 "master_last_io_seconds_ago:%d\r\n"
6542 ,server.masterhost,
6543 server.masterport,
6544 (server.replstate == REDIS_REPL_CONNECTED) ?
6545 "up" : "down",
f72b934d 6546 server.master ? ((int)(time(NULL)-server.master->lastinteraction)) : -1
a0f643ea 6547 );
6548 }
7d98e08c 6549 if (server.vm_enabled) {
1064ef87 6550 lockThreadedIO();
7d98e08c 6551 info = sdscatprintf(info,
6552 "vm_conf_max_memory:%llu\r\n"
6553 "vm_conf_page_size:%llu\r\n"
6554 "vm_conf_pages:%llu\r\n"
6555 "vm_stats_used_pages:%llu\r\n"
6556 "vm_stats_swapped_objects:%llu\r\n"
6557 "vm_stats_swappin_count:%llu\r\n"
6558 "vm_stats_swappout_count:%llu\r\n"
b9bc0eef 6559 "vm_stats_io_newjobs_len:%lu\r\n"
6560 "vm_stats_io_processing_len:%lu\r\n"
6561 "vm_stats_io_processed_len:%lu\r\n"
25fd2cb2 6562 "vm_stats_io_active_threads:%lu\r\n"
d5d55fc3 6563 "vm_stats_blocked_clients:%lu\r\n"
7d98e08c 6564 ,(unsigned long long) server.vm_max_memory,
6565 (unsigned long long) server.vm_page_size,
6566 (unsigned long long) server.vm_pages,
6567 (unsigned long long) server.vm_stats_used_pages,
6568 (unsigned long long) server.vm_stats_swapped_objects,
6569 (unsigned long long) server.vm_stats_swapins,
b9bc0eef 6570 (unsigned long long) server.vm_stats_swapouts,
6571 (unsigned long) listLength(server.io_newjobs),
6572 (unsigned long) listLength(server.io_processing),
6573 (unsigned long) listLength(server.io_processed),
d5d55fc3 6574 (unsigned long) server.io_active_threads,
6575 (unsigned long) server.vm_blocked_clients
7d98e08c 6576 );
1064ef87 6577 unlockThreadedIO();
7d98e08c 6578 }
c3cb078d 6579 for (j = 0; j < server.dbnum; j++) {
6580 long long keys, vkeys;
6581
6582 keys = dictSize(server.db[j].dict);
6583 vkeys = dictSize(server.db[j].expires);
6584 if (keys || vkeys) {
9d65a1bb 6585 info = sdscatprintf(info, "db%d:keys=%lld,expires=%lld\r\n",
c3cb078d 6586 j, keys, vkeys);
6587 }
6588 }
1c85b79f 6589 return info;
6590}
6591
6592static void infoCommand(redisClient *c) {
6593 sds info = genRedisInfoString();
83c6a618 6594 addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
6595 (unsigned long)sdslen(info)));
ed9b544e 6596 addReplySds(c,info);
70003d28 6597 addReply(c,shared.crlf);
ed9b544e 6598}
6599
3305306f 6600static void monitorCommand(redisClient *c) {
6601 /* ignore MONITOR if aleady slave or in monitor mode */
6602 if (c->flags & REDIS_SLAVE) return;
6603
6604 c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
6605 c->slaveseldb = 0;
6b47e12e 6606 listAddNodeTail(server.monitors,c);
3305306f 6607 addReply(c,shared.ok);
6608}
6609
6610/* ================================= Expire ================================= */
6611static int removeExpire(redisDb *db, robj *key) {
6612 if (dictDelete(db->expires,key) == DICT_OK) {
6613 return 1;
6614 } else {
6615 return 0;
6616 }
6617}
6618
6619static int setExpire(redisDb *db, robj *key, time_t when) {
6620 if (dictAdd(db->expires,key,(void*)when) == DICT_ERR) {
6621 return 0;
6622 } else {
6623 incrRefCount(key);
6624 return 1;
6625 }
6626}
6627
bb32ede5 6628/* Return the expire time of the specified key, or -1 if no expire
6629 * is associated with this key (i.e. the key is non volatile) */
6630static time_t getExpire(redisDb *db, robj *key) {
6631 dictEntry *de;
6632
6633 /* No expire? return ASAP */
6634 if (dictSize(db->expires) == 0 ||
6635 (de = dictFind(db->expires,key)) == NULL) return -1;
6636
6637 return (time_t) dictGetEntryVal(de);
6638}
6639
3305306f 6640static int expireIfNeeded(redisDb *db, robj *key) {
6641 time_t when;
6642 dictEntry *de;
6643
6644 /* No expire? return ASAP */
6645 if (dictSize(db->expires) == 0 ||
6646 (de = dictFind(db->expires,key)) == NULL) return 0;
6647
6648 /* Lookup the expire */
6649 when = (time_t) dictGetEntryVal(de);
6650 if (time(NULL) <= when) return 0;
6651
6652 /* Delete the key */
6653 dictDelete(db->expires,key);
6654 return dictDelete(db->dict,key) == DICT_OK;
6655}
6656
6657static int deleteIfVolatile(redisDb *db, robj *key) {
6658 dictEntry *de;
6659
6660 /* No expire? return ASAP */
6661 if (dictSize(db->expires) == 0 ||
6662 (de = dictFind(db->expires,key)) == NULL) return 0;
6663
6664 /* Delete the key */
0c66a471 6665 server.dirty++;
3305306f 6666 dictDelete(db->expires,key);
6667 return dictDelete(db->dict,key) == DICT_OK;
6668}
6669
802e8373 6670static void expireGenericCommand(redisClient *c, robj *key, time_t seconds) {
3305306f 6671 dictEntry *de;
3305306f 6672
802e8373 6673 de = dictFind(c->db->dict,key);
3305306f 6674 if (de == NULL) {
6675 addReply(c,shared.czero);
6676 return;
6677 }
43e5ccdf 6678 if (seconds < 0) {
6679 if (deleteKey(c->db,key)) server.dirty++;
6680 addReply(c, shared.cone);
3305306f 6681 return;
6682 } else {
6683 time_t when = time(NULL)+seconds;
802e8373 6684 if (setExpire(c->db,key,when)) {
3305306f 6685 addReply(c,shared.cone);
77423026 6686 server.dirty++;
6687 } else {
3305306f 6688 addReply(c,shared.czero);
77423026 6689 }
3305306f 6690 return;
6691 }
6692}
6693
802e8373 6694static void expireCommand(redisClient *c) {
6695 expireGenericCommand(c,c->argv[1],strtol(c->argv[2]->ptr,NULL,10));
6696}
6697
6698static void expireatCommand(redisClient *c) {
6699 expireGenericCommand(c,c->argv[1],strtol(c->argv[2]->ptr,NULL,10)-time(NULL));
6700}
6701
fd88489a 6702static void ttlCommand(redisClient *c) {
6703 time_t expire;
6704 int ttl = -1;
6705
6706 expire = getExpire(c->db,c->argv[1]);
6707 if (expire != -1) {
6708 ttl = (int) (expire-time(NULL));
6709 if (ttl < 0) ttl = -1;
6710 }
6711 addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",ttl));
6712}
6713
6e469882 6714/* ================================ MULTI/EXEC ============================== */
6715
6716/* Client state initialization for MULTI/EXEC */
6717static void initClientMultiState(redisClient *c) {
6718 c->mstate.commands = NULL;
6719 c->mstate.count = 0;
6720}
6721
6722/* Release all the resources associated with MULTI/EXEC state */
6723static void freeClientMultiState(redisClient *c) {
6724 int j;
6725
6726 for (j = 0; j < c->mstate.count; j++) {
6727 int i;
6728 multiCmd *mc = c->mstate.commands+j;
6729
6730 for (i = 0; i < mc->argc; i++)
6731 decrRefCount(mc->argv[i]);
6732 zfree(mc->argv);
6733 }
6734 zfree(c->mstate.commands);
6735}
6736
6737/* Add a new command into the MULTI commands queue */
6738static void queueMultiCommand(redisClient *c, struct redisCommand *cmd) {
6739 multiCmd *mc;
6740 int j;
6741
6742 c->mstate.commands = zrealloc(c->mstate.commands,
6743 sizeof(multiCmd)*(c->mstate.count+1));
6744 mc = c->mstate.commands+c->mstate.count;
6745 mc->cmd = cmd;
6746 mc->argc = c->argc;
6747 mc->argv = zmalloc(sizeof(robj*)*c->argc);
6748 memcpy(mc->argv,c->argv,sizeof(robj*)*c->argc);
6749 for (j = 0; j < c->argc; j++)
6750 incrRefCount(mc->argv[j]);
6751 c->mstate.count++;
6752}
6753
6754static void multiCommand(redisClient *c) {
6755 c->flags |= REDIS_MULTI;
36c548f0 6756 addReply(c,shared.ok);
6e469882 6757}
6758
18b6cb76
DJ
6759static void discardCommand(redisClient *c) {
6760 if (!(c->flags & REDIS_MULTI)) {
6761 addReplySds(c,sdsnew("-ERR DISCARD without MULTI\r\n"));
6762 return;
6763 }
6764
6765 freeClientMultiState(c);
6766 initClientMultiState(c);
6767 c->flags &= (~REDIS_MULTI);
6768 addReply(c,shared.ok);
6769}
6770
6e469882 6771static void execCommand(redisClient *c) {
6772 int j;
6773 robj **orig_argv;
6774 int orig_argc;
6775
6776 if (!(c->flags & REDIS_MULTI)) {
6777 addReplySds(c,sdsnew("-ERR EXEC without MULTI\r\n"));
6778 return;
6779 }
6780
6781 orig_argv = c->argv;
6782 orig_argc = c->argc;
6783 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->mstate.count));
6784 for (j = 0; j < c->mstate.count; j++) {
6785 c->argc = c->mstate.commands[j].argc;
6786 c->argv = c->mstate.commands[j].argv;
6787 call(c,c->mstate.commands[j].cmd);
6788 }
6789 c->argv = orig_argv;
6790 c->argc = orig_argc;
6791 freeClientMultiState(c);
6792 initClientMultiState(c);
6793 c->flags &= (~REDIS_MULTI);
6794}
6795
4409877e 6796/* =========================== Blocking Operations ========================= */
6797
6798/* Currently Redis blocking operations support is limited to list POP ops,
6799 * so the current implementation is not fully generic, but it is also not
6800 * completely specific so it will not require a rewrite to support new
6801 * kind of blocking operations in the future.
6802 *
6803 * Still it's important to note that list blocking operations can be already
6804 * used as a notification mechanism in order to implement other blocking
6805 * operations at application level, so there must be a very strong evidence
6806 * of usefulness and generality before new blocking operations are implemented.
6807 *
6808 * This is how the current blocking POP works, we use BLPOP as example:
6809 * - If the user calls BLPOP and the key exists and contains a non empty list
6810 * then LPOP is called instead. So BLPOP is semantically the same as LPOP
6811 * if there is not to block.
6812 * - If instead BLPOP is called and the key does not exists or the list is
6813 * empty we need to block. In order to do so we remove the notification for
6814 * new data to read in the client socket (so that we'll not serve new
6815 * requests if the blocking request is not served). Also we put the client
95242ab5 6816 * in a dictionary (db->blockingkeys) mapping keys to a list of clients
4409877e 6817 * blocking for this keys.
6818 * - If a PUSH operation against a key with blocked clients waiting is
6819 * performed, we serve the first in the list: basically instead to push
6820 * the new element inside the list we return it to the (first / oldest)
6821 * blocking client, unblock the client, and remove it form the list.
6822 *
6823 * The above comment and the source code should be enough in order to understand
6824 * the implementation and modify / fix it later.
6825 */
6826
6827/* Set a client in blocking mode for the specified key, with the specified
6828 * timeout */
b177fd30 6829static void blockForKeys(redisClient *c, robj **keys, int numkeys, time_t timeout) {
4409877e 6830 dictEntry *de;
6831 list *l;
b177fd30 6832 int j;
4409877e 6833
b177fd30 6834 c->blockingkeys = zmalloc(sizeof(robj*)*numkeys);
6835 c->blockingkeysnum = numkeys;
4409877e 6836 c->blockingto = timeout;
b177fd30 6837 for (j = 0; j < numkeys; j++) {
6838 /* Add the key in the client structure, to map clients -> keys */
6839 c->blockingkeys[j] = keys[j];
6840 incrRefCount(keys[j]);
4409877e 6841
b177fd30 6842 /* And in the other "side", to map keys -> clients */
6843 de = dictFind(c->db->blockingkeys,keys[j]);
6844 if (de == NULL) {
6845 int retval;
6846
6847 /* For every key we take a list of clients blocked for it */
6848 l = listCreate();
6849 retval = dictAdd(c->db->blockingkeys,keys[j],l);
6850 incrRefCount(keys[j]);
6851 assert(retval == DICT_OK);
6852 } else {
6853 l = dictGetEntryVal(de);
6854 }
6855 listAddNodeTail(l,c);
4409877e 6856 }
b177fd30 6857 /* Mark the client as a blocked client */
4409877e 6858 c->flags |= REDIS_BLOCKED;
d5d55fc3 6859 server.blpop_blocked_clients++;
4409877e 6860}
6861
6862/* Unblock a client that's waiting in a blocking operation such as BLPOP */
b0d8747d 6863static void unblockClientWaitingData(redisClient *c) {
4409877e 6864 dictEntry *de;
6865 list *l;
b177fd30 6866 int j;
4409877e 6867
b177fd30 6868 assert(c->blockingkeys != NULL);
6869 /* The client may wait for multiple keys, so unblock it for every key. */
6870 for (j = 0; j < c->blockingkeysnum; j++) {
6871 /* Remove this client from the list of clients waiting for this key. */
6872 de = dictFind(c->db->blockingkeys,c->blockingkeys[j]);
6873 assert(de != NULL);
6874 l = dictGetEntryVal(de);
6875 listDelNode(l,listSearchKey(l,c));
6876 /* If the list is empty we need to remove it to avoid wasting memory */
6877 if (listLength(l) == 0)
6878 dictDelete(c->db->blockingkeys,c->blockingkeys[j]);
6879 decrRefCount(c->blockingkeys[j]);
6880 }
6881 /* Cleanup the client structure */
6882 zfree(c->blockingkeys);
6883 c->blockingkeys = NULL;
4409877e 6884 c->flags &= (~REDIS_BLOCKED);
d5d55fc3 6885 server.blpop_blocked_clients--;
5921aa36 6886 /* We want to process data if there is some command waiting
b0d8747d 6887 * in the input buffer. Note that this is safe even if
6888 * unblockClientWaitingData() gets called from freeClient() because
6889 * freeClient() will be smart enough to call this function
6890 * *after* c->querybuf was set to NULL. */
4409877e 6891 if (c->querybuf && sdslen(c->querybuf) > 0) processInputBuffer(c);
6892}
6893
6894/* This should be called from any function PUSHing into lists.
6895 * 'c' is the "pushing client", 'key' is the key it is pushing data against,
6896 * 'ele' is the element pushed.
6897 *
6898 * If the function returns 0 there was no client waiting for a list push
6899 * against this key.
6900 *
6901 * If the function returns 1 there was a client waiting for a list push
6902 * against this key, the element was passed to this client thus it's not
6903 * needed to actually add it to the list and the caller should return asap. */
6904static int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele) {
6905 struct dictEntry *de;
6906 redisClient *receiver;
6907 list *l;
6908 listNode *ln;
6909
6910 de = dictFind(c->db->blockingkeys,key);
6911 if (de == NULL) return 0;
6912 l = dictGetEntryVal(de);
6913 ln = listFirst(l);
6914 assert(ln != NULL);
6915 receiver = ln->value;
4409877e 6916
b177fd30 6917 addReplySds(receiver,sdsnew("*2\r\n"));
dd88747b 6918 addReplyBulk(receiver,key);
6919 addReplyBulk(receiver,ele);
b0d8747d 6920 unblockClientWaitingData(receiver);
4409877e 6921 return 1;
6922}
6923
6924/* Blocking RPOP/LPOP */
6925static void blockingPopGenericCommand(redisClient *c, int where) {
6926 robj *o;
6927 time_t timeout;
b177fd30 6928 int j;
4409877e 6929
b177fd30 6930 for (j = 1; j < c->argc-1; j++) {
6931 o = lookupKeyWrite(c->db,c->argv[j]);
6932 if (o != NULL) {
6933 if (o->type != REDIS_LIST) {
6934 addReply(c,shared.wrongtypeerr);
4409877e 6935 return;
b177fd30 6936 } else {
6937 list *list = o->ptr;
6938 if (listLength(list) != 0) {
6939 /* If the list contains elements fall back to the usual
6940 * non-blocking POP operation */
6941 robj *argv[2], **orig_argv;
6942 int orig_argc;
6943
6944 /* We need to alter the command arguments before to call
6945 * popGenericCommand() as the command takes a single key. */
6946 orig_argv = c->argv;
6947 orig_argc = c->argc;
6948 argv[1] = c->argv[j];
6949 c->argv = argv;
6950 c->argc = 2;
6951
6952 /* Also the return value is different, we need to output
6953 * the multi bulk reply header and the key name. The
6954 * "real" command will add the last element (the value)
6955 * for us. If this souds like an hack to you it's just
6956 * because it is... */
6957 addReplySds(c,sdsnew("*2\r\n"));
dd88747b 6958 addReplyBulk(c,argv[1]);
b177fd30 6959 popGenericCommand(c,where);
6960
6961 /* Fix the client structure with the original stuff */
6962 c->argv = orig_argv;
6963 c->argc = orig_argc;
6964 return;
6965 }
4409877e 6966 }
6967 }
6968 }
6969 /* If the list is empty or the key does not exists we must block */
b177fd30 6970 timeout = strtol(c->argv[c->argc-1]->ptr,NULL,10);
4409877e 6971 if (timeout > 0) timeout += time(NULL);
b177fd30 6972 blockForKeys(c,c->argv+1,c->argc-2,timeout);
4409877e 6973}
6974
6975static void blpopCommand(redisClient *c) {
6976 blockingPopGenericCommand(c,REDIS_HEAD);
6977}
6978
6979static void brpopCommand(redisClient *c) {
6980 blockingPopGenericCommand(c,REDIS_TAIL);
6981}
6982
ed9b544e 6983/* =============================== Replication ============================= */
6984
a4d1ba9a 6985static int syncWrite(int fd, char *ptr, ssize_t size, int timeout) {
ed9b544e 6986 ssize_t nwritten, ret = size;
6987 time_t start = time(NULL);
6988
6989 timeout++;
6990 while(size) {
6991 if (aeWait(fd,AE_WRITABLE,1000) & AE_WRITABLE) {
6992 nwritten = write(fd,ptr,size);
6993 if (nwritten == -1) return -1;
6994 ptr += nwritten;
6995 size -= nwritten;
6996 }
6997 if ((time(NULL)-start) > timeout) {
6998 errno = ETIMEDOUT;
6999 return -1;
7000 }
7001 }
7002 return ret;
7003}
7004
a4d1ba9a 7005static int syncRead(int fd, char *ptr, ssize_t size, int timeout) {
ed9b544e 7006 ssize_t nread, totread = 0;
7007 time_t start = time(NULL);
7008
7009 timeout++;
7010 while(size) {
7011 if (aeWait(fd,AE_READABLE,1000) & AE_READABLE) {
7012 nread = read(fd,ptr,size);
7013 if (nread == -1) return -1;
7014 ptr += nread;
7015 size -= nread;
7016 totread += nread;
7017 }
7018 if ((time(NULL)-start) > timeout) {
7019 errno = ETIMEDOUT;
7020 return -1;
7021 }
7022 }
7023 return totread;
7024}
7025
7026static int syncReadLine(int fd, char *ptr, ssize_t size, int timeout) {
7027 ssize_t nread = 0;
7028
7029 size--;
7030 while(size) {
7031 char c;
7032
7033 if (syncRead(fd,&c,1,timeout) == -1) return -1;
7034 if (c == '\n') {
7035 *ptr = '\0';
7036 if (nread && *(ptr-1) == '\r') *(ptr-1) = '\0';
7037 return nread;
7038 } else {
7039 *ptr++ = c;
7040 *ptr = '\0';
7041 nread++;
7042 }
7043 }
7044 return nread;
7045}
7046
7047static void syncCommand(redisClient *c) {
40d224a9 7048 /* ignore SYNC if aleady slave or in monitor mode */
7049 if (c->flags & REDIS_SLAVE) return;
7050
7051 /* SYNC can't be issued when the server has pending data to send to
7052 * the client about already issued commands. We need a fresh reply
7053 * buffer registering the differences between the BGSAVE and the current
7054 * dataset, so that we can copy to other slaves if needed. */
7055 if (listLength(c->reply) != 0) {
7056 addReplySds(c,sdsnew("-ERR SYNC is invalid with pending input\r\n"));
7057 return;
7058 }
7059
7060 redisLog(REDIS_NOTICE,"Slave ask for synchronization");
7061 /* Here we need to check if there is a background saving operation
7062 * in progress, or if it is required to start one */
9d65a1bb 7063 if (server.bgsavechildpid != -1) {
40d224a9 7064 /* Ok a background save is in progress. Let's check if it is a good
7065 * one for replication, i.e. if there is another slave that is
7066 * registering differences since the server forked to save */
7067 redisClient *slave;
7068 listNode *ln;
c7df85a4 7069 listIter li;
40d224a9 7070
c7df85a4 7071 listRewind(server.slaves,&li);
7072 while((ln = listNext(&li))) {
40d224a9 7073 slave = ln->value;
7074 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_END) break;
40d224a9 7075 }
7076 if (ln) {
7077 /* Perfect, the server is already registering differences for
7078 * another slave. Set the right state, and copy the buffer. */
7079 listRelease(c->reply);
7080 c->reply = listDup(slave->reply);
40d224a9 7081 c->replstate = REDIS_REPL_WAIT_BGSAVE_END;
7082 redisLog(REDIS_NOTICE,"Waiting for end of BGSAVE for SYNC");
7083 } else {
7084 /* No way, we need to wait for the next BGSAVE in order to
7085 * register differences */
7086 c->replstate = REDIS_REPL_WAIT_BGSAVE_START;
7087 redisLog(REDIS_NOTICE,"Waiting for next BGSAVE for SYNC");
7088 }
7089 } else {
7090 /* Ok we don't have a BGSAVE in progress, let's start one */
7091 redisLog(REDIS_NOTICE,"Starting BGSAVE for SYNC");
7092 if (rdbSaveBackground(server.dbfilename) != REDIS_OK) {
7093 redisLog(REDIS_NOTICE,"Replication failed, can't BGSAVE");
7094 addReplySds(c,sdsnew("-ERR Unalbe to perform background save\r\n"));
7095 return;
7096 }
7097 c->replstate = REDIS_REPL_WAIT_BGSAVE_END;
7098 }
6208b3a7 7099 c->repldbfd = -1;
40d224a9 7100 c->flags |= REDIS_SLAVE;
7101 c->slaveseldb = 0;
6b47e12e 7102 listAddNodeTail(server.slaves,c);
40d224a9 7103 return;
7104}
7105
6208b3a7 7106static void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
7107 redisClient *slave = privdata;
7108 REDIS_NOTUSED(el);
7109 REDIS_NOTUSED(mask);
7110 char buf[REDIS_IOBUF_LEN];
7111 ssize_t nwritten, buflen;
7112
7113 if (slave->repldboff == 0) {
7114 /* Write the bulk write count before to transfer the DB. In theory here
7115 * we don't know how much room there is in the output buffer of the
7116 * socket, but in pratice SO_SNDLOWAT (the minimum count for output
7117 * operations) will never be smaller than the few bytes we need. */
7118 sds bulkcount;
7119
7120 bulkcount = sdscatprintf(sdsempty(),"$%lld\r\n",(unsigned long long)
7121 slave->repldbsize);
7122 if (write(fd,bulkcount,sdslen(bulkcount)) != (signed)sdslen(bulkcount))
7123 {
7124 sdsfree(bulkcount);
7125 freeClient(slave);
7126 return;
7127 }
7128 sdsfree(bulkcount);
7129 }
7130 lseek(slave->repldbfd,slave->repldboff,SEEK_SET);
7131 buflen = read(slave->repldbfd,buf,REDIS_IOBUF_LEN);
7132 if (buflen <= 0) {
7133 redisLog(REDIS_WARNING,"Read error sending DB to slave: %s",
7134 (buflen == 0) ? "premature EOF" : strerror(errno));
7135 freeClient(slave);
7136 return;
7137 }
7138 if ((nwritten = write(fd,buf,buflen)) == -1) {
f870935d 7139 redisLog(REDIS_VERBOSE,"Write error sending DB to slave: %s",
6208b3a7 7140 strerror(errno));
7141 freeClient(slave);
7142 return;
7143 }
7144 slave->repldboff += nwritten;
7145 if (slave->repldboff == slave->repldbsize) {
7146 close(slave->repldbfd);
7147 slave->repldbfd = -1;
7148 aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
7149 slave->replstate = REDIS_REPL_ONLINE;
7150 if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE,
266373b2 7151 sendReplyToClient, slave) == AE_ERR) {
6208b3a7 7152 freeClient(slave);
7153 return;
7154 }
7155 addReplySds(slave,sdsempty());
7156 redisLog(REDIS_NOTICE,"Synchronization with slave succeeded");
7157 }
7158}
ed9b544e 7159
a3b21203 7160/* This function is called at the end of every backgrond saving.
7161 * The argument bgsaveerr is REDIS_OK if the background saving succeeded
7162 * otherwise REDIS_ERR is passed to the function.
7163 *
7164 * The goal of this function is to handle slaves waiting for a successful
7165 * background saving in order to perform non-blocking synchronization. */
7166static void updateSlavesWaitingBgsave(int bgsaveerr) {
6208b3a7 7167 listNode *ln;
7168 int startbgsave = 0;
c7df85a4 7169 listIter li;
ed9b544e 7170
c7df85a4 7171 listRewind(server.slaves,&li);
7172 while((ln = listNext(&li))) {
6208b3a7 7173 redisClient *slave = ln->value;
ed9b544e 7174
6208b3a7 7175 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START) {
7176 startbgsave = 1;
7177 slave->replstate = REDIS_REPL_WAIT_BGSAVE_END;
7178 } else if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_END) {
dde65f3f 7179 struct redis_stat buf;
6208b3a7 7180
7181 if (bgsaveerr != REDIS_OK) {
7182 freeClient(slave);
7183 redisLog(REDIS_WARNING,"SYNC failed. BGSAVE child returned an error");
7184 continue;
7185 }
7186 if ((slave->repldbfd = open(server.dbfilename,O_RDONLY)) == -1 ||
dde65f3f 7187 redis_fstat(slave->repldbfd,&buf) == -1) {
6208b3a7 7188 freeClient(slave);
7189 redisLog(REDIS_WARNING,"SYNC failed. Can't open/stat DB after BGSAVE: %s", strerror(errno));
7190 continue;
7191 }
7192 slave->repldboff = 0;
7193 slave->repldbsize = buf.st_size;
7194 slave->replstate = REDIS_REPL_SEND_BULK;
7195 aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
266373b2 7196 if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, sendBulkToSlave, slave) == AE_ERR) {
6208b3a7 7197 freeClient(slave);
7198 continue;
7199 }
7200 }
ed9b544e 7201 }
6208b3a7 7202 if (startbgsave) {
7203 if (rdbSaveBackground(server.dbfilename) != REDIS_OK) {
c7df85a4 7204 listIter li;
7205
7206 listRewind(server.slaves,&li);
6208b3a7 7207 redisLog(REDIS_WARNING,"SYNC failed. BGSAVE failed");
c7df85a4 7208 while((ln = listNext(&li))) {
6208b3a7 7209 redisClient *slave = ln->value;
ed9b544e 7210
6208b3a7 7211 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START)
7212 freeClient(slave);
7213 }
7214 }
7215 }
ed9b544e 7216}
7217
7218static int syncWithMaster(void) {
d0ccebcf 7219 char buf[1024], tmpfile[256], authcmd[1024];
18e61fa2 7220 long dumpsize;
ed9b544e 7221 int fd = anetTcpConnect(NULL,server.masterhost,server.masterport);
8c5abee8 7222 int dfd, maxtries = 5;
ed9b544e 7223
7224 if (fd == -1) {
7225 redisLog(REDIS_WARNING,"Unable to connect to MASTER: %s",
7226 strerror(errno));
7227 return REDIS_ERR;
7228 }
d0ccebcf 7229
7230 /* AUTH with the master if required. */
7231 if(server.masterauth) {
7232 snprintf(authcmd, 1024, "AUTH %s\r\n", server.masterauth);
7233 if (syncWrite(fd, authcmd, strlen(server.masterauth)+7, 5) == -1) {
7234 close(fd);
7235 redisLog(REDIS_WARNING,"Unable to AUTH to MASTER: %s",
7236 strerror(errno));
7237 return REDIS_ERR;
7238 }
7239 /* Read the AUTH result. */
7240 if (syncReadLine(fd,buf,1024,3600) == -1) {
7241 close(fd);
7242 redisLog(REDIS_WARNING,"I/O error reading auth result from MASTER: %s",
7243 strerror(errno));
7244 return REDIS_ERR;
7245 }
7246 if (buf[0] != '+') {
7247 close(fd);
7248 redisLog(REDIS_WARNING,"Cannot AUTH to MASTER, is the masterauth password correct?");
7249 return REDIS_ERR;
7250 }
7251 }
7252
ed9b544e 7253 /* Issue the SYNC command */
7254 if (syncWrite(fd,"SYNC \r\n",7,5) == -1) {
7255 close(fd);
7256 redisLog(REDIS_WARNING,"I/O error writing to MASTER: %s",
7257 strerror(errno));
7258 return REDIS_ERR;
7259 }
7260 /* Read the bulk write count */
8c4d91fc 7261 if (syncReadLine(fd,buf,1024,3600) == -1) {
ed9b544e 7262 close(fd);
7263 redisLog(REDIS_WARNING,"I/O error reading bulk count from MASTER: %s",
7264 strerror(errno));
7265 return REDIS_ERR;
7266 }
4aa701c1 7267 if (buf[0] != '$') {
7268 close(fd);
7269 redisLog(REDIS_WARNING,"Bad protocol from MASTER, the first byte is not '$', are you sure the host and port are right?");
7270 return REDIS_ERR;
7271 }
18e61fa2 7272 dumpsize = strtol(buf+1,NULL,10);
7273 redisLog(REDIS_NOTICE,"Receiving %ld bytes data dump from MASTER",dumpsize);
ed9b544e 7274 /* Read the bulk write data on a temp file */
8c5abee8 7275 while(maxtries--) {
7276 snprintf(tmpfile,256,
7277 "temp-%d.%ld.rdb",(int)time(NULL),(long int)getpid());
7278 dfd = open(tmpfile,O_CREAT|O_WRONLY|O_EXCL,0644);
7279 if (dfd != -1) break;
5de9ad7c 7280 sleep(1);
8c5abee8 7281 }
ed9b544e 7282 if (dfd == -1) {
7283 close(fd);
7284 redisLog(REDIS_WARNING,"Opening the temp file needed for MASTER <-> SLAVE synchronization: %s",strerror(errno));
7285 return REDIS_ERR;
7286 }
7287 while(dumpsize) {
7288 int nread, nwritten;
7289
7290 nread = read(fd,buf,(dumpsize < 1024)?dumpsize:1024);
7291 if (nread == -1) {
7292 redisLog(REDIS_WARNING,"I/O error trying to sync with MASTER: %s",
7293 strerror(errno));
7294 close(fd);
7295 close(dfd);
7296 return REDIS_ERR;
7297 }
7298 nwritten = write(dfd,buf,nread);
7299 if (nwritten == -1) {
7300 redisLog(REDIS_WARNING,"Write error writing to the DB dump file needed for MASTER <-> SLAVE synchrnonization: %s", strerror(errno));
7301 close(fd);
7302 close(dfd);
7303 return REDIS_ERR;
7304 }
7305 dumpsize -= nread;
7306 }
7307 close(dfd);
7308 if (rename(tmpfile,server.dbfilename) == -1) {
7309 redisLog(REDIS_WARNING,"Failed trying to rename the temp DB into dump.rdb in MASTER <-> SLAVE synchronization: %s", strerror(errno));
7310 unlink(tmpfile);
7311 close(fd);
7312 return REDIS_ERR;
7313 }
7314 emptyDb();
f78fd11b 7315 if (rdbLoad(server.dbfilename) != REDIS_OK) {
ed9b544e 7316 redisLog(REDIS_WARNING,"Failed trying to load the MASTER synchronization DB from disk");
7317 close(fd);
7318 return REDIS_ERR;
7319 }
7320 server.master = createClient(fd);
7321 server.master->flags |= REDIS_MASTER;
179b3952 7322 server.master->authenticated = 1;
ed9b544e 7323 server.replstate = REDIS_REPL_CONNECTED;
7324 return REDIS_OK;
7325}
7326
321b0e13 7327static void slaveofCommand(redisClient *c) {
7328 if (!strcasecmp(c->argv[1]->ptr,"no") &&
7329 !strcasecmp(c->argv[2]->ptr,"one")) {
7330 if (server.masterhost) {
7331 sdsfree(server.masterhost);
7332 server.masterhost = NULL;
7333 if (server.master) freeClient(server.master);
7334 server.replstate = REDIS_REPL_NONE;
7335 redisLog(REDIS_NOTICE,"MASTER MODE enabled (user request)");
7336 }
7337 } else {
7338 sdsfree(server.masterhost);
7339 server.masterhost = sdsdup(c->argv[1]->ptr);
7340 server.masterport = atoi(c->argv[2]->ptr);
7341 if (server.master) freeClient(server.master);
7342 server.replstate = REDIS_REPL_CONNECT;
7343 redisLog(REDIS_NOTICE,"SLAVE OF %s:%d enabled (user request)",
7344 server.masterhost, server.masterport);
7345 }
7346 addReply(c,shared.ok);
7347}
7348
3fd78bcd 7349/* ============================ Maxmemory directive ======================== */
7350
a5819310 7351/* Try to free one object form the pre-allocated objects free list.
7352 * This is useful under low mem conditions as by default we take 1 million
7353 * free objects allocated. On success REDIS_OK is returned, otherwise
7354 * REDIS_ERR. */
7355static int tryFreeOneObjectFromFreelist(void) {
f870935d 7356 robj *o;
7357
a5819310 7358 if (server.vm_enabled) pthread_mutex_lock(&server.obj_freelist_mutex);
7359 if (listLength(server.objfreelist)) {
7360 listNode *head = listFirst(server.objfreelist);
7361 o = listNodeValue(head);
7362 listDelNode(server.objfreelist,head);
7363 if (server.vm_enabled) pthread_mutex_unlock(&server.obj_freelist_mutex);
7364 zfree(o);
7365 return REDIS_OK;
7366 } else {
7367 if (server.vm_enabled) pthread_mutex_unlock(&server.obj_freelist_mutex);
7368 return REDIS_ERR;
7369 }
f870935d 7370}
7371
3fd78bcd 7372/* This function gets called when 'maxmemory' is set on the config file to limit
7373 * the max memory used by the server, and we are out of memory.
7374 * This function will try to, in order:
7375 *
7376 * - Free objects from the free list
7377 * - Try to remove keys with an EXPIRE set
7378 *
7379 * It is not possible to free enough memory to reach used-memory < maxmemory
7380 * the server will start refusing commands that will enlarge even more the
7381 * memory usage.
7382 */
7383static void freeMemoryIfNeeded(void) {
7384 while (server.maxmemory && zmalloc_used_memory() > server.maxmemory) {
a5819310 7385 int j, k, freed = 0;
7386
7387 if (tryFreeOneObjectFromFreelist() == REDIS_OK) continue;
7388 for (j = 0; j < server.dbnum; j++) {
7389 int minttl = -1;
7390 robj *minkey = NULL;
7391 struct dictEntry *de;
7392
7393 if (dictSize(server.db[j].expires)) {
7394 freed = 1;
7395 /* From a sample of three keys drop the one nearest to
7396 * the natural expire */
7397 for (k = 0; k < 3; k++) {
7398 time_t t;
7399
7400 de = dictGetRandomKey(server.db[j].expires);
7401 t = (time_t) dictGetEntryVal(de);
7402 if (minttl == -1 || t < minttl) {
7403 minkey = dictGetEntryKey(de);
7404 minttl = t;
3fd78bcd 7405 }
3fd78bcd 7406 }
a5819310 7407 deleteKey(server.db+j,minkey);
3fd78bcd 7408 }
3fd78bcd 7409 }
a5819310 7410 if (!freed) return; /* nothing to free... */
3fd78bcd 7411 }
7412}
7413
f80dff62 7414/* ============================== Append Only file ========================== */
7415
7416static void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) {
7417 sds buf = sdsempty();
7418 int j;
7419 ssize_t nwritten;
7420 time_t now;
7421 robj *tmpargv[3];
7422
7423 /* The DB this command was targetting is not the same as the last command
7424 * we appendend. To issue a SELECT command is needed. */
7425 if (dictid != server.appendseldb) {
7426 char seldb[64];
7427
7428 snprintf(seldb,sizeof(seldb),"%d",dictid);
682ac724 7429 buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n",
83c6a618 7430 (unsigned long)strlen(seldb),seldb);
f80dff62 7431 server.appendseldb = dictid;
7432 }
7433
7434 /* "Fix" the argv vector if the command is EXPIRE. We want to translate
7435 * EXPIREs into EXPIREATs calls */
7436 if (cmd->proc == expireCommand) {
7437 long when;
7438
7439 tmpargv[0] = createStringObject("EXPIREAT",8);
7440 tmpargv[1] = argv[1];
7441 incrRefCount(argv[1]);
7442 when = time(NULL)+strtol(argv[2]->ptr,NULL,10);
7443 tmpargv[2] = createObject(REDIS_STRING,
7444 sdscatprintf(sdsempty(),"%ld",when));
7445 argv = tmpargv;
7446 }
7447
7448 /* Append the actual command */
7449 buf = sdscatprintf(buf,"*%d\r\n",argc);
7450 for (j = 0; j < argc; j++) {
7451 robj *o = argv[j];
7452
9d65a1bb 7453 o = getDecodedObject(o);
83c6a618 7454 buf = sdscatprintf(buf,"$%lu\r\n",(unsigned long)sdslen(o->ptr));
f80dff62 7455 buf = sdscatlen(buf,o->ptr,sdslen(o->ptr));
7456 buf = sdscatlen(buf,"\r\n",2);
9d65a1bb 7457 decrRefCount(o);
f80dff62 7458 }
7459
7460 /* Free the objects from the modified argv for EXPIREAT */
7461 if (cmd->proc == expireCommand) {
7462 for (j = 0; j < 3; j++)
7463 decrRefCount(argv[j]);
7464 }
7465
7466 /* We want to perform a single write. This should be guaranteed atomic
7467 * at least if the filesystem we are writing is a real physical one.
7468 * While this will save us against the server being killed I don't think
7469 * there is much to do about the whole server stopping for power problems
7470 * or alike */
7471 nwritten = write(server.appendfd,buf,sdslen(buf));
7472 if (nwritten != (signed)sdslen(buf)) {
7473 /* Ooops, we are in troubles. The best thing to do for now is
7474 * to simply exit instead to give the illusion that everything is
7475 * working as expected. */
7476 if (nwritten == -1) {
7477 redisLog(REDIS_WARNING,"Exiting on error writing to the append-only file: %s",strerror(errno));
7478 } else {
7479 redisLog(REDIS_WARNING,"Exiting on short write while writing to the append-only file: %s",strerror(errno));
7480 }
7481 exit(1);
7482 }
85a83172 7483 /* If a background append only file rewriting is in progress we want to
7484 * accumulate the differences between the child DB and the current one
7485 * in a buffer, so that when the child process will do its work we
7486 * can append the differences to the new append only file. */
7487 if (server.bgrewritechildpid != -1)
7488 server.bgrewritebuf = sdscatlen(server.bgrewritebuf,buf,sdslen(buf));
7489
7490 sdsfree(buf);
f80dff62 7491 now = time(NULL);
7492 if (server.appendfsync == APPENDFSYNC_ALWAYS ||
7493 (server.appendfsync == APPENDFSYNC_EVERYSEC &&
7494 now-server.lastfsync > 1))
7495 {
7496 fsync(server.appendfd); /* Let's try to get this data on the disk */
7497 server.lastfsync = now;
7498 }
7499}
7500
7501/* In Redis commands are always executed in the context of a client, so in
7502 * order to load the append only file we need to create a fake client. */
7503static struct redisClient *createFakeClient(void) {
7504 struct redisClient *c = zmalloc(sizeof(*c));
7505
7506 selectDb(c,0);
7507 c->fd = -1;
7508 c->querybuf = sdsempty();
7509 c->argc = 0;
7510 c->argv = NULL;
7511 c->flags = 0;
9387d17d 7512 /* We set the fake client as a slave waiting for the synchronization
7513 * so that Redis will not try to send replies to this client. */
7514 c->replstate = REDIS_REPL_WAIT_BGSAVE_START;
f80dff62 7515 c->reply = listCreate();
7516 listSetFreeMethod(c->reply,decrRefCount);
7517 listSetDupMethod(c->reply,dupClientReplyValue);
7518 return c;
7519}
7520
7521static void freeFakeClient(struct redisClient *c) {
7522 sdsfree(c->querybuf);
7523 listRelease(c->reply);
7524 zfree(c);
7525}
7526
7527/* Replay the append log file. On error REDIS_OK is returned. On non fatal
7528 * error (the append only file is zero-length) REDIS_ERR is returned. On
7529 * fatal error an error message is logged and the program exists. */
7530int loadAppendOnlyFile(char *filename) {
7531 struct redisClient *fakeClient;
7532 FILE *fp = fopen(filename,"r");
7533 struct redis_stat sb;
b492cf00 7534 unsigned long long loadedkeys = 0;
f80dff62 7535
7536 if (redis_fstat(fileno(fp),&sb) != -1 && sb.st_size == 0)
7537 return REDIS_ERR;
7538
7539 if (fp == NULL) {
7540 redisLog(REDIS_WARNING,"Fatal error: can't open the append log file for reading: %s",strerror(errno));
7541 exit(1);
7542 }
7543
7544 fakeClient = createFakeClient();
7545 while(1) {
7546 int argc, j;
7547 unsigned long len;
7548 robj **argv;
7549 char buf[128];
7550 sds argsds;
7551 struct redisCommand *cmd;
7552
7553 if (fgets(buf,sizeof(buf),fp) == NULL) {
7554 if (feof(fp))
7555 break;
7556 else
7557 goto readerr;
7558 }
7559 if (buf[0] != '*') goto fmterr;
7560 argc = atoi(buf+1);
7561 argv = zmalloc(sizeof(robj*)*argc);
7562 for (j = 0; j < argc; j++) {
7563 if (fgets(buf,sizeof(buf),fp) == NULL) goto readerr;
7564 if (buf[0] != '$') goto fmterr;
7565 len = strtol(buf+1,NULL,10);
7566 argsds = sdsnewlen(NULL,len);
0f151ef1 7567 if (len && fread(argsds,len,1,fp) == 0) goto fmterr;
f80dff62 7568 argv[j] = createObject(REDIS_STRING,argsds);
7569 if (fread(buf,2,1,fp) == 0) goto fmterr; /* discard CRLF */
7570 }
7571
7572 /* Command lookup */
7573 cmd = lookupCommand(argv[0]->ptr);
7574 if (!cmd) {
7575 redisLog(REDIS_WARNING,"Unknown command '%s' reading the append only file", argv[0]->ptr);
7576 exit(1);
7577 }
7578 /* Try object sharing and encoding */
7579 if (server.shareobjects) {
7580 int j;
7581 for(j = 1; j < argc; j++)
7582 argv[j] = tryObjectSharing(argv[j]);
7583 }
7584 if (cmd->flags & REDIS_CMD_BULK)
7585 tryObjectEncoding(argv[argc-1]);
7586 /* Run the command in the context of a fake client */
7587 fakeClient->argc = argc;
7588 fakeClient->argv = argv;
7589 cmd->proc(fakeClient);
7590 /* Discard the reply objects list from the fake client */
7591 while(listLength(fakeClient->reply))
7592 listDelNode(fakeClient->reply,listFirst(fakeClient->reply));
7593 /* Clean up, ready for the next command */
7594 for (j = 0; j < argc; j++) decrRefCount(argv[j]);
7595 zfree(argv);
b492cf00 7596 /* Handle swapping while loading big datasets when VM is on */
7597 loadedkeys++;
7598 if (server.vm_enabled && (loadedkeys % 5000) == 0) {
7599 while (zmalloc_used_memory() > server.vm_max_memory) {
a69a0c9c 7600 if (vmSwapOneObjectBlocking() == REDIS_ERR) break;
b492cf00 7601 }
7602 }
f80dff62 7603 }
7604 fclose(fp);
7605 freeFakeClient(fakeClient);
7606 return REDIS_OK;
7607
7608readerr:
7609 if (feof(fp)) {
7610 redisLog(REDIS_WARNING,"Unexpected end of file reading the append only file");
7611 } else {
7612 redisLog(REDIS_WARNING,"Unrecoverable error reading the append only file: %s", strerror(errno));
7613 }
7614 exit(1);
7615fmterr:
7616 redisLog(REDIS_WARNING,"Bad file format reading the append only file");
7617 exit(1);
7618}
7619
9d65a1bb 7620/* Write an object into a file in the bulk format $<count>\r\n<payload>\r\n */
9c8e3cee 7621static int fwriteBulkObject(FILE *fp, robj *obj) {
9d65a1bb 7622 char buf[128];
b9bc0eef 7623 int decrrc = 0;
7624
f2d9f50f 7625 /* Avoid the incr/decr ref count business if possible to help
7626 * copy-on-write (we are often in a child process when this function
7627 * is called).
7628 * Also makes sure that key objects don't get incrRefCount-ed when VM
7629 * is enabled */
7630 if (obj->encoding != REDIS_ENCODING_RAW) {
b9bc0eef 7631 obj = getDecodedObject(obj);
7632 decrrc = 1;
7633 }
9d65a1bb 7634 snprintf(buf,sizeof(buf),"$%ld\r\n",(long)sdslen(obj->ptr));
7635 if (fwrite(buf,strlen(buf),1,fp) == 0) goto err;
e96e4fbf 7636 if (sdslen(obj->ptr) && fwrite(obj->ptr,sdslen(obj->ptr),1,fp) == 0)
7637 goto err;
9d65a1bb 7638 if (fwrite("\r\n",2,1,fp) == 0) goto err;
b9bc0eef 7639 if (decrrc) decrRefCount(obj);
9d65a1bb 7640 return 1;
7641err:
b9bc0eef 7642 if (decrrc) decrRefCount(obj);
9d65a1bb 7643 return 0;
7644}
7645
9c8e3cee 7646/* Write binary-safe string into a file in the bulkformat
7647 * $<count>\r\n<payload>\r\n */
7648static int fwriteBulkString(FILE *fp, char *s, unsigned long len) {
7649 char buf[128];
7650
7651 snprintf(buf,sizeof(buf),"$%ld\r\n",(unsigned long)len);
7652 if (fwrite(buf,strlen(buf),1,fp) == 0) return 0;
7653 if (len && fwrite(s,len,1,fp) == 0) return 0;
7654 if (fwrite("\r\n",2,1,fp) == 0) return 0;
7655 return 1;
7656}
7657
9d65a1bb 7658/* Write a double value in bulk format $<count>\r\n<payload>\r\n */
7659static int fwriteBulkDouble(FILE *fp, double d) {
7660 char buf[128], dbuf[128];
7661
7662 snprintf(dbuf,sizeof(dbuf),"%.17g\r\n",d);
7663 snprintf(buf,sizeof(buf),"$%lu\r\n",(unsigned long)strlen(dbuf)-2);
7664 if (fwrite(buf,strlen(buf),1,fp) == 0) return 0;
7665 if (fwrite(dbuf,strlen(dbuf),1,fp) == 0) return 0;
7666 return 1;
7667}
7668
7669/* Write a long value in bulk format $<count>\r\n<payload>\r\n */
7670static int fwriteBulkLong(FILE *fp, long l) {
7671 char buf[128], lbuf[128];
7672
7673 snprintf(lbuf,sizeof(lbuf),"%ld\r\n",l);
7674 snprintf(buf,sizeof(buf),"$%lu\r\n",(unsigned long)strlen(lbuf)-2);
7675 if (fwrite(buf,strlen(buf),1,fp) == 0) return 0;
7676 if (fwrite(lbuf,strlen(lbuf),1,fp) == 0) return 0;
7677 return 1;
7678}
7679
7680/* Write a sequence of commands able to fully rebuild the dataset into
7681 * "filename". Used both by REWRITEAOF and BGREWRITEAOF. */
7682static int rewriteAppendOnlyFile(char *filename) {
7683 dictIterator *di = NULL;
7684 dictEntry *de;
7685 FILE *fp;
7686 char tmpfile[256];
7687 int j;
7688 time_t now = time(NULL);
7689
7690 /* Note that we have to use a different temp name here compared to the
7691 * one used by rewriteAppendOnlyFileBackground() function. */
7692 snprintf(tmpfile,256,"temp-rewriteaof-%d.aof", (int) getpid());
7693 fp = fopen(tmpfile,"w");
7694 if (!fp) {
7695 redisLog(REDIS_WARNING, "Failed rewriting the append only file: %s", strerror(errno));
7696 return REDIS_ERR;
7697 }
7698 for (j = 0; j < server.dbnum; j++) {
7699 char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n";
7700 redisDb *db = server.db+j;
7701 dict *d = db->dict;
7702 if (dictSize(d) == 0) continue;
7703 di = dictGetIterator(d);
7704 if (!di) {
7705 fclose(fp);
7706 return REDIS_ERR;
7707 }
7708
7709 /* SELECT the new DB */
7710 if (fwrite(selectcmd,sizeof(selectcmd)-1,1,fp) == 0) goto werr;
85a83172 7711 if (fwriteBulkLong(fp,j) == 0) goto werr;
9d65a1bb 7712
7713 /* Iterate this DB writing every entry */
7714 while((de = dictNext(di)) != NULL) {
e7546c63 7715 robj *key, *o;
7716 time_t expiretime;
7717 int swapped;
7718
7719 key = dictGetEntryKey(de);
b9bc0eef 7720 /* If the value for this key is swapped, load a preview in memory.
7721 * We use a "swapped" flag to remember if we need to free the
7722 * value object instead to just increment the ref count anyway
7723 * in order to avoid copy-on-write of pages if we are forked() */
996cb5f7 7724 if (!server.vm_enabled || key->storage == REDIS_VM_MEMORY ||
7725 key->storage == REDIS_VM_SWAPPING) {
e7546c63 7726 o = dictGetEntryVal(de);
7727 swapped = 0;
7728 } else {
7729 o = vmPreviewObject(key);
e7546c63 7730 swapped = 1;
7731 }
7732 expiretime = getExpire(db,key);
9d65a1bb 7733
7734 /* Save the key and associated value */
9d65a1bb 7735 if (o->type == REDIS_STRING) {
7736 /* Emit a SET command */
7737 char cmd[]="*3\r\n$3\r\nSET\r\n";
7738 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
7739 /* Key and value */
9c8e3cee 7740 if (fwriteBulkObject(fp,key) == 0) goto werr;
7741 if (fwriteBulkObject(fp,o) == 0) goto werr;
9d65a1bb 7742 } else if (o->type == REDIS_LIST) {
7743 /* Emit the RPUSHes needed to rebuild the list */
7744 list *list = o->ptr;
7745 listNode *ln;
c7df85a4 7746 listIter li;
9d65a1bb 7747
c7df85a4 7748 listRewind(list,&li);
7749 while((ln = listNext(&li))) {
9d65a1bb 7750 char cmd[]="*3\r\n$5\r\nRPUSH\r\n";
7751 robj *eleobj = listNodeValue(ln);
7752
7753 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
9c8e3cee 7754 if (fwriteBulkObject(fp,key) == 0) goto werr;
7755 if (fwriteBulkObject(fp,eleobj) == 0) goto werr;
9d65a1bb 7756 }
7757 } else if (o->type == REDIS_SET) {
7758 /* Emit the SADDs needed to rebuild the set */
7759 dict *set = o->ptr;
7760 dictIterator *di = dictGetIterator(set);
7761 dictEntry *de;
7762
7763 while((de = dictNext(di)) != NULL) {
7764 char cmd[]="*3\r\n$4\r\nSADD\r\n";
7765 robj *eleobj = dictGetEntryKey(de);
7766
7767 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
9c8e3cee 7768 if (fwriteBulkObject(fp,key) == 0) goto werr;
7769 if (fwriteBulkObject(fp,eleobj) == 0) goto werr;
9d65a1bb 7770 }
7771 dictReleaseIterator(di);
7772 } else if (o->type == REDIS_ZSET) {
7773 /* Emit the ZADDs needed to rebuild the sorted set */
7774 zset *zs = o->ptr;
7775 dictIterator *di = dictGetIterator(zs->dict);
7776 dictEntry *de;
7777
7778 while((de = dictNext(di)) != NULL) {
7779 char cmd[]="*4\r\n$4\r\nZADD\r\n";
7780 robj *eleobj = dictGetEntryKey(de);
7781 double *score = dictGetEntryVal(de);
7782
7783 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
9c8e3cee 7784 if (fwriteBulkObject(fp,key) == 0) goto werr;
9d65a1bb 7785 if (fwriteBulkDouble(fp,*score) == 0) goto werr;
9c8e3cee 7786 if (fwriteBulkObject(fp,eleobj) == 0) goto werr;
9d65a1bb 7787 }
7788 dictReleaseIterator(di);
9c8e3cee 7789 } else if (o->type == REDIS_HASH) {
7790 char cmd[]="*4\r\n$4\r\nHSET\r\n";
7791
7792 /* Emit the HSETs needed to rebuild the hash */
7793 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
7794 unsigned char *p = zipmapRewind(o->ptr);
7795 unsigned char *field, *val;
7796 unsigned int flen, vlen;
7797
7798 while((p = zipmapNext(p,&field,&flen,&val,&vlen)) != NULL) {
7799 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
7800 if (fwriteBulkObject(fp,key) == 0) goto werr;
7801 if (fwriteBulkString(fp,(char*)field,flen) == -1)
7802 return -1;
7803 if (fwriteBulkString(fp,(char*)val,vlen) == -1)
7804 return -1;
7805 }
7806 } else {
7807 dictIterator *di = dictGetIterator(o->ptr);
7808 dictEntry *de;
7809
7810 while((de = dictNext(di)) != NULL) {
7811 robj *field = dictGetEntryKey(de);
7812 robj *val = dictGetEntryVal(de);
7813
7814 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
7815 if (fwriteBulkObject(fp,key) == 0) goto werr;
7816 if (fwriteBulkObject(fp,field) == -1) return -1;
7817 if (fwriteBulkObject(fp,val) == -1) return -1;
7818 }
7819 dictReleaseIterator(di);
7820 }
9d65a1bb 7821 } else {
78409a0f 7822 redisAssert(0);
9d65a1bb 7823 }
7824 /* Save the expire time */
7825 if (expiretime != -1) {
e96e4fbf 7826 char cmd[]="*3\r\n$8\r\nEXPIREAT\r\n";
9d65a1bb 7827 /* If this key is already expired skip it */
7828 if (expiretime < now) continue;
7829 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
9c8e3cee 7830 if (fwriteBulkObject(fp,key) == 0) goto werr;
9d65a1bb 7831 if (fwriteBulkLong(fp,expiretime) == 0) goto werr;
7832 }
b9bc0eef 7833 if (swapped) decrRefCount(o);
9d65a1bb 7834 }
7835 dictReleaseIterator(di);
7836 }
7837
7838 /* Make sure data will not remain on the OS's output buffers */
7839 fflush(fp);
7840 fsync(fileno(fp));
7841 fclose(fp);
7842
7843 /* Use RENAME to make sure the DB file is changed atomically only
7844 * if the generate DB file is ok. */
7845 if (rename(tmpfile,filename) == -1) {
7846 redisLog(REDIS_WARNING,"Error moving temp append only file on the final destination: %s", strerror(errno));
7847 unlink(tmpfile);
7848 return REDIS_ERR;
7849 }
7850 redisLog(REDIS_NOTICE,"SYNC append only file rewrite performed");
7851 return REDIS_OK;
7852
7853werr:
7854 fclose(fp);
7855 unlink(tmpfile);
e96e4fbf 7856 redisLog(REDIS_WARNING,"Write error writing append only file on disk: %s", strerror(errno));
9d65a1bb 7857 if (di) dictReleaseIterator(di);
7858 return REDIS_ERR;
7859}
7860
7861/* This is how rewriting of the append only file in background works:
7862 *
7863 * 1) The user calls BGREWRITEAOF
7864 * 2) Redis calls this function, that forks():
7865 * 2a) the child rewrite the append only file in a temp file.
7866 * 2b) the parent accumulates differences in server.bgrewritebuf.
7867 * 3) When the child finished '2a' exists.
7868 * 4) The parent will trap the exit code, if it's OK, will append the
7869 * data accumulated into server.bgrewritebuf into the temp file, and
7870 * finally will rename(2) the temp file in the actual file name.
7871 * The the new file is reopened as the new append only file. Profit!
7872 */
7873static int rewriteAppendOnlyFileBackground(void) {
7874 pid_t childpid;
7875
7876 if (server.bgrewritechildpid != -1) return REDIS_ERR;
054e426d 7877 if (server.vm_enabled) waitEmptyIOJobsQueue();
9d65a1bb 7878 if ((childpid = fork()) == 0) {
7879 /* Child */
7880 char tmpfile[256];
9d65a1bb 7881
054e426d 7882 if (server.vm_enabled) vmReopenSwapFile();
7883 close(server.fd);
9d65a1bb 7884 snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) getpid());
7885 if (rewriteAppendOnlyFile(tmpfile) == REDIS_OK) {
478c2c6f 7886 _exit(0);
9d65a1bb 7887 } else {
478c2c6f 7888 _exit(1);
9d65a1bb 7889 }
7890 } else {
7891 /* Parent */
7892 if (childpid == -1) {
7893 redisLog(REDIS_WARNING,
7894 "Can't rewrite append only file in background: fork: %s",
7895 strerror(errno));
7896 return REDIS_ERR;
7897 }
7898 redisLog(REDIS_NOTICE,
7899 "Background append only file rewriting started by pid %d",childpid);
7900 server.bgrewritechildpid = childpid;
85a83172 7901 /* We set appendseldb to -1 in order to force the next call to the
7902 * feedAppendOnlyFile() to issue a SELECT command, so the differences
7903 * accumulated by the parent into server.bgrewritebuf will start
7904 * with a SELECT statement and it will be safe to merge. */
7905 server.appendseldb = -1;
9d65a1bb 7906 return REDIS_OK;
7907 }
7908 return REDIS_OK; /* unreached */
7909}
7910
7911static void bgrewriteaofCommand(redisClient *c) {
7912 if (server.bgrewritechildpid != -1) {
7913 addReplySds(c,sdsnew("-ERR background append only file rewriting already in progress\r\n"));
7914 return;
7915 }
7916 if (rewriteAppendOnlyFileBackground() == REDIS_OK) {
49b99ab4 7917 char *status = "+Background append only file rewriting started\r\n";
7918 addReplySds(c,sdsnew(status));
9d65a1bb 7919 } else {
7920 addReply(c,shared.err);
7921 }
7922}
7923
7924static void aofRemoveTempFile(pid_t childpid) {
7925 char tmpfile[256];
7926
7927 snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) childpid);
7928 unlink(tmpfile);
7929}
7930
996cb5f7 7931/* Virtual Memory is composed mainly of two subsystems:
7932 * - Blocking Virutal Memory
7933 * - Threaded Virtual Memory I/O
7934 * The two parts are not fully decoupled, but functions are split among two
7935 * different sections of the source code (delimited by comments) in order to
7936 * make more clear what functionality is about the blocking VM and what about
7937 * the threaded (not blocking) VM.
7938 *
7939 * Redis VM design:
7940 *
7941 * Redis VM is a blocking VM (one that blocks reading swapped values from
7942 * disk into memory when a value swapped out is needed in memory) that is made
7943 * unblocking by trying to examine the command argument vector in order to
7944 * load in background values that will likely be needed in order to exec
7945 * the command. The command is executed only once all the relevant keys
7946 * are loaded into memory.
7947 *
7948 * This basically is almost as simple of a blocking VM, but almost as parallel
7949 * as a fully non-blocking VM.
7950 */
7951
7952/* =================== Virtual Memory - Blocking Side ====================== */
054e426d 7953
7954/* substitute the first occurrence of '%p' with the process pid in the
7955 * swap file name. */
7956static void expandVmSwapFilename(void) {
7957 char *p = strstr(server.vm_swap_file,"%p");
7958 sds new;
7959
7960 if (!p) return;
7961 new = sdsempty();
7962 *p = '\0';
7963 new = sdscat(new,server.vm_swap_file);
7964 new = sdscatprintf(new,"%ld",(long) getpid());
7965 new = sdscat(new,p+2);
7966 zfree(server.vm_swap_file);
7967 server.vm_swap_file = new;
7968}
7969
75680a3c 7970static void vmInit(void) {
7971 off_t totsize;
996cb5f7 7972 int pipefds[2];
bcaa7a4f 7973 size_t stacksize;
75680a3c 7974
4ad37480 7975 if (server.vm_max_threads != 0)
7976 zmalloc_enable_thread_safeness(); /* we need thread safe zmalloc() */
7977
054e426d 7978 expandVmSwapFilename();
7979 redisLog(REDIS_NOTICE,"Using '%s' as swap file",server.vm_swap_file);
6fa987e3 7980 if ((server.vm_fp = fopen(server.vm_swap_file,"r+b")) == NULL) {
7981 server.vm_fp = fopen(server.vm_swap_file,"w+b");
7982 }
75680a3c 7983 if (server.vm_fp == NULL) {
6fa987e3 7984 redisLog(REDIS_WARNING,
7985 "Impossible to open the swap file: %s. Exiting.",
7986 strerror(errno));
75680a3c 7987 exit(1);
7988 }
7989 server.vm_fd = fileno(server.vm_fp);
7990 server.vm_next_page = 0;
7991 server.vm_near_pages = 0;
7d98e08c 7992 server.vm_stats_used_pages = 0;
7993 server.vm_stats_swapped_objects = 0;
7994 server.vm_stats_swapouts = 0;
7995 server.vm_stats_swapins = 0;
75680a3c 7996 totsize = server.vm_pages*server.vm_page_size;
7997 redisLog(REDIS_NOTICE,"Allocating %lld bytes of swap file",totsize);
7998 if (ftruncate(server.vm_fd,totsize) == -1) {
7999 redisLog(REDIS_WARNING,"Can't ftruncate swap file: %s. Exiting.",
8000 strerror(errno));
8001 exit(1);
8002 } else {
8003 redisLog(REDIS_NOTICE,"Swap file allocated with success");
8004 }
7d30035d 8005 server.vm_bitmap = zmalloc((server.vm_pages+7)/8);
f870935d 8006 redisLog(REDIS_VERBOSE,"Allocated %lld bytes page table for %lld pages",
4ef8de8a 8007 (long long) (server.vm_pages+7)/8, server.vm_pages);
7d30035d 8008 memset(server.vm_bitmap,0,(server.vm_pages+7)/8);
92f8e882 8009
996cb5f7 8010 /* Initialize threaded I/O (used by Virtual Memory) */
8011 server.io_newjobs = listCreate();
8012 server.io_processing = listCreate();
8013 server.io_processed = listCreate();
d5d55fc3 8014 server.io_ready_clients = listCreate();
92f8e882 8015 pthread_mutex_init(&server.io_mutex,NULL);
a5819310 8016 pthread_mutex_init(&server.obj_freelist_mutex,NULL);
8017 pthread_mutex_init(&server.io_swapfile_mutex,NULL);
92f8e882 8018 server.io_active_threads = 0;
996cb5f7 8019 if (pipe(pipefds) == -1) {
8020 redisLog(REDIS_WARNING,"Unable to intialized VM: pipe(2): %s. Exiting."
8021 ,strerror(errno));
8022 exit(1);
8023 }
8024 server.io_ready_pipe_read = pipefds[0];
8025 server.io_ready_pipe_write = pipefds[1];
8026 redisAssert(anetNonBlock(NULL,server.io_ready_pipe_read) != ANET_ERR);
bcaa7a4f 8027 /* LZF requires a lot of stack */
8028 pthread_attr_init(&server.io_threads_attr);
8029 pthread_attr_getstacksize(&server.io_threads_attr, &stacksize);
8030 while (stacksize < REDIS_THREAD_STACK_SIZE) stacksize *= 2;
8031 pthread_attr_setstacksize(&server.io_threads_attr, stacksize);
b9bc0eef 8032 /* Listen for events in the threaded I/O pipe */
8033 if (aeCreateFileEvent(server.el, server.io_ready_pipe_read, AE_READABLE,
8034 vmThreadedIOCompletedJob, NULL) == AE_ERR)
8035 oom("creating file event");
75680a3c 8036}
8037
06224fec 8038/* Mark the page as used */
8039static void vmMarkPageUsed(off_t page) {
8040 off_t byte = page/8;
8041 int bit = page&7;
970e10bb 8042 redisAssert(vmFreePage(page) == 1);
06224fec 8043 server.vm_bitmap[byte] |= 1<<bit;
8044}
8045
8046/* Mark N contiguous pages as used, with 'page' being the first. */
8047static void vmMarkPagesUsed(off_t page, off_t count) {
8048 off_t j;
8049
8050 for (j = 0; j < count; j++)
7d30035d 8051 vmMarkPageUsed(page+j);
7d98e08c 8052 server.vm_stats_used_pages += count;
7c775e09 8053 redisLog(REDIS_DEBUG,"Mark USED pages: %lld pages at %lld\n",
8054 (long long)count, (long long)page);
06224fec 8055}
8056
8057/* Mark the page as free */
8058static void vmMarkPageFree(off_t page) {
8059 off_t byte = page/8;
8060 int bit = page&7;
970e10bb 8061 redisAssert(vmFreePage(page) == 0);
06224fec 8062 server.vm_bitmap[byte] &= ~(1<<bit);
8063}
8064
8065/* Mark N contiguous pages as free, with 'page' being the first. */
8066static void vmMarkPagesFree(off_t page, off_t count) {
8067 off_t j;
8068
8069 for (j = 0; j < count; j++)
7d30035d 8070 vmMarkPageFree(page+j);
7d98e08c 8071 server.vm_stats_used_pages -= count;
7c775e09 8072 redisLog(REDIS_DEBUG,"Mark FREE pages: %lld pages at %lld\n",
8073 (long long)count, (long long)page);
06224fec 8074}
8075
8076/* Test if the page is free */
8077static int vmFreePage(off_t page) {
8078 off_t byte = page/8;
8079 int bit = page&7;
7d30035d 8080 return (server.vm_bitmap[byte] & (1<<bit)) == 0;
06224fec 8081}
8082
8083/* Find N contiguous free pages storing the first page of the cluster in *first.
3a66edc7 8084 * Returns REDIS_OK if it was able to find N contiguous pages, otherwise
8085 * REDIS_ERR is returned.
06224fec 8086 *
8087 * This function uses a simple algorithm: we try to allocate
8088 * REDIS_VM_MAX_NEAR_PAGES sequentially, when we reach this limit we start
8089 * again from the start of the swap file searching for free spaces.
8090 *
8091 * If it looks pretty clear that there are no free pages near our offset
8092 * we try to find less populated places doing a forward jump of
8093 * REDIS_VM_MAX_RANDOM_JUMP, then we start scanning again a few pages
8094 * without hurry, and then we jump again and so forth...
8095 *
8096 * This function can be improved using a free list to avoid to guess
8097 * too much, since we could collect data about freed pages.
8098 *
8099 * note: I implemented this function just after watching an episode of
8100 * Battlestar Galactica, where the hybrid was continuing to say "JUMP!"
8101 */
c7df85a4 8102static int vmFindContiguousPages(off_t *first, off_t n) {
06224fec 8103 off_t base, offset = 0, since_jump = 0, numfree = 0;
8104
8105 if (server.vm_near_pages == REDIS_VM_MAX_NEAR_PAGES) {
8106 server.vm_near_pages = 0;
8107 server.vm_next_page = 0;
8108 }
8109 server.vm_near_pages++; /* Yet another try for pages near to the old ones */
8110 base = server.vm_next_page;
8111
8112 while(offset < server.vm_pages) {
8113 off_t this = base+offset;
8114
8115 /* If we overflow, restart from page zero */
8116 if (this >= server.vm_pages) {
8117 this -= server.vm_pages;
8118 if (this == 0) {
8119 /* Just overflowed, what we found on tail is no longer
8120 * interesting, as it's no longer contiguous. */
8121 numfree = 0;
8122 }
8123 }
8124 if (vmFreePage(this)) {
8125 /* This is a free page */
8126 numfree++;
8127 /* Already got N free pages? Return to the caller, with success */
8128 if (numfree == n) {
7d30035d 8129 *first = this-(n-1);
8130 server.vm_next_page = this+1;
7c775e09 8131 redisLog(REDIS_DEBUG, "FOUND CONTIGUOUS PAGES: %lld pages at %lld\n", (long long) n, (long long) *first);
3a66edc7 8132 return REDIS_OK;
06224fec 8133 }
8134 } else {
8135 /* The current one is not a free page */
8136 numfree = 0;
8137 }
8138
8139 /* Fast-forward if the current page is not free and we already
8140 * searched enough near this place. */
8141 since_jump++;
8142 if (!numfree && since_jump >= REDIS_VM_MAX_RANDOM_JUMP/4) {
8143 offset += random() % REDIS_VM_MAX_RANDOM_JUMP;
8144 since_jump = 0;
8145 /* Note that even if we rewind after the jump, we are don't need
8146 * to make sure numfree is set to zero as we only jump *if* it
8147 * is set to zero. */
8148 } else {
8149 /* Otherwise just check the next page */
8150 offset++;
8151 }
8152 }
3a66edc7 8153 return REDIS_ERR;
8154}
8155
a5819310 8156/* Write the specified object at the specified page of the swap file */
8157static int vmWriteObjectOnSwap(robj *o, off_t page) {
8158 if (server.vm_enabled) pthread_mutex_lock(&server.io_swapfile_mutex);
8159 if (fseeko(server.vm_fp,page*server.vm_page_size,SEEK_SET) == -1) {
8160 if (server.vm_enabled) pthread_mutex_unlock(&server.io_swapfile_mutex);
8161 redisLog(REDIS_WARNING,
9ebed7cf 8162 "Critical VM problem in vmWriteObjectOnSwap(): can't seek: %s",
a5819310 8163 strerror(errno));
8164 return REDIS_ERR;
8165 }
8166 rdbSaveObject(server.vm_fp,o);
ba76a8f9 8167 fflush(server.vm_fp);
a5819310 8168 if (server.vm_enabled) pthread_mutex_unlock(&server.io_swapfile_mutex);
8169 return REDIS_OK;
8170}
8171
3a66edc7 8172/* Swap the 'val' object relative to 'key' into disk. Store all the information
8173 * needed to later retrieve the object into the key object.
8174 * If we can't find enough contiguous empty pages to swap the object on disk
8175 * REDIS_ERR is returned. */
a69a0c9c 8176static int vmSwapObjectBlocking(robj *key, robj *val) {
b9bc0eef 8177 off_t pages = rdbSavedObjectPages(val,NULL);
3a66edc7 8178 off_t page;
8179
8180 assert(key->storage == REDIS_VM_MEMORY);
4ef8de8a 8181 assert(key->refcount == 1);
3a66edc7 8182 if (vmFindContiguousPages(&page,pages) == REDIS_ERR) return REDIS_ERR;
a5819310 8183 if (vmWriteObjectOnSwap(val,page) == REDIS_ERR) return REDIS_ERR;
3a66edc7 8184 key->vm.page = page;
8185 key->vm.usedpages = pages;
8186 key->storage = REDIS_VM_SWAPPED;
d894161b 8187 key->vtype = val->type;
3a66edc7 8188 decrRefCount(val); /* Deallocate the object from memory. */
8189 vmMarkPagesUsed(page,pages);
7d30035d 8190 redisLog(REDIS_DEBUG,"VM: object %s swapped out at %lld (%lld pages)",
8191 (unsigned char*) key->ptr,
8192 (unsigned long long) page, (unsigned long long) pages);
7d98e08c 8193 server.vm_stats_swapped_objects++;
8194 server.vm_stats_swapouts++;
3a66edc7 8195 return REDIS_OK;
8196}
8197
a5819310 8198static robj *vmReadObjectFromSwap(off_t page, int type) {
8199 robj *o;
3a66edc7 8200
a5819310 8201 if (server.vm_enabled) pthread_mutex_lock(&server.io_swapfile_mutex);
8202 if (fseeko(server.vm_fp,page*server.vm_page_size,SEEK_SET) == -1) {
3a66edc7 8203 redisLog(REDIS_WARNING,
d5d55fc3 8204 "Unrecoverable VM problem in vmReadObjectFromSwap(): can't seek: %s",
3a66edc7 8205 strerror(errno));
478c2c6f 8206 _exit(1);
3a66edc7 8207 }
a5819310 8208 o = rdbLoadObject(type,server.vm_fp);
8209 if (o == NULL) {
d5d55fc3 8210 redisLog(REDIS_WARNING, "Unrecoverable VM problem in vmReadObjectFromSwap(): can't load object from swap file: %s", strerror(errno));
478c2c6f 8211 _exit(1);
3a66edc7 8212 }
a5819310 8213 if (server.vm_enabled) pthread_mutex_unlock(&server.io_swapfile_mutex);
8214 return o;
8215}
8216
8217/* Load the value object relative to the 'key' object from swap to memory.
8218 * The newly allocated object is returned.
8219 *
8220 * If preview is true the unserialized object is returned to the caller but
8221 * no changes are made to the key object, nor the pages are marked as freed */
8222static robj *vmGenericLoadObject(robj *key, int preview) {
8223 robj *val;
8224
d5d55fc3 8225 redisAssert(key->storage == REDIS_VM_SWAPPED || key->storage == REDIS_VM_LOADING);
a5819310 8226 val = vmReadObjectFromSwap(key->vm.page,key->vtype);
7e69548d 8227 if (!preview) {
8228 key->storage = REDIS_VM_MEMORY;
8229 key->vm.atime = server.unixtime;
8230 vmMarkPagesFree(key->vm.page,key->vm.usedpages);
8231 redisLog(REDIS_DEBUG, "VM: object %s loaded from disk",
8232 (unsigned char*) key->ptr);
7d98e08c 8233 server.vm_stats_swapped_objects--;
38aba9a1 8234 } else {
8235 redisLog(REDIS_DEBUG, "VM: object %s previewed from disk",
8236 (unsigned char*) key->ptr);
7e69548d 8237 }
7d98e08c 8238 server.vm_stats_swapins++;
3a66edc7 8239 return val;
06224fec 8240}
8241
7e69548d 8242/* Plain object loading, from swap to memory */
8243static robj *vmLoadObject(robj *key) {
996cb5f7 8244 /* If we are loading the object in background, stop it, we
8245 * need to load this object synchronously ASAP. */
8246 if (key->storage == REDIS_VM_LOADING)
8247 vmCancelThreadedIOJob(key);
7e69548d 8248 return vmGenericLoadObject(key,0);
8249}
8250
8251/* Just load the value on disk, without to modify the key.
8252 * This is useful when we want to perform some operation on the value
8253 * without to really bring it from swap to memory, like while saving the
8254 * dataset or rewriting the append only log. */
8255static robj *vmPreviewObject(robj *key) {
8256 return vmGenericLoadObject(key,1);
8257}
8258
4ef8de8a 8259/* How a good candidate is this object for swapping?
8260 * The better candidate it is, the greater the returned value.
8261 *
8262 * Currently we try to perform a fast estimation of the object size in
8263 * memory, and combine it with aging informations.
8264 *
8265 * Basically swappability = idle-time * log(estimated size)
8266 *
8267 * Bigger objects are preferred over smaller objects, but not
8268 * proportionally, this is why we use the logarithm. This algorithm is
8269 * just a first try and will probably be tuned later. */
8270static double computeObjectSwappability(robj *o) {
8271 time_t age = server.unixtime - o->vm.atime;
8272 long asize = 0;
8273 list *l;
8274 dict *d;
8275 struct dictEntry *de;
8276 int z;
8277
8278 if (age <= 0) return 0;
8279 switch(o->type) {
8280 case REDIS_STRING:
8281 if (o->encoding != REDIS_ENCODING_RAW) {
8282 asize = sizeof(*o);
8283 } else {
8284 asize = sdslen(o->ptr)+sizeof(*o)+sizeof(long)*2;
8285 }
8286 break;
8287 case REDIS_LIST:
8288 l = o->ptr;
8289 listNode *ln = listFirst(l);
8290
8291 asize = sizeof(list);
8292 if (ln) {
8293 robj *ele = ln->value;
8294 long elesize;
8295
8296 elesize = (ele->encoding == REDIS_ENCODING_RAW) ?
8297 (sizeof(*o)+sdslen(ele->ptr)) :
8298 sizeof(*o);
8299 asize += (sizeof(listNode)+elesize)*listLength(l);
8300 }
8301 break;
8302 case REDIS_SET:
8303 case REDIS_ZSET:
8304 z = (o->type == REDIS_ZSET);
8305 d = z ? ((zset*)o->ptr)->dict : o->ptr;
8306
8307 asize = sizeof(dict)+(sizeof(struct dictEntry*)*dictSlots(d));
8308 if (z) asize += sizeof(zset)-sizeof(dict);
8309 if (dictSize(d)) {
8310 long elesize;
8311 robj *ele;
8312
8313 de = dictGetRandomKey(d);
8314 ele = dictGetEntryKey(de);
8315 elesize = (ele->encoding == REDIS_ENCODING_RAW) ?
8316 (sizeof(*o)+sdslen(ele->ptr)) :
8317 sizeof(*o);
8318 asize += (sizeof(struct dictEntry)+elesize)*dictSize(d);
8319 if (z) asize += sizeof(zskiplistNode)*dictSize(d);
8320 }
8321 break;
a97b9060 8322 case REDIS_HASH:
8323 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
8324 unsigned char *p = zipmapRewind((unsigned char*)o->ptr);
8325 unsigned int len = zipmapLen((unsigned char*)o->ptr);
8326 unsigned int klen, vlen;
8327 unsigned char *key, *val;
8328
8329 if ((p = zipmapNext(p,&key,&klen,&val,&vlen)) == NULL) {
8330 klen = 0;
8331 vlen = 0;
8332 }
8333 asize = len*(klen+vlen+3);
8334 } else if (o->encoding == REDIS_ENCODING_HT) {
8335 d = o->ptr;
8336 asize = sizeof(dict)+(sizeof(struct dictEntry*)*dictSlots(d));
8337 if (dictSize(d)) {
8338 long elesize;
8339 robj *ele;
8340
8341 de = dictGetRandomKey(d);
8342 ele = dictGetEntryKey(de);
8343 elesize = (ele->encoding == REDIS_ENCODING_RAW) ?
8344 (sizeof(*o)+sdslen(ele->ptr)) :
8345 sizeof(*o);
8346 ele = dictGetEntryVal(de);
8347 elesize = (ele->encoding == REDIS_ENCODING_RAW) ?
8348 (sizeof(*o)+sdslen(ele->ptr)) :
8349 sizeof(*o);
8350 asize += (sizeof(struct dictEntry)+elesize)*dictSize(d);
8351 }
8352 }
8353 break;
4ef8de8a 8354 }
c8c72447 8355 return (double)age*log(1+asize);
4ef8de8a 8356}
8357
8358/* Try to swap an object that's a good candidate for swapping.
8359 * Returns REDIS_OK if the object was swapped, REDIS_ERR if it's not possible
a69a0c9c 8360 * to swap any object at all.
8361 *
8362 * If 'usethreaded' is true, Redis will try to swap the object in background
8363 * using I/O threads. */
8364static int vmSwapOneObject(int usethreads) {
4ef8de8a 8365 int j, i;
8366 struct dictEntry *best = NULL;
8367 double best_swappability = 0;
b9bc0eef 8368 redisDb *best_db = NULL;
4ef8de8a 8369 robj *key, *val;
8370
8371 for (j = 0; j < server.dbnum; j++) {
8372 redisDb *db = server.db+j;
b72f6a4b 8373 /* Why maxtries is set to 100?
8374 * Because this way (usually) we'll find 1 object even if just 1% - 2%
8375 * are swappable objects */
b0d8747d 8376 int maxtries = 100;
4ef8de8a 8377
8378 if (dictSize(db->dict) == 0) continue;
8379 for (i = 0; i < 5; i++) {
8380 dictEntry *de;
8381 double swappability;
8382
e3cadb8a 8383 if (maxtries) maxtries--;
4ef8de8a 8384 de = dictGetRandomKey(db->dict);
8385 key = dictGetEntryKey(de);
8386 val = dictGetEntryVal(de);
1064ef87 8387 /* Only swap objects that are currently in memory.
8388 *
8389 * Also don't swap shared objects if threaded VM is on, as we
8390 * try to ensure that the main thread does not touch the
8391 * object while the I/O thread is using it, but we can't
8392 * control other keys without adding additional mutex. */
8393 if (key->storage != REDIS_VM_MEMORY ||
8394 (server.vm_max_threads != 0 && val->refcount != 1)) {
e3cadb8a 8395 if (maxtries) i--; /* don't count this try */
8396 continue;
8397 }
4ef8de8a 8398 swappability = computeObjectSwappability(val);
8399 if (!best || swappability > best_swappability) {
8400 best = de;
8401 best_swappability = swappability;
b9bc0eef 8402 best_db = db;
4ef8de8a 8403 }
8404 }
8405 }
7c775e09 8406 if (best == NULL) return REDIS_ERR;
4ef8de8a 8407 key = dictGetEntryKey(best);
8408 val = dictGetEntryVal(best);
8409
e3cadb8a 8410 redisLog(REDIS_DEBUG,"Key with best swappability: %s, %f",
4ef8de8a 8411 key->ptr, best_swappability);
8412
8413 /* Unshare the key if needed */
8414 if (key->refcount > 1) {
8415 robj *newkey = dupStringObject(key);
8416 decrRefCount(key);
8417 key = dictGetEntryKey(best) = newkey;
8418 }
8419 /* Swap it */
a69a0c9c 8420 if (usethreads) {
b9bc0eef 8421 vmSwapObjectThreaded(key,val,best_db);
4ef8de8a 8422 return REDIS_OK;
8423 } else {
a69a0c9c 8424 if (vmSwapObjectBlocking(key,val) == REDIS_OK) {
8425 dictGetEntryVal(best) = NULL;
8426 return REDIS_OK;
8427 } else {
8428 return REDIS_ERR;
8429 }
4ef8de8a 8430 }
8431}
8432
a69a0c9c 8433static int vmSwapOneObjectBlocking() {
8434 return vmSwapOneObject(0);
8435}
8436
8437static int vmSwapOneObjectThreaded() {
8438 return vmSwapOneObject(1);
8439}
8440
7e69548d 8441/* Return true if it's safe to swap out objects in a given moment.
8442 * Basically we don't want to swap objects out while there is a BGSAVE
8443 * or a BGAEOREWRITE running in backgroud. */
8444static int vmCanSwapOut(void) {
8445 return (server.bgsavechildpid == -1 && server.bgrewritechildpid == -1);
8446}
8447
1b03836c 8448/* Delete a key if swapped. Returns 1 if the key was found, was swapped
8449 * and was deleted. Otherwise 0 is returned. */
8450static int deleteIfSwapped(redisDb *db, robj *key) {
8451 dictEntry *de;
8452 robj *foundkey;
8453
8454 if ((de = dictFind(db->dict,key)) == NULL) return 0;
8455 foundkey = dictGetEntryKey(de);
8456 if (foundkey->storage == REDIS_VM_MEMORY) return 0;
8457 deleteKey(db,key);
8458 return 1;
8459}
8460
996cb5f7 8461/* =================== Virtual Memory - Threaded I/O ======================= */
8462
b9bc0eef 8463static void freeIOJob(iojob *j) {
d5d55fc3 8464 if ((j->type == REDIS_IOJOB_PREPARE_SWAP ||
8465 j->type == REDIS_IOJOB_DO_SWAP ||
8466 j->type == REDIS_IOJOB_LOAD) && j->val != NULL)
b9bc0eef 8467 decrRefCount(j->val);
8468 decrRefCount(j->key);
8469 zfree(j);
8470}
8471
996cb5f7 8472/* Every time a thread finished a Job, it writes a byte into the write side
8473 * of an unix pipe in order to "awake" the main thread, and this function
8474 * is called. */
8475static void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata,
8476 int mask)
8477{
8478 char buf[1];
b0d8747d 8479 int retval, processed = 0, toprocess = -1, trytoswap = 1;
996cb5f7 8480 REDIS_NOTUSED(el);
8481 REDIS_NOTUSED(mask);
8482 REDIS_NOTUSED(privdata);
8483
8484 /* For every byte we read in the read side of the pipe, there is one
8485 * I/O job completed to process. */
8486 while((retval = read(fd,buf,1)) == 1) {
b9bc0eef 8487 iojob *j;
8488 listNode *ln;
8489 robj *key;
8490 struct dictEntry *de;
8491
996cb5f7 8492 redisLog(REDIS_DEBUG,"Processing I/O completed job");
b9bc0eef 8493
8494 /* Get the processed element (the oldest one) */
8495 lockThreadedIO();
1064ef87 8496 assert(listLength(server.io_processed) != 0);
f6c0bba8 8497 if (toprocess == -1) {
8498 toprocess = (listLength(server.io_processed)*REDIS_MAX_COMPLETED_JOBS_PROCESSED)/100;
8499 if (toprocess <= 0) toprocess = 1;
8500 }
b9bc0eef 8501 ln = listFirst(server.io_processed);
8502 j = ln->value;
8503 listDelNode(server.io_processed,ln);
8504 unlockThreadedIO();
8505 /* If this job is marked as canceled, just ignore it */
8506 if (j->canceled) {
8507 freeIOJob(j);
8508 continue;
8509 }
8510 /* Post process it in the main thread, as there are things we
8511 * can do just here to avoid race conditions and/or invasive locks */
6c96ba7d 8512 redisLog(REDIS_DEBUG,"Job %p type: %d, key at %p (%s) refcount: %d\n", (void*) j, j->type, (void*)j->key, (char*)j->key->ptr, j->key->refcount);
b9bc0eef 8513 de = dictFind(j->db->dict,j->key);
8514 assert(de != NULL);
8515 key = dictGetEntryKey(de);
8516 if (j->type == REDIS_IOJOB_LOAD) {
d5d55fc3 8517 redisDb *db;
8518
b9bc0eef 8519 /* Key loaded, bring it at home */
8520 key->storage = REDIS_VM_MEMORY;
8521 key->vm.atime = server.unixtime;
8522 vmMarkPagesFree(key->vm.page,key->vm.usedpages);
8523 redisLog(REDIS_DEBUG, "VM: object %s loaded from disk (threaded)",
8524 (unsigned char*) key->ptr);
8525 server.vm_stats_swapped_objects--;
8526 server.vm_stats_swapins++;
d5d55fc3 8527 dictGetEntryVal(de) = j->val;
8528 incrRefCount(j->val);
8529 db = j->db;
b9bc0eef 8530 freeIOJob(j);
d5d55fc3 8531 /* Handle clients waiting for this key to be loaded. */
8532 handleClientsBlockedOnSwappedKey(db,key);
b9bc0eef 8533 } else if (j->type == REDIS_IOJOB_PREPARE_SWAP) {
8534 /* Now we know the amount of pages required to swap this object.
8535 * Let's find some space for it, and queue this task again
8536 * rebranded as REDIS_IOJOB_DO_SWAP. */
054e426d 8537 if (!vmCanSwapOut() ||
8538 vmFindContiguousPages(&j->page,j->pages) == REDIS_ERR)
8539 {
8540 /* Ooops... no space or we can't swap as there is
8541 * a fork()ed Redis trying to save stuff on disk. */
b9bc0eef 8542 freeIOJob(j);
054e426d 8543 key->storage = REDIS_VM_MEMORY; /* undo operation */
b9bc0eef 8544 } else {
c7df85a4 8545 /* Note that we need to mark this pages as used now,
8546 * if the job will be canceled, we'll mark them as freed
8547 * again. */
8548 vmMarkPagesUsed(j->page,j->pages);
b9bc0eef 8549 j->type = REDIS_IOJOB_DO_SWAP;
8550 lockThreadedIO();
8551 queueIOJob(j);
8552 unlockThreadedIO();
8553 }
8554 } else if (j->type == REDIS_IOJOB_DO_SWAP) {
8555 robj *val;
8556
8557 /* Key swapped. We can finally free some memory. */
6c96ba7d 8558 if (key->storage != REDIS_VM_SWAPPING) {
8559 printf("key->storage: %d\n",key->storage);
8560 printf("key->name: %s\n",(char*)key->ptr);
8561 printf("key->refcount: %d\n",key->refcount);
8562 printf("val: %p\n",(void*)j->val);
8563 printf("val->type: %d\n",j->val->type);
8564 printf("val->ptr: %s\n",(char*)j->val->ptr);
8565 }
8566 redisAssert(key->storage == REDIS_VM_SWAPPING);
b9bc0eef 8567 val = dictGetEntryVal(de);
8568 key->vm.page = j->page;
8569 key->vm.usedpages = j->pages;
8570 key->storage = REDIS_VM_SWAPPED;
8571 key->vtype = j->val->type;
8572 decrRefCount(val); /* Deallocate the object from memory. */
f11b8647 8573 dictGetEntryVal(de) = NULL;
b9bc0eef 8574 redisLog(REDIS_DEBUG,
8575 "VM: object %s swapped out at %lld (%lld pages) (threaded)",
8576 (unsigned char*) key->ptr,
8577 (unsigned long long) j->page, (unsigned long long) j->pages);
8578 server.vm_stats_swapped_objects++;
8579 server.vm_stats_swapouts++;
8580 freeIOJob(j);
f11b8647 8581 /* Put a few more swap requests in queue if we are still
8582 * out of memory */
b0d8747d 8583 if (trytoswap && vmCanSwapOut() &&
8584 zmalloc_used_memory() > server.vm_max_memory)
8585 {
f11b8647 8586 int more = 1;
8587 while(more) {
8588 lockThreadedIO();
8589 more = listLength(server.io_newjobs) <
8590 (unsigned) server.vm_max_threads;
8591 unlockThreadedIO();
8592 /* Don't waste CPU time if swappable objects are rare. */
b0d8747d 8593 if (vmSwapOneObjectThreaded() == REDIS_ERR) {
8594 trytoswap = 0;
8595 break;
8596 }
f11b8647 8597 }
8598 }
b9bc0eef 8599 }
c953f24b 8600 processed++;
f6c0bba8 8601 if (processed == toprocess) return;
996cb5f7 8602 }
8603 if (retval < 0 && errno != EAGAIN) {
8604 redisLog(REDIS_WARNING,
8605 "WARNING: read(2) error in vmThreadedIOCompletedJob() %s",
8606 strerror(errno));
8607 }
8608}
8609
8610static void lockThreadedIO(void) {
8611 pthread_mutex_lock(&server.io_mutex);
8612}
8613
8614static void unlockThreadedIO(void) {
8615 pthread_mutex_unlock(&server.io_mutex);
8616}
8617
8618/* Remove the specified object from the threaded I/O queue if still not
8619 * processed, otherwise make sure to flag it as canceled. */
8620static void vmCancelThreadedIOJob(robj *o) {
8621 list *lists[3] = {
6c96ba7d 8622 server.io_newjobs, /* 0 */
8623 server.io_processing, /* 1 */
8624 server.io_processed /* 2 */
996cb5f7 8625 };
8626 int i;
8627
8628 assert(o->storage == REDIS_VM_LOADING || o->storage == REDIS_VM_SWAPPING);
2e111efe 8629again:
996cb5f7 8630 lockThreadedIO();
8631 /* Search for a matching key in one of the queues */
8632 for (i = 0; i < 3; i++) {
8633 listNode *ln;
c7df85a4 8634 listIter li;
996cb5f7 8635
c7df85a4 8636 listRewind(lists[i],&li);
8637 while ((ln = listNext(&li)) != NULL) {
996cb5f7 8638 iojob *job = ln->value;
8639
6c96ba7d 8640 if (job->canceled) continue; /* Skip this, already canceled. */
996cb5f7 8641 if (compareStringObjects(job->key,o) == 0) {
970e10bb 8642 redisLog(REDIS_DEBUG,"*** CANCELED %p (%s) (type %d) (LIST ID %d)\n",
8643 (void*)job, (char*)o->ptr, job->type, i);
427a2153 8644 /* Mark the pages as free since the swap didn't happened
8645 * or happened but is now discarded. */
970e10bb 8646 if (i != 1 && job->type == REDIS_IOJOB_DO_SWAP)
427a2153 8647 vmMarkPagesFree(job->page,job->pages);
8648 /* Cancel the job. It depends on the list the job is
8649 * living in. */
996cb5f7 8650 switch(i) {
8651 case 0: /* io_newjobs */
6c96ba7d 8652 /* If the job was yet not processed the best thing to do
996cb5f7 8653 * is to remove it from the queue at all */
6c96ba7d 8654 freeIOJob(job);
996cb5f7 8655 listDelNode(lists[i],ln);
8656 break;
8657 case 1: /* io_processing */
d5d55fc3 8658 /* Oh Shi- the thread is messing with the Job:
8659 *
8660 * Probably it's accessing the object if this is a
8661 * PREPARE_SWAP or DO_SWAP job.
8662 * If it's a LOAD job it may be reading from disk and
8663 * if we don't wait for the job to terminate before to
8664 * cancel it, maybe in a few microseconds data can be
8665 * corrupted in this pages. So the short story is:
8666 *
8667 * Better to wait for the job to move into the
8668 * next queue (processed)... */
8669
8670 /* We try again and again until the job is completed. */
8671 unlockThreadedIO();
8672 /* But let's wait some time for the I/O thread
8673 * to finish with this job. After all this condition
8674 * should be very rare. */
8675 usleep(1);
8676 goto again;
996cb5f7 8677 case 2: /* io_processed */
2e111efe 8678 /* The job was already processed, that's easy...
8679 * just mark it as canceled so that we'll ignore it
8680 * when processing completed jobs. */
996cb5f7 8681 job->canceled = 1;
8682 break;
8683 }
c7df85a4 8684 /* Finally we have to adjust the storage type of the object
8685 * in order to "UNDO" the operaiton. */
996cb5f7 8686 if (o->storage == REDIS_VM_LOADING)
8687 o->storage = REDIS_VM_SWAPPED;
8688 else if (o->storage == REDIS_VM_SWAPPING)
8689 o->storage = REDIS_VM_MEMORY;
8690 unlockThreadedIO();
8691 return;
8692 }
8693 }
8694 }
8695 unlockThreadedIO();
8696 assert(1 != 1); /* We should never reach this */
8697}
8698
b9bc0eef 8699static void *IOThreadEntryPoint(void *arg) {
8700 iojob *j;
8701 listNode *ln;
8702 REDIS_NOTUSED(arg);
8703
8704 pthread_detach(pthread_self());
8705 while(1) {
8706 /* Get a new job to process */
8707 lockThreadedIO();
8708 if (listLength(server.io_newjobs) == 0) {
8709 /* No new jobs in queue, exit. */
9ebed7cf 8710 redisLog(REDIS_DEBUG,"Thread %ld exiting, nothing to do",
8711 (long) pthread_self());
b9bc0eef 8712 server.io_active_threads--;
8713 unlockThreadedIO();
8714 return NULL;
8715 }
8716 ln = listFirst(server.io_newjobs);
8717 j = ln->value;
8718 listDelNode(server.io_newjobs,ln);
8719 /* Add the job in the processing queue */
8720 j->thread = pthread_self();
8721 listAddNodeTail(server.io_processing,j);
8722 ln = listLast(server.io_processing); /* We use ln later to remove it */
8723 unlockThreadedIO();
9ebed7cf 8724 redisLog(REDIS_DEBUG,"Thread %ld got a new job (type %d): %p about key '%s'",
8725 (long) pthread_self(), j->type, (void*)j, (char*)j->key->ptr);
b9bc0eef 8726
8727 /* Process the Job */
8728 if (j->type == REDIS_IOJOB_LOAD) {
d5d55fc3 8729 j->val = vmReadObjectFromSwap(j->page,j->key->vtype);
b9bc0eef 8730 } else if (j->type == REDIS_IOJOB_PREPARE_SWAP) {
8731 FILE *fp = fopen("/dev/null","w+");
8732 j->pages = rdbSavedObjectPages(j->val,fp);
8733 fclose(fp);
8734 } else if (j->type == REDIS_IOJOB_DO_SWAP) {
a5819310 8735 if (vmWriteObjectOnSwap(j->val,j->page) == REDIS_ERR)
8736 j->canceled = 1;
b9bc0eef 8737 }
8738
8739 /* Done: insert the job into the processed queue */
9ebed7cf 8740 redisLog(REDIS_DEBUG,"Thread %ld completed the job: %p (key %s)",
8741 (long) pthread_self(), (void*)j, (char*)j->key->ptr);
b9bc0eef 8742 lockThreadedIO();
8743 listDelNode(server.io_processing,ln);
8744 listAddNodeTail(server.io_processed,j);
8745 unlockThreadedIO();
8746
8747 /* Signal the main thread there is new stuff to process */
8748 assert(write(server.io_ready_pipe_write,"x",1) == 1);
8749 }
8750 return NULL; /* never reached */
8751}
8752
8753static void spawnIOThread(void) {
8754 pthread_t thread;
478c2c6f 8755 sigset_t mask, omask;
a97b9060 8756 int err;
b9bc0eef 8757
478c2c6f 8758 sigemptyset(&mask);
8759 sigaddset(&mask,SIGCHLD);
8760 sigaddset(&mask,SIGHUP);
8761 sigaddset(&mask,SIGPIPE);
8762 pthread_sigmask(SIG_SETMASK, &mask, &omask);
a97b9060 8763 while ((err = pthread_create(&thread,&server.io_threads_attr,IOThreadEntryPoint,NULL)) != 0) {
8764 redisLog(REDIS_WARNING,"Unable to spawn an I/O thread: %s",
8765 strerror(err));
8766 usleep(1000000);
8767 }
478c2c6f 8768 pthread_sigmask(SIG_SETMASK, &omask, NULL);
b9bc0eef 8769 server.io_active_threads++;
8770}
8771
4ee9488d 8772/* We need to wait for the last thread to exit before we are able to
8773 * fork() in order to BGSAVE or BGREWRITEAOF. */
054e426d 8774static void waitEmptyIOJobsQueue(void) {
4ee9488d 8775 while(1) {
76b7233a 8776 int io_processed_len;
8777
4ee9488d 8778 lockThreadedIO();
054e426d 8779 if (listLength(server.io_newjobs) == 0 &&
8780 listLength(server.io_processing) == 0 &&
8781 server.io_active_threads == 0)
8782 {
4ee9488d 8783 unlockThreadedIO();
8784 return;
8785 }
76b7233a 8786 /* While waiting for empty jobs queue condition we post-process some
8787 * finshed job, as I/O threads may be hanging trying to write against
8788 * the io_ready_pipe_write FD but there are so much pending jobs that
8789 * it's blocking. */
8790 io_processed_len = listLength(server.io_processed);
4ee9488d 8791 unlockThreadedIO();
76b7233a 8792 if (io_processed_len) {
8793 vmThreadedIOCompletedJob(NULL,server.io_ready_pipe_read,NULL,0);
8794 usleep(1000); /* 1 millisecond */
8795 } else {
8796 usleep(10000); /* 10 milliseconds */
8797 }
4ee9488d 8798 }
8799}
8800
054e426d 8801static void vmReopenSwapFile(void) {
478c2c6f 8802 /* Note: we don't close the old one as we are in the child process
8803 * and don't want to mess at all with the original file object. */
054e426d 8804 server.vm_fp = fopen(server.vm_swap_file,"r+b");
8805 if (server.vm_fp == NULL) {
8806 redisLog(REDIS_WARNING,"Can't re-open the VM swap file: %s. Exiting.",
8807 server.vm_swap_file);
478c2c6f 8808 _exit(1);
054e426d 8809 }
8810 server.vm_fd = fileno(server.vm_fp);
8811}
8812
b9bc0eef 8813/* This function must be called while with threaded IO locked */
8814static void queueIOJob(iojob *j) {
6c96ba7d 8815 redisLog(REDIS_DEBUG,"Queued IO Job %p type %d about key '%s'\n",
8816 (void*)j, j->type, (char*)j->key->ptr);
b9bc0eef 8817 listAddNodeTail(server.io_newjobs,j);
8818 if (server.io_active_threads < server.vm_max_threads)
8819 spawnIOThread();
8820}
8821
8822static int vmSwapObjectThreaded(robj *key, robj *val, redisDb *db) {
8823 iojob *j;
8824
8825 assert(key->storage == REDIS_VM_MEMORY);
8826 assert(key->refcount == 1);
8827
8828 j = zmalloc(sizeof(*j));
8829 j->type = REDIS_IOJOB_PREPARE_SWAP;
8830 j->db = db;
8831 j->key = dupStringObject(key);
8832 j->val = val;
8833 incrRefCount(val);
8834 j->canceled = 0;
8835 j->thread = (pthread_t) -1;
f11b8647 8836 key->storage = REDIS_VM_SWAPPING;
b9bc0eef 8837
8838 lockThreadedIO();
8839 queueIOJob(j);
8840 unlockThreadedIO();
8841 return REDIS_OK;
8842}
8843
b0d8747d 8844/* ============ Virtual Memory - Blocking clients on missing keys =========== */
8845
d5d55fc3 8846/* This function makes the clinet 'c' waiting for the key 'key' to be loaded.
8847 * If there is not already a job loading the key, it is craeted.
8848 * The key is added to the io_keys list in the client structure, and also
8849 * in the hash table mapping swapped keys to waiting clients, that is,
8850 * server.io_waited_keys. */
8851static int waitForSwappedKey(redisClient *c, robj *key) {
8852 struct dictEntry *de;
8853 robj *o;
8854 list *l;
8855
8856 /* If the key does not exist or is already in RAM we don't need to
8857 * block the client at all. */
8858 de = dictFind(c->db->dict,key);
8859 if (de == NULL) return 0;
8860 o = dictGetEntryKey(de);
8861 if (o->storage == REDIS_VM_MEMORY) {
8862 return 0;
8863 } else if (o->storage == REDIS_VM_SWAPPING) {
8864 /* We were swapping the key, undo it! */
8865 vmCancelThreadedIOJob(o);
8866 return 0;
8867 }
8868
8869 /* OK: the key is either swapped, or being loaded just now. */
8870
8871 /* Add the key to the list of keys this client is waiting for.
8872 * This maps clients to keys they are waiting for. */
8873 listAddNodeTail(c->io_keys,key);
8874 incrRefCount(key);
8875
8876 /* Add the client to the swapped keys => clients waiting map. */
8877 de = dictFind(c->db->io_keys,key);
8878 if (de == NULL) {
8879 int retval;
8880
8881 /* For every key we take a list of clients blocked for it */
8882 l = listCreate();
8883 retval = dictAdd(c->db->io_keys,key,l);
8884 incrRefCount(key);
8885 assert(retval == DICT_OK);
8886 } else {
8887 l = dictGetEntryVal(de);
8888 }
8889 listAddNodeTail(l,c);
8890
8891 /* Are we already loading the key from disk? If not create a job */
8892 if (o->storage == REDIS_VM_SWAPPED) {
8893 iojob *j;
8894
8895 o->storage = REDIS_VM_LOADING;
8896 j = zmalloc(sizeof(*j));
8897 j->type = REDIS_IOJOB_LOAD;
8898 j->db = c->db;
8899 j->key = dupStringObject(key);
8900 j->key->vtype = o->vtype;
8901 j->page = o->vm.page;
8902 j->val = NULL;
8903 j->canceled = 0;
8904 j->thread = (pthread_t) -1;
8905 lockThreadedIO();
8906 queueIOJob(j);
8907 unlockThreadedIO();
8908 }
8909 return 1;
8910}
8911
76583ea4
PN
8912/* Preload keys needed for the ZUNION and ZINTER commands. */
8913static void zunionInterBlockClientOnSwappedKeys(redisClient *c) {
8914 int i, num;
8915 num = atoi(c->argv[2]->ptr);
8916 for (i = 0; i < num; i++) {
8917 waitForSwappedKey(c,c->argv[3+i]);
8918 }
8919}
8920
b0d8747d 8921/* Is this client attempting to run a command against swapped keys?
d5d55fc3 8922 * If so, block it ASAP, load the keys in background, then resume it.
b0d8747d 8923 *
d5d55fc3 8924 * The important idea about this function is that it can fail! If keys will
8925 * still be swapped when the client is resumed, this key lookups will
8926 * just block loading keys from disk. In practical terms this should only
8927 * happen with SORT BY command or if there is a bug in this function.
8928 *
8929 * Return 1 if the client is marked as blocked, 0 if the client can
8930 * continue as the keys it is going to access appear to be in memory. */
8931static int blockClientOnSwappedKeys(struct redisCommand *cmd, redisClient *c) {
7c775e09 8932 int j, last;
8933
76583ea4
PN
8934 if (cmd->vm_preload_proc != NULL) {
8935 cmd->vm_preload_proc(c);
8936 } else {
8937 if (cmd->vm_firstkey == 0) return 0;
8938 last = cmd->vm_lastkey;
8939 if (last < 0) last = c->argc+last;
8940 for (j = cmd->vm_firstkey; j <= last; j += cmd->vm_keystep)
8941 waitForSwappedKey(c,c->argv[j]);
8942 }
8943
d5d55fc3 8944 /* If the client was blocked for at least one key, mark it as blocked. */
8945 if (listLength(c->io_keys)) {
8946 c->flags |= REDIS_IO_WAIT;
8947 aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
8948 server.vm_blocked_clients++;
8949 return 1;
8950 } else {
8951 return 0;
8952 }
8953}
8954
8955/* Remove the 'key' from the list of blocked keys for a given client.
8956 *
8957 * The function returns 1 when there are no longer blocking keys after
8958 * the current one was removed (and the client can be unblocked). */
8959static int dontWaitForSwappedKey(redisClient *c, robj *key) {
8960 list *l;
8961 listNode *ln;
8962 listIter li;
8963 struct dictEntry *de;
8964
8965 /* Remove the key from the list of keys this client is waiting for. */
8966 listRewind(c->io_keys,&li);
8967 while ((ln = listNext(&li)) != NULL) {
8968 if (compareStringObjects(ln->value,key) == 0) {
8969 listDelNode(c->io_keys,ln);
8970 break;
8971 }
8972 }
8973 assert(ln != NULL);
8974
8975 /* Remove the client form the key => waiting clients map. */
8976 de = dictFind(c->db->io_keys,key);
8977 assert(de != NULL);
8978 l = dictGetEntryVal(de);
8979 ln = listSearchKey(l,c);
8980 assert(ln != NULL);
8981 listDelNode(l,ln);
8982 if (listLength(l) == 0)
8983 dictDelete(c->db->io_keys,key);
8984
8985 return listLength(c->io_keys) == 0;
8986}
8987
8988static void handleClientsBlockedOnSwappedKey(redisDb *db, robj *key) {
8989 struct dictEntry *de;
8990 list *l;
8991 listNode *ln;
8992 int len;
8993
8994 de = dictFind(db->io_keys,key);
8995 if (!de) return;
8996
8997 l = dictGetEntryVal(de);
8998 len = listLength(l);
8999 /* Note: we can't use something like while(listLength(l)) as the list
9000 * can be freed by the calling function when we remove the last element. */
9001 while (len--) {
9002 ln = listFirst(l);
9003 redisClient *c = ln->value;
9004
9005 if (dontWaitForSwappedKey(c,key)) {
9006 /* Put the client in the list of clients ready to go as we
9007 * loaded all the keys about it. */
9008 listAddNodeTail(server.io_ready_clients,c);
9009 }
9010 }
b0d8747d 9011}
b0d8747d 9012
7f957c92 9013/* ================================= Debugging ============================== */
9014
9015static void debugCommand(redisClient *c) {
9016 if (!strcasecmp(c->argv[1]->ptr,"segfault")) {
9017 *((char*)-1) = 'x';
210e29f7 9018 } else if (!strcasecmp(c->argv[1]->ptr,"reload")) {
9019 if (rdbSave(server.dbfilename) != REDIS_OK) {
9020 addReply(c,shared.err);
9021 return;
9022 }
9023 emptyDb();
9024 if (rdbLoad(server.dbfilename) != REDIS_OK) {
9025 addReply(c,shared.err);
9026 return;
9027 }
9028 redisLog(REDIS_WARNING,"DB reloaded by DEBUG RELOAD");
9029 addReply(c,shared.ok);
71c2b467 9030 } else if (!strcasecmp(c->argv[1]->ptr,"loadaof")) {
9031 emptyDb();
9032 if (loadAppendOnlyFile(server.appendfilename) != REDIS_OK) {
9033 addReply(c,shared.err);
9034 return;
9035 }
9036 redisLog(REDIS_WARNING,"Append Only File loaded by DEBUG LOADAOF");
9037 addReply(c,shared.ok);
333298da 9038 } else if (!strcasecmp(c->argv[1]->ptr,"object") && c->argc == 3) {
9039 dictEntry *de = dictFind(c->db->dict,c->argv[2]);
9040 robj *key, *val;
9041
9042 if (!de) {
9043 addReply(c,shared.nokeyerr);
9044 return;
9045 }
9046 key = dictGetEntryKey(de);
9047 val = dictGetEntryVal(de);
59146ef3 9048 if (!server.vm_enabled || (key->storage == REDIS_VM_MEMORY ||
9049 key->storage == REDIS_VM_SWAPPING)) {
07efaf74 9050 char *strenc;
9051 char buf[128];
9052
9053 if (val->encoding < (sizeof(strencoding)/sizeof(char*))) {
9054 strenc = strencoding[val->encoding];
9055 } else {
9056 snprintf(buf,64,"unknown encoding %d\n", val->encoding);
9057 strenc = buf;
9058 }
ace06542 9059 addReplySds(c,sdscatprintf(sdsempty(),
9060 "+Key at:%p refcount:%d, value at:%p refcount:%d "
07efaf74 9061 "encoding:%s serializedlength:%lld\r\n",
682ac724 9062 (void*)key, key->refcount, (void*)val, val->refcount,
07efaf74 9063 strenc, (long long) rdbSavedObjectLen(val,NULL)));
ace06542 9064 } else {
9065 addReplySds(c,sdscatprintf(sdsempty(),
9066 "+Key at:%p refcount:%d, value swapped at: page %llu "
9067 "using %llu pages\r\n",
9068 (void*)key, key->refcount, (unsigned long long) key->vm.page,
9069 (unsigned long long) key->vm.usedpages));
9070 }
7d30035d 9071 } else if (!strcasecmp(c->argv[1]->ptr,"swapout") && c->argc == 3) {
9072 dictEntry *de = dictFind(c->db->dict,c->argv[2]);
9073 robj *key, *val;
9074
9075 if (!server.vm_enabled) {
9076 addReplySds(c,sdsnew("-ERR Virtual Memory is disabled\r\n"));
9077 return;
9078 }
9079 if (!de) {
9080 addReply(c,shared.nokeyerr);
9081 return;
9082 }
9083 key = dictGetEntryKey(de);
9084 val = dictGetEntryVal(de);
4ef8de8a 9085 /* If the key is shared we want to create a copy */
9086 if (key->refcount > 1) {
9087 robj *newkey = dupStringObject(key);
9088 decrRefCount(key);
9089 key = dictGetEntryKey(de) = newkey;
9090 }
9091 /* Swap it */
7d30035d 9092 if (key->storage != REDIS_VM_MEMORY) {
9093 addReplySds(c,sdsnew("-ERR This key is not in memory\r\n"));
a69a0c9c 9094 } else if (vmSwapObjectBlocking(key,val) == REDIS_OK) {
7d30035d 9095 dictGetEntryVal(de) = NULL;
9096 addReply(c,shared.ok);
9097 } else {
9098 addReply(c,shared.err);
9099 }
7f957c92 9100 } else {
333298da 9101 addReplySds(c,sdsnew(
7d30035d 9102 "-ERR Syntax error, try DEBUG [SEGFAULT|OBJECT <key>|SWAPOUT <key>|RELOAD]\r\n"));
7f957c92 9103 }
9104}
56906eef 9105
6c96ba7d 9106static void _redisAssert(char *estr, char *file, int line) {
dfc5e96c 9107 redisLog(REDIS_WARNING,"=== ASSERTION FAILED ===");
6c96ba7d 9108 redisLog(REDIS_WARNING,"==> %s:%d '%s' is not true\n",file,line,estr);
dfc5e96c 9109#ifdef HAVE_BACKTRACE
9110 redisLog(REDIS_WARNING,"(forcing SIGSEGV in order to print the stack trace)");
9111 *((char*)-1) = 'x';
9112#endif
9113}
9114
bcfc686d 9115/* =================================== Main! ================================ */
56906eef 9116
bcfc686d 9117#ifdef __linux__
9118int linuxOvercommitMemoryValue(void) {
9119 FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r");
9120 char buf[64];
56906eef 9121
bcfc686d 9122 if (!fp) return -1;
9123 if (fgets(buf,64,fp) == NULL) {
9124 fclose(fp);
9125 return -1;
9126 }
9127 fclose(fp);
56906eef 9128
bcfc686d 9129 return atoi(buf);
9130}
9131
9132void linuxOvercommitMemoryWarning(void) {
9133 if (linuxOvercommitMemoryValue() == 0) {
9134 redisLog(REDIS_WARNING,"WARNING overcommit_memory is set to 0! Background save may fail under low condition memory. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.");
9135 }
9136}
9137#endif /* __linux__ */
9138
9139static void daemonize(void) {
9140 int fd;
9141 FILE *fp;
9142
9143 if (fork() != 0) exit(0); /* parent exits */
9144 setsid(); /* create a new session */
9145
9146 /* Every output goes to /dev/null. If Redis is daemonized but
9147 * the 'logfile' is set to 'stdout' in the configuration file
9148 * it will not log at all. */
9149 if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
9150 dup2(fd, STDIN_FILENO);
9151 dup2(fd, STDOUT_FILENO);
9152 dup2(fd, STDERR_FILENO);
9153 if (fd > STDERR_FILENO) close(fd);
9154 }
9155 /* Try to write the pid file */
9156 fp = fopen(server.pidfile,"w");
9157 if (fp) {
9158 fprintf(fp,"%d\n",getpid());
9159 fclose(fp);
56906eef 9160 }
56906eef 9161}
9162
42ab0172
AO
9163static void version() {
9164 printf("Redis server version %s\n", REDIS_VERSION);
9165 exit(0);
9166}
9167
bcfc686d 9168int main(int argc, char **argv) {
9651a787 9169 time_t start;
9170
bcfc686d 9171 initServerConfig();
9172 if (argc == 2) {
42ab0172
AO
9173 if ((strcmp(argv[1], "-v") == 0) || (strcmp(argv[1], "--version") == 0)) {
9174 version();
9175 }
bcfc686d 9176 resetServerSaveParams();
9177 loadServerConfig(argv[1]);
9178 } else if (argc > 2) {
9179 fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n");
9180 exit(1);
9181 } else {
9182 redisLog(REDIS_WARNING,"Warning: no config file specified, using the default config. In order to specify a config file use 'redis-server /path/to/redis.conf'");
9183 }
bcfc686d 9184 if (server.daemonize) daemonize();
71c54b21 9185 initServer();
bcfc686d 9186 redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION);
9187#ifdef __linux__
9188 linuxOvercommitMemoryWarning();
9189#endif
9651a787 9190 start = time(NULL);
bcfc686d 9191 if (server.appendonly) {
9192 if (loadAppendOnlyFile(server.appendfilename) == REDIS_OK)
9651a787 9193 redisLog(REDIS_NOTICE,"DB loaded from append only file: %ld seconds",time(NULL)-start);
bcfc686d 9194 } else {
9195 if (rdbLoad(server.dbfilename) == REDIS_OK)
9651a787 9196 redisLog(REDIS_NOTICE,"DB loaded from disk: %ld seconds",time(NULL)-start);
bcfc686d 9197 }
bcfc686d 9198 redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);
d5d55fc3 9199 aeSetBeforeSleepProc(server.el,beforeSleep);
bcfc686d 9200 aeMain(server.el);
9201 aeDeleteEventLoop(server.el);
9202 return 0;
9203}
9204
9205/* ============================= Backtrace support ========================= */
9206
9207#ifdef HAVE_BACKTRACE
9208static char *findFuncName(void *pointer, unsigned long *offset);
9209
56906eef 9210static void *getMcontextEip(ucontext_t *uc) {
9211#if defined(__FreeBSD__)
9212 return (void*) uc->uc_mcontext.mc_eip;
9213#elif defined(__dietlibc__)
9214 return (void*) uc->uc_mcontext.eip;
06db1f50 9215#elif defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
da0a1620 9216 #if __x86_64__
9217 return (void*) uc->uc_mcontext->__ss.__rip;
9218 #else
56906eef 9219 return (void*) uc->uc_mcontext->__ss.__eip;
da0a1620 9220 #endif
06db1f50 9221#elif defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)
cb7e07cc 9222 #if defined(_STRUCT_X86_THREAD_STATE64) && !defined(__i386__)
06db1f50 9223 return (void*) uc->uc_mcontext->__ss.__rip;
cbc59b38 9224 #else
9225 return (void*) uc->uc_mcontext->__ss.__eip;
9226 #endif
54bac49d 9227#elif defined(__i386__) || defined(__X86_64__) || defined(__x86_64__)
c04c9ac9 9228 return (void*) uc->uc_mcontext.gregs[REG_EIP]; /* Linux 32/64 bit */
b91cf5ef 9229#elif defined(__ia64__) /* Linux IA64 */
9230 return (void*) uc->uc_mcontext.sc_ip;
9231#else
9232 return NULL;
56906eef 9233#endif
9234}
9235
9236static void segvHandler(int sig, siginfo_t *info, void *secret) {
9237 void *trace[100];
9238 char **messages = NULL;
9239 int i, trace_size = 0;
9240 unsigned long offset=0;
56906eef 9241 ucontext_t *uc = (ucontext_t*) secret;
1c85b79f 9242 sds infostring;
56906eef 9243 REDIS_NOTUSED(info);
9244
9245 redisLog(REDIS_WARNING,
9246 "======= Ooops! Redis %s got signal: -%d- =======", REDIS_VERSION, sig);
1c85b79f 9247 infostring = genRedisInfoString();
9248 redisLog(REDIS_WARNING, "%s",infostring);
9249 /* It's not safe to sdsfree() the returned string under memory
9250 * corruption conditions. Let it leak as we are going to abort */
56906eef 9251
9252 trace_size = backtrace(trace, 100);
de96dbfe 9253 /* overwrite sigaction with caller's address */
b91cf5ef 9254 if (getMcontextEip(uc) != NULL) {
9255 trace[1] = getMcontextEip(uc);
9256 }
56906eef 9257 messages = backtrace_symbols(trace, trace_size);
fe3bbfbe 9258
d76412d1 9259 for (i=1; i<trace_size; ++i) {
56906eef 9260 char *fn = findFuncName(trace[i], &offset), *p;
9261
9262 p = strchr(messages[i],'+');
9263 if (!fn || (p && ((unsigned long)strtol(p+1,NULL,10)) < offset)) {
9264 redisLog(REDIS_WARNING,"%s", messages[i]);
9265 } else {
9266 redisLog(REDIS_WARNING,"%d redis-server %p %s + %d", i, trace[i], fn, (unsigned int)offset);
9267 }
9268 }
b177fd30 9269 /* free(messages); Don't call free() with possibly corrupted memory. */
478c2c6f 9270 _exit(0);
fe3bbfbe 9271}
56906eef 9272
9273static void setupSigSegvAction(void) {
9274 struct sigaction act;
9275
9276 sigemptyset (&act.sa_mask);
9277 /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction
9278 * is used. Otherwise, sa_handler is used */
9279 act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;
9280 act.sa_sigaction = segvHandler;
9281 sigaction (SIGSEGV, &act, NULL);
9282 sigaction (SIGBUS, &act, NULL);
12fea928 9283 sigaction (SIGFPE, &act, NULL);
9284 sigaction (SIGILL, &act, NULL);
9285 sigaction (SIGBUS, &act, NULL);
e65fdc78 9286 return;
56906eef 9287}
e65fdc78 9288
bcfc686d 9289#include "staticsymbols.h"
9290/* This function try to convert a pointer into a function name. It's used in
9291 * oreder to provide a backtrace under segmentation fault that's able to
9292 * display functions declared as static (otherwise the backtrace is useless). */
9293static char *findFuncName(void *pointer, unsigned long *offset){
9294 int i, ret = -1;
9295 unsigned long off, minoff = 0;
ed9b544e 9296
bcfc686d 9297 /* Try to match against the Symbol with the smallest offset */
9298 for (i=0; symsTable[i].pointer; i++) {
9299 unsigned long lp = (unsigned long) pointer;
0bc03378 9300
bcfc686d 9301 if (lp != (unsigned long)-1 && lp >= symsTable[i].pointer) {
9302 off=lp-symsTable[i].pointer;
9303 if (ret < 0 || off < minoff) {
9304 minoff=off;
9305 ret=i;
9306 }
9307 }
0bc03378 9308 }
bcfc686d 9309 if (ret == -1) return NULL;
9310 *offset = minoff;
9311 return symsTable[ret].name;
0bc03378 9312}
bcfc686d 9313#else /* HAVE_BACKTRACE */
9314static void setupSigSegvAction(void) {
0bc03378 9315}
bcfc686d 9316#endif /* HAVE_BACKTRACE */
0bc03378 9317
ed9b544e 9318
ed9b544e 9319
bcfc686d 9320/* The End */
9321
9322
ed9b544e 9323