]> git.saurik.com Git - redis.git/blame - src/redis.c
Fix updating the prevlen field of consecutive entries
[redis.git] / src / redis.c
CommitLineData
e2641e09 1/*
2 * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * * Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of Redis nor the names of its contributors may be used
14 * to endorse or promote products derived from this software without
15 * specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "redis.h"
31
32#ifdef HAVE_BACKTRACE
33#include <execinfo.h>
34#include <ucontext.h>
35#endif /* HAVE_BACKTRACE */
36
37#include <time.h>
38#include <signal.h>
39#include <sys/wait.h>
40#include <errno.h>
41#include <assert.h>
42#include <ctype.h>
43#include <stdarg.h>
e2641e09 44#include <arpa/inet.h>
45#include <sys/stat.h>
46#include <fcntl.h>
47#include <sys/time.h>
48#include <sys/resource.h>
49#include <sys/uio.h>
50#include <limits.h>
51#include <float.h>
52#include <math.h>
53#include <pthread.h>
54
55/* Our shared "common" objects */
56
57struct sharedObjectsStruct shared;
58
59/* Global vars that are actally used as constants. The following double
60 * values are used for double on-disk serialization, and are initialized
61 * at runtime to avoid strange compiler optimizations. */
62
63double R_Zero, R_PosInf, R_NegInf, R_Nan;
64
65/*================================= Globals ================================= */
66
67/* Global vars */
68struct redisServer server; /* server global state */
69struct redisCommand *commandTable;
70struct redisCommand readonlyCommandTable[] = {
71 {"get",getCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
72 {"set",setCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,0,0,0},
73 {"setnx",setnxCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,0,0,0},
74 {"setex",setexCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,0,0,0},
75 {"append",appendCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
76 {"substr",substrCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
80091bba 77 {"strlen",strlenCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
e2641e09 78 {"del",delCommand,-2,REDIS_CMD_INLINE,NULL,0,0,0},
79 {"exists",existsCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
80 {"incr",incrCommand,2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
81 {"decr",decrCommand,2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
82 {"mget",mgetCommand,-2,REDIS_CMD_INLINE,NULL,1,-1,1},
83 {"rpush",rpushCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
84 {"lpush",lpushCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
85 {"rpushx",rpushxCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
86 {"lpushx",lpushxCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
87 {"linsert",linsertCommand,5,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
88 {"rpop",rpopCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
89 {"lpop",lpopCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
90 {"brpop",brpopCommand,-3,REDIS_CMD_INLINE,NULL,1,1,1},
91 {"blpop",blpopCommand,-3,REDIS_CMD_INLINE,NULL,1,1,1},
92 {"llen",llenCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
93 {"lindex",lindexCommand,3,REDIS_CMD_INLINE,NULL,1,1,1},
94 {"lset",lsetCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
95 {"lrange",lrangeCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
96 {"ltrim",ltrimCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
97 {"lrem",lremCommand,4,REDIS_CMD_BULK,NULL,1,1,1},
98 {"rpoplpush",rpoplpushcommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,2,1},
99 {"sadd",saddCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
100 {"srem",sremCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
101 {"smove",smoveCommand,4,REDIS_CMD_BULK,NULL,1,2,1},
102 {"sismember",sismemberCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
103 {"scard",scardCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
104 {"spop",spopCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
105 {"srandmember",srandmemberCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
106 {"sinter",sinterCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,-1,1},
107 {"sinterstore",sinterstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,2,-1,1},
108 {"sunion",sunionCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,-1,1},
109 {"sunionstore",sunionstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,2,-1,1},
110 {"sdiff",sdiffCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,-1,1},
111 {"sdiffstore",sdiffstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,2,-1,1},
112 {"smembers",sinterCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
113 {"zadd",zaddCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
114 {"zincrby",zincrbyCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
115 {"zrem",zremCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
116 {"zremrangebyscore",zremrangebyscoreCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
117 {"zremrangebyrank",zremrangebyrankCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
118 {"zunionstore",zunionstoreCommand,-4,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,zunionInterBlockClientOnSwappedKeys,0,0,0},
119 {"zinterstore",zinterstoreCommand,-4,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,zunionInterBlockClientOnSwappedKeys,0,0,0},
120 {"zrange",zrangeCommand,-4,REDIS_CMD_INLINE,NULL,1,1,1},
121 {"zrangebyscore",zrangebyscoreCommand,-4,REDIS_CMD_INLINE,NULL,1,1,1},
122 {"zcount",zcountCommand,4,REDIS_CMD_INLINE,NULL,1,1,1},
123 {"zrevrange",zrevrangeCommand,-4,REDIS_CMD_INLINE,NULL,1,1,1},
124 {"zcard",zcardCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
125 {"zscore",zscoreCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
126 {"zrank",zrankCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
127 {"zrevrank",zrevrankCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
128 {"hset",hsetCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
129 {"hsetnx",hsetnxCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
130 {"hget",hgetCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
131 {"hmset",hmsetCommand,-4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
132 {"hmget",hmgetCommand,-3,REDIS_CMD_BULK,NULL,1,1,1},
133 {"hincrby",hincrbyCommand,4,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
134 {"hdel",hdelCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
135 {"hlen",hlenCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
136 {"hkeys",hkeysCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
137 {"hvals",hvalsCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
138 {"hgetall",hgetallCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
139 {"hexists",hexistsCommand,3,REDIS_CMD_BULK,NULL,1,1,1},
140 {"incrby",incrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
141 {"decrby",decrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
142 {"getset",getsetCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,1,1},
143 {"mset",msetCommand,-3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,-1,2},
144 {"msetnx",msetnxCommand,-3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM,NULL,1,-1,2},
145 {"randomkey",randomkeyCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
146 {"select",selectCommand,2,REDIS_CMD_INLINE,NULL,0,0,0},
147 {"move",moveCommand,3,REDIS_CMD_INLINE,NULL,1,1,1},
148 {"rename",renameCommand,3,REDIS_CMD_INLINE,NULL,1,1,1},
149 {"renamenx",renamenxCommand,3,REDIS_CMD_INLINE,NULL,1,1,1},
150 {"expire",expireCommand,3,REDIS_CMD_INLINE,NULL,0,0,0},
151 {"expireat",expireatCommand,3,REDIS_CMD_INLINE,NULL,0,0,0},
152 {"keys",keysCommand,2,REDIS_CMD_INLINE,NULL,0,0,0},
153 {"dbsize",dbsizeCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
154 {"auth",authCommand,2,REDIS_CMD_INLINE,NULL,0,0,0},
155 {"ping",pingCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
156 {"echo",echoCommand,2,REDIS_CMD_BULK,NULL,0,0,0},
157 {"save",saveCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
158 {"bgsave",bgsaveCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
159 {"bgrewriteaof",bgrewriteaofCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
160 {"shutdown",shutdownCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
161 {"lastsave",lastsaveCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
162 {"type",typeCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
163 {"multi",multiCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
164 {"exec",execCommand,1,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,execBlockClientOnSwappedKeys,0,0,0},
165 {"discard",discardCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
166 {"sync",syncCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
167 {"flushdb",flushdbCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
168 {"flushall",flushallCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
169 {"sort",sortCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,NULL,1,1,1},
170 {"info",infoCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
171 {"monitor",monitorCommand,1,REDIS_CMD_INLINE,NULL,0,0,0},
172 {"ttl",ttlCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
a539d29a 173 {"persist",persistCommand,2,REDIS_CMD_INLINE,NULL,1,1,1},
e2641e09 174 {"slaveof",slaveofCommand,3,REDIS_CMD_INLINE,NULL,0,0,0},
175 {"debug",debugCommand,-2,REDIS_CMD_INLINE,NULL,0,0,0},
176 {"config",configCommand,-2,REDIS_CMD_BULK,NULL,0,0,0},
177 {"subscribe",subscribeCommand,-2,REDIS_CMD_INLINE,NULL,0,0,0},
178 {"unsubscribe",unsubscribeCommand,-1,REDIS_CMD_INLINE,NULL,0,0,0},
179 {"psubscribe",psubscribeCommand,-2,REDIS_CMD_INLINE,NULL,0,0,0},
180 {"punsubscribe",punsubscribeCommand,-1,REDIS_CMD_INLINE,NULL,0,0,0},
181 {"publish",publishCommand,3,REDIS_CMD_BULK|REDIS_CMD_FORCE_REPLICATION,NULL,0,0,0},
182 {"watch",watchCommand,-2,REDIS_CMD_INLINE,NULL,0,0,0},
183 {"unwatch",unwatchCommand,1,REDIS_CMD_INLINE,NULL,0,0,0}
184};
185
186/*============================ Utility functions ============================ */
187
188void redisLog(int level, const char *fmt, ...) {
189 va_list ap;
190 FILE *fp;
23072961 191 char *c = ".-*#";
192 char buf[64];
193 time_t now;
194
195 if (level < server.verbosity) return;
e2641e09 196
197 fp = (server.logfile == NULL) ? stdout : fopen(server.logfile,"a");
198 if (!fp) return;
199
200 va_start(ap, fmt);
23072961 201 now = time(NULL);
202 strftime(buf,64,"%d %b %H:%M:%S",localtime(&now));
203 fprintf(fp,"[%d] %s %c ",(int)getpid(),buf,c[level]);
204 vfprintf(fp, fmt, ap);
205 fprintf(fp,"\n");
206 fflush(fp);
e2641e09 207 va_end(ap);
208
209 if (server.logfile) fclose(fp);
210}
211
212/* Redis generally does not try to recover from out of memory conditions
213 * when allocating objects or strings, it is not clear if it will be possible
214 * to report this condition to the client since the networking layer itself
215 * is based on heap allocation for send buffers, so we simply abort.
216 * At least the code will be simpler to read... */
217void oom(const char *msg) {
218 redisLog(REDIS_WARNING, "%s: Out of memory\n",msg);
219 sleep(1);
220 abort();
221}
222
223/*====================== Hash table type implementation ==================== */
224
225/* This is an hash table type that uses the SDS dynamic strings libary as
226 * keys and radis objects as values (objects can hold SDS strings,
227 * lists, sets). */
228
229void dictVanillaFree(void *privdata, void *val)
230{
231 DICT_NOTUSED(privdata);
232 zfree(val);
233}
234
235void dictListDestructor(void *privdata, void *val)
236{
237 DICT_NOTUSED(privdata);
238 listRelease((list*)val);
239}
240
241int dictSdsKeyCompare(void *privdata, const void *key1,
242 const void *key2)
243{
244 int l1,l2;
245 DICT_NOTUSED(privdata);
246
247 l1 = sdslen((sds)key1);
248 l2 = sdslen((sds)key2);
249 if (l1 != l2) return 0;
250 return memcmp(key1, key2, l1) == 0;
251}
252
253void dictRedisObjectDestructor(void *privdata, void *val)
254{
255 DICT_NOTUSED(privdata);
256
257 if (val == NULL) return; /* Values of swapped out keys as set to NULL */
258 decrRefCount(val);
259}
260
261void dictSdsDestructor(void *privdata, void *val)
262{
263 DICT_NOTUSED(privdata);
264
265 sdsfree(val);
266}
267
268int dictObjKeyCompare(void *privdata, const void *key1,
269 const void *key2)
270{
271 const robj *o1 = key1, *o2 = key2;
272 return dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
273}
274
275unsigned int dictObjHash(const void *key) {
276 const robj *o = key;
277 return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
278}
279
280unsigned int dictSdsHash(const void *key) {
281 return dictGenHashFunction((unsigned char*)key, sdslen((char*)key));
282}
283
284int dictEncObjKeyCompare(void *privdata, const void *key1,
285 const void *key2)
286{
287 robj *o1 = (robj*) key1, *o2 = (robj*) key2;
288 int cmp;
289
290 if (o1->encoding == REDIS_ENCODING_INT &&
291 o2->encoding == REDIS_ENCODING_INT)
292 return o1->ptr == o2->ptr;
293
294 o1 = getDecodedObject(o1);
295 o2 = getDecodedObject(o2);
296 cmp = dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
297 decrRefCount(o1);
298 decrRefCount(o2);
299 return cmp;
300}
301
302unsigned int dictEncObjHash(const void *key) {
303 robj *o = (robj*) key;
304
305 if (o->encoding == REDIS_ENCODING_RAW) {
306 return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
307 } else {
308 if (o->encoding == REDIS_ENCODING_INT) {
309 char buf[32];
310 int len;
311
312 len = ll2string(buf,32,(long)o->ptr);
313 return dictGenHashFunction((unsigned char*)buf, len);
314 } else {
315 unsigned int hash;
316
317 o = getDecodedObject(o);
318 hash = dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
319 decrRefCount(o);
320 return hash;
321 }
322 }
323}
324
325/* Sets type */
326dictType setDictType = {
327 dictEncObjHash, /* hash function */
328 NULL, /* key dup */
329 NULL, /* val dup */
330 dictEncObjKeyCompare, /* key compare */
331 dictRedisObjectDestructor, /* key destructor */
332 NULL /* val destructor */
333};
334
335/* Sorted sets hash (note: a skiplist is used in addition to the hash table) */
336dictType zsetDictType = {
337 dictEncObjHash, /* hash function */
338 NULL, /* key dup */
339 NULL, /* val dup */
340 dictEncObjKeyCompare, /* key compare */
341 dictRedisObjectDestructor, /* key destructor */
342 dictVanillaFree /* val destructor of malloc(sizeof(double)) */
343};
344
345/* Db->dict, keys are sds strings, vals are Redis objects. */
346dictType dbDictType = {
347 dictSdsHash, /* hash function */
348 NULL, /* key dup */
349 NULL, /* val dup */
350 dictSdsKeyCompare, /* key compare */
351 dictSdsDestructor, /* key destructor */
352 dictRedisObjectDestructor /* val destructor */
353};
354
355/* Db->expires */
356dictType keyptrDictType = {
357 dictSdsHash, /* hash function */
358 NULL, /* key dup */
359 NULL, /* val dup */
360 dictSdsKeyCompare, /* key compare */
361 NULL, /* key destructor */
362 NULL /* val destructor */
363};
364
365/* Hash type hash table (note that small hashes are represented with zimpaps) */
366dictType hashDictType = {
367 dictEncObjHash, /* hash function */
368 NULL, /* key dup */
369 NULL, /* val dup */
370 dictEncObjKeyCompare, /* key compare */
371 dictRedisObjectDestructor, /* key destructor */
372 dictRedisObjectDestructor /* val destructor */
373};
374
375/* Keylist hash table type has unencoded redis objects as keys and
376 * lists as values. It's used for blocking operations (BLPOP) and to
377 * map swapped keys to a list of clients waiting for this keys to be loaded. */
378dictType keylistDictType = {
379 dictObjHash, /* hash function */
380 NULL, /* key dup */
381 NULL, /* val dup */
382 dictObjKeyCompare, /* key compare */
383 dictRedisObjectDestructor, /* key destructor */
384 dictListDestructor /* val destructor */
385};
386
387int htNeedsResize(dict *dict) {
388 long long size, used;
389
390 size = dictSlots(dict);
391 used = dictSize(dict);
392 return (size && used && size > DICT_HT_INITIAL_SIZE &&
393 (used*100/size < REDIS_HT_MINFILL));
394}
395
396/* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
397 * we resize the hash table to save memory */
398void tryResizeHashTables(void) {
399 int j;
400
401 for (j = 0; j < server.dbnum; j++) {
402 if (htNeedsResize(server.db[j].dict))
403 dictResize(server.db[j].dict);
404 if (htNeedsResize(server.db[j].expires))
405 dictResize(server.db[j].expires);
406 }
407}
408
409/* Our hash table implementation performs rehashing incrementally while
410 * we write/read from the hash table. Still if the server is idle, the hash
411 * table will use two tables for a long time. So we try to use 1 millisecond
412 * of CPU time at every serverCron() loop in order to rehash some key. */
413void incrementallyRehash(void) {
414 int j;
415
416 for (j = 0; j < server.dbnum; j++) {
417 if (dictIsRehashing(server.db[j].dict)) {
418 dictRehashMilliseconds(server.db[j].dict,1);
419 break; /* already used our millisecond for this loop... */
420 }
421 }
422}
423
424/* This function is called once a background process of some kind terminates,
425 * as we want to avoid resizing the hash tables when there is a child in order
426 * to play well with copy-on-write (otherwise when a resize happens lots of
427 * memory pages are copied). The goal of this function is to update the ability
428 * for dict.c to resize the hash tables accordingly to the fact we have o not
429 * running childs. */
430void updateDictResizePolicy(void) {
431 if (server.bgsavechildpid == -1 && server.bgrewritechildpid == -1)
432 dictEnableResize();
433 else
434 dictDisableResize();
435}
436
437/* ======================= Cron: called every 100 ms ======================== */
438
bcf2995c 439/* Try to expire a few timed out keys. The algorithm used is adaptive and
440 * will use few CPU cycles if there are few expiring keys, otherwise
441 * it will get more aggressive to avoid that too much memory is used by
442 * keys that can be removed from the keyspace. */
443void activeExpireCycle(void) {
444 int j;
445
446 for (j = 0; j < server.dbnum; j++) {
447 int expired;
448 redisDb *db = server.db+j;
449
450 /* Continue to expire if at the end of the cycle more than 25%
451 * of the keys were expired. */
452 do {
453 long num = dictSize(db->expires);
454 time_t now = time(NULL);
455
456 expired = 0;
457 if (num > REDIS_EXPIRELOOKUPS_PER_CRON)
458 num = REDIS_EXPIRELOOKUPS_PER_CRON;
459 while (num--) {
460 dictEntry *de;
461 time_t t;
462
463 if ((de = dictGetRandomKey(db->expires)) == NULL) break;
464 t = (time_t) dictGetEntryVal(de);
465 if (now > t) {
466 sds key = dictGetEntryKey(de);
467 robj *keyobj = createStringObject(key,sdslen(key));
468
469 propagateExpire(db,keyobj);
470 dbDelete(db,keyobj);
471 decrRefCount(keyobj);
472 expired++;
473 server.stat_expiredkeys++;
474 }
475 }
476 } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4);
477 }
478}
479
480
e2641e09 481int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
482 int j, loops = server.cronloops++;
483 REDIS_NOTUSED(eventLoop);
484 REDIS_NOTUSED(id);
485 REDIS_NOTUSED(clientData);
486
487 /* We take a cached value of the unix time in the global state because
488 * with virtual memory and aging there is to store the current time
489 * in objects at every object access, and accuracy is not needed.
490 * To access a global var is faster than calling time(NULL) */
491 server.unixtime = time(NULL);
492 /* We have just 21 bits per object for LRU information.
493 * So we use an (eventually wrapping) LRU clock with minutes resolution.
494 *
495 * When we need to select what object to swap, we compute the minimum
496 * time distance between the current lruclock and the object last access
497 * lruclock info. Even if clocks will wrap on overflow, there is
498 * the interesting property that we are sure that at least
499 * ABS(A-B) minutes passed between current time and timestamp B.
500 *
501 * This is not precise but we don't need at all precision, but just
502 * something statistically reasonable.
503 */
504 server.lruclock = (time(NULL)/60)&((1<<21)-1);
505
506 /* We received a SIGTERM, shutting down here in a safe way, as it is
507 * not ok doing so inside the signal handler. */
508 if (server.shutdown_asap) {
509 if (prepareForShutdown() == REDIS_OK) exit(0);
510 redisLog(REDIS_WARNING,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
511 }
512
513 /* Show some info about non-empty databases */
514 for (j = 0; j < server.dbnum; j++) {
515 long long size, used, vkeys;
516
517 size = dictSlots(server.db[j].dict);
518 used = dictSize(server.db[j].dict);
519 vkeys = dictSize(server.db[j].expires);
520 if (!(loops % 50) && (used || vkeys)) {
521 redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
522 /* dictPrintStats(server.dict); */
523 }
524 }
525
526 /* We don't want to resize the hash tables while a bacground saving
527 * is in progress: the saving child is created using fork() that is
528 * implemented with a copy-on-write semantic in most modern systems, so
529 * if we resize the HT while there is the saving child at work actually
530 * a lot of memory movements in the parent will cause a lot of pages
531 * copied. */
532 if (server.bgsavechildpid == -1 && server.bgrewritechildpid == -1) {
533 if (!(loops % 10)) tryResizeHashTables();
534 if (server.activerehashing) incrementallyRehash();
535 }
536
537 /* Show information about connected clients */
538 if (!(loops % 50)) {
539 redisLog(REDIS_VERBOSE,"%d clients connected (%d slaves), %zu bytes in use",
540 listLength(server.clients)-listLength(server.slaves),
541 listLength(server.slaves),
542 zmalloc_used_memory());
543 }
544
545 /* Close connections of timedout clients */
546 if ((server.maxidletime && !(loops % 100)) || server.blpop_blocked_clients)
547 closeTimedoutClients();
548
549 /* Check if a background saving or AOF rewrite in progress terminated */
550 if (server.bgsavechildpid != -1 || server.bgrewritechildpid != -1) {
551 int statloc;
552 pid_t pid;
553
554 if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
555 if (pid == server.bgsavechildpid) {
556 backgroundSaveDoneHandler(statloc);
557 } else {
558 backgroundRewriteDoneHandler(statloc);
559 }
560 updateDictResizePolicy();
561 }
562 } else {
563 /* If there is not a background saving in progress check if
564 * we have to save now */
565 time_t now = time(NULL);
566 for (j = 0; j < server.saveparamslen; j++) {
567 struct saveparam *sp = server.saveparams+j;
568
569 if (server.dirty >= sp->changes &&
570 now-server.lastsave > sp->seconds) {
571 redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
572 sp->changes, sp->seconds);
573 rdbSaveBackground(server.dbfilename);
574 break;
575 }
576 }
577 }
578
bcf2995c 579 /* Expire a few keys per cycle, only if this is a master.
580 * On slaves we wait for DEL operations synthesized by the master
581 * in order to guarantee a strict consistency. */
582 if (server.masterhost == NULL) activeExpireCycle();
e2641e09 583
584 /* Swap a few keys on disk if we are over the memory limit and VM
585 * is enbled. Try to free objects from the free list first. */
586 if (vmCanSwapOut()) {
587 while (server.vm_enabled && zmalloc_used_memory() >
588 server.vm_max_memory)
589 {
590 int retval;
591
592 if (tryFreeOneObjectFromFreelist() == REDIS_OK) continue;
593 retval = (server.vm_max_threads == 0) ?
594 vmSwapOneObjectBlocking() :
595 vmSwapOneObjectThreaded();
596 if (retval == REDIS_ERR && !(loops % 300) &&
597 zmalloc_used_memory() >
598 (server.vm_max_memory+server.vm_max_memory/10))
599 {
600 redisLog(REDIS_WARNING,"WARNING: vm-max-memory limit exceeded by more than 10%% but unable to swap more objects out!");
601 }
602 /* Note that when using threade I/O we free just one object,
603 * because anyway when the I/O thread in charge to swap this
604 * object out will finish, the handler of completed jobs
605 * will try to swap more objects if we are still out of memory. */
606 if (retval == REDIS_ERR || server.vm_max_threads > 0) break;
607 }
608 }
609
610 /* Check if we should connect to a MASTER */
611 if (server.replstate == REDIS_REPL_CONNECT && !(loops % 10)) {
612 redisLog(REDIS_NOTICE,"Connecting to MASTER...");
613 if (syncWithMaster() == REDIS_OK) {
614 redisLog(REDIS_NOTICE,"MASTER <-> SLAVE sync succeeded");
615 if (server.appendonly) rewriteAppendOnlyFileBackground();
616 }
617 }
618 return 100;
619}
620
621/* This function gets called every time Redis is entering the
622 * main loop of the event driven library, that is, before to sleep
623 * for ready file descriptors. */
624void beforeSleep(struct aeEventLoop *eventLoop) {
625 REDIS_NOTUSED(eventLoop);
626
627 /* Awake clients that got all the swapped keys they requested */
628 if (server.vm_enabled && listLength(server.io_ready_clients)) {
629 listIter li;
630 listNode *ln;
631
632 listRewind(server.io_ready_clients,&li);
633 while((ln = listNext(&li))) {
634 redisClient *c = ln->value;
635 struct redisCommand *cmd;
636
637 /* Resume the client. */
638 listDelNode(server.io_ready_clients,ln);
639 c->flags &= (~REDIS_IO_WAIT);
640 server.vm_blocked_clients--;
641 aeCreateFileEvent(server.el, c->fd, AE_READABLE,
642 readQueryFromClient, c);
643 cmd = lookupCommand(c->argv[0]->ptr);
644 redisAssert(cmd != NULL);
645 call(c,cmd);
646 resetClient(c);
647 /* There may be more data to process in the input buffer. */
648 if (c->querybuf && sdslen(c->querybuf) > 0)
649 processInputBuffer(c);
650 }
651 }
652 /* Write the AOF buffer on disk */
653 flushAppendOnlyFile();
654}
655
656/* =========================== Server initialization ======================== */
657
658void createSharedObjects(void) {
659 int j;
660
661 shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
662 shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
663 shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
664 shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
665 shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
666 shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
667 shared.cnegone = createObject(REDIS_STRING,sdsnew(":-1\r\n"));
668 shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
669 shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
670 shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
671 shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
672 shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n"));
673 shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
674 "-ERR Operation against a key holding the wrong kind of value\r\n"));
675 shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
676 "-ERR no such key\r\n"));
677 shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
678 "-ERR syntax error\r\n"));
679 shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
680 "-ERR source and destination objects are the same\r\n"));
681 shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
682 "-ERR index out of range\r\n"));
683 shared.space = createObject(REDIS_STRING,sdsnew(" "));
684 shared.colon = createObject(REDIS_STRING,sdsnew(":"));
685 shared.plus = createObject(REDIS_STRING,sdsnew("+"));
686 shared.select0 = createStringObject("select 0\r\n",10);
687 shared.select1 = createStringObject("select 1\r\n",10);
688 shared.select2 = createStringObject("select 2\r\n",10);
689 shared.select3 = createStringObject("select 3\r\n",10);
690 shared.select4 = createStringObject("select 4\r\n",10);
691 shared.select5 = createStringObject("select 5\r\n",10);
692 shared.select6 = createStringObject("select 6\r\n",10);
693 shared.select7 = createStringObject("select 7\r\n",10);
694 shared.select8 = createStringObject("select 8\r\n",10);
695 shared.select9 = createStringObject("select 9\r\n",10);
696 shared.messagebulk = createStringObject("$7\r\nmessage\r\n",13);
697 shared.pmessagebulk = createStringObject("$8\r\npmessage\r\n",14);
698 shared.subscribebulk = createStringObject("$9\r\nsubscribe\r\n",15);
699 shared.unsubscribebulk = createStringObject("$11\r\nunsubscribe\r\n",18);
700 shared.psubscribebulk = createStringObject("$10\r\npsubscribe\r\n",17);
701 shared.punsubscribebulk = createStringObject("$12\r\npunsubscribe\r\n",19);
702 shared.mbulk3 = createStringObject("*3\r\n",4);
703 shared.mbulk4 = createStringObject("*4\r\n",4);
704 for (j = 0; j < REDIS_SHARED_INTEGERS; j++) {
705 shared.integers[j] = createObject(REDIS_STRING,(void*)(long)j);
706 shared.integers[j]->encoding = REDIS_ENCODING_INT;
707 }
708}
709
710void initServerConfig() {
711 server.dbnum = REDIS_DEFAULT_DBNUM;
712 server.port = REDIS_SERVERPORT;
713 server.verbosity = REDIS_VERBOSE;
714 server.maxidletime = REDIS_MAXIDLETIME;
715 server.saveparams = NULL;
716 server.logfile = NULL; /* NULL = log on standard output */
717 server.bindaddr = NULL;
718 server.glueoutputbuf = 1;
719 server.daemonize = 0;
720 server.appendonly = 0;
721 server.appendfsync = APPENDFSYNC_EVERYSEC;
722 server.no_appendfsync_on_rewrite = 0;
723 server.lastfsync = time(NULL);
724 server.appendfd = -1;
725 server.appendseldb = -1; /* Make sure the first time will not match */
726 server.pidfile = zstrdup("/var/run/redis.pid");
727 server.dbfilename = zstrdup("dump.rdb");
728 server.appendfilename = zstrdup("appendonly.aof");
729 server.requirepass = NULL;
730 server.rdbcompression = 1;
731 server.activerehashing = 1;
732 server.maxclients = 0;
733 server.blpop_blocked_clients = 0;
734 server.maxmemory = 0;
735 server.vm_enabled = 0;
736 server.vm_swap_file = zstrdup("/tmp/redis-%p.vm");
737 server.vm_page_size = 256; /* 256 bytes per page */
738 server.vm_pages = 1024*1024*100; /* 104 millions of pages */
739 server.vm_max_memory = 1024LL*1024*1024*1; /* 1 GB of RAM */
740 server.vm_max_threads = 4;
741 server.vm_blocked_clients = 0;
742 server.hash_max_zipmap_entries = REDIS_HASH_MAX_ZIPMAP_ENTRIES;
743 server.hash_max_zipmap_value = REDIS_HASH_MAX_ZIPMAP_VALUE;
744 server.list_max_ziplist_entries = REDIS_LIST_MAX_ZIPLIST_ENTRIES;
745 server.list_max_ziplist_value = REDIS_LIST_MAX_ZIPLIST_VALUE;
746 server.shutdown_asap = 0;
747
748 resetServerSaveParams();
749
750 appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
751 appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
752 appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
753 /* Replication related */
754 server.isslave = 0;
755 server.masterauth = NULL;
756 server.masterhost = NULL;
757 server.masterport = 6379;
758 server.master = NULL;
759 server.replstate = REDIS_REPL_NONE;
760
761 /* Double constants initialization */
762 R_Zero = 0.0;
763 R_PosInf = 1.0/R_Zero;
764 R_NegInf = -1.0/R_Zero;
765 R_Nan = R_Zero/R_Zero;
766}
767
768void initServer() {
769 int j;
770
771 signal(SIGHUP, SIG_IGN);
772 signal(SIGPIPE, SIG_IGN);
773 setupSigSegvAction();
774
0e5441d8 775 server.mainthread = pthread_self();
e2641e09 776 server.devnull = fopen("/dev/null","w");
777 if (server.devnull == NULL) {
778 redisLog(REDIS_WARNING, "Can't open /dev/null: %s", server.neterr);
779 exit(1);
780 }
781 server.clients = listCreate();
782 server.slaves = listCreate();
783 server.monitors = listCreate();
784 server.objfreelist = listCreate();
785 createSharedObjects();
786 server.el = aeCreateEventLoop();
787 server.db = zmalloc(sizeof(redisDb)*server.dbnum);
788 server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr);
789 if (server.fd == -1) {
790 redisLog(REDIS_WARNING, "Opening TCP port: %s", server.neterr);
791 exit(1);
792 }
793 for (j = 0; j < server.dbnum; j++) {
794 server.db[j].dict = dictCreate(&dbDictType,NULL);
795 server.db[j].expires = dictCreate(&keyptrDictType,NULL);
796 server.db[j].blocking_keys = dictCreate(&keylistDictType,NULL);
797 server.db[j].watched_keys = dictCreate(&keylistDictType,NULL);
798 if (server.vm_enabled)
799 server.db[j].io_keys = dictCreate(&keylistDictType,NULL);
800 server.db[j].id = j;
801 }
802 server.pubsub_channels = dictCreate(&keylistDictType,NULL);
803 server.pubsub_patterns = listCreate();
804 listSetFreeMethod(server.pubsub_patterns,freePubsubPattern);
805 listSetMatchMethod(server.pubsub_patterns,listMatchPubsubPattern);
806 server.cronloops = 0;
807 server.bgsavechildpid = -1;
808 server.bgrewritechildpid = -1;
809 server.bgrewritebuf = sdsempty();
810 server.aofbuf = sdsempty();
811 server.lastsave = time(NULL);
812 server.dirty = 0;
813 server.stat_numcommands = 0;
814 server.stat_numconnections = 0;
815 server.stat_expiredkeys = 0;
816 server.stat_starttime = time(NULL);
817 server.unixtime = time(NULL);
818 aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL);
819 if (aeCreateFileEvent(server.el, server.fd, AE_READABLE,
820 acceptHandler, NULL) == AE_ERR) oom("creating file event");
821
822 if (server.appendonly) {
823 server.appendfd = open(server.appendfilename,O_WRONLY|O_APPEND|O_CREAT,0644);
824 if (server.appendfd == -1) {
825 redisLog(REDIS_WARNING, "Can't open the append-only file: %s",
826 strerror(errno));
827 exit(1);
828 }
829 }
830
831 if (server.vm_enabled) vmInit();
832}
833
834int qsortRedisCommands(const void *r1, const void *r2) {
835 return strcasecmp(
836 ((struct redisCommand*)r1)->name,
837 ((struct redisCommand*)r2)->name);
838}
839
840void sortCommandTable() {
841 /* Copy and sort the read-only version of the command table */
b3aa6d71 842 commandTable = (struct redisCommand*)zmalloc(sizeof(readonlyCommandTable));
e2641e09 843 memcpy(commandTable,readonlyCommandTable,sizeof(readonlyCommandTable));
844 qsort(commandTable,
845 sizeof(readonlyCommandTable)/sizeof(struct redisCommand),
846 sizeof(struct redisCommand),qsortRedisCommands);
847}
848
849/* ====================== Commands lookup and execution ===================== */
850
851struct redisCommand *lookupCommand(char *name) {
852 struct redisCommand tmp = {name,NULL,0,0,NULL,0,0,0};
853 return bsearch(
854 &tmp,
855 commandTable,
856 sizeof(readonlyCommandTable)/sizeof(struct redisCommand),
857 sizeof(struct redisCommand),
858 qsortRedisCommands);
859}
860
861/* Call() is the core of Redis execution of a command */
862void call(redisClient *c, struct redisCommand *cmd) {
863 long long dirty;
864
865 dirty = server.dirty;
866 cmd->proc(c);
867 dirty = server.dirty-dirty;
868
869 if (server.appendonly && dirty)
870 feedAppendOnlyFile(cmd,c->db->id,c->argv,c->argc);
871 if ((dirty || cmd->flags & REDIS_CMD_FORCE_REPLICATION) &&
872 listLength(server.slaves))
873 replicationFeedSlaves(server.slaves,c->db->id,c->argv,c->argc);
874 if (listLength(server.monitors))
875 replicationFeedMonitors(server.monitors,c->db->id,c->argv,c->argc);
876 server.stat_numcommands++;
877}
878
879/* If this function gets called we already read a whole
880 * command, argments are in the client argv/argc fields.
881 * processCommand() execute the command or prepare the
882 * server for a bulk read from the client.
883 *
884 * If 1 is returned the client is still alive and valid and
885 * and other operations can be performed by the caller. Otherwise
886 * if 0 is returned the client was destroied (i.e. after QUIT). */
887int processCommand(redisClient *c) {
888 struct redisCommand *cmd;
889
890 /* Free some memory if needed (maxmemory setting) */
891 if (server.maxmemory) freeMemoryIfNeeded();
892
893 /* Handle the multi bulk command type. This is an alternative protocol
894 * supported by Redis in order to receive commands that are composed of
895 * multiple binary-safe "bulk" arguments. The latency of processing is
896 * a bit higher but this allows things like multi-sets, so if this
897 * protocol is used only for MSET and similar commands this is a big win. */
898 if (c->multibulk == 0 && c->argc == 1 && ((char*)(c->argv[0]->ptr))[0] == '*') {
899 c->multibulk = atoi(((char*)c->argv[0]->ptr)+1);
900 if (c->multibulk <= 0) {
901 resetClient(c);
902 return 1;
903 } else {
904 decrRefCount(c->argv[c->argc-1]);
905 c->argc--;
906 return 1;
907 }
908 } else if (c->multibulk) {
909 if (c->bulklen == -1) {
910 if (((char*)c->argv[0]->ptr)[0] != '$') {
911 addReplySds(c,sdsnew("-ERR multi bulk protocol error\r\n"));
912 resetClient(c);
913 return 1;
914 } else {
915 int bulklen = atoi(((char*)c->argv[0]->ptr)+1);
916 decrRefCount(c->argv[0]);
917 if (bulklen < 0 || bulklen > 1024*1024*1024) {
918 c->argc--;
919 addReplySds(c,sdsnew("-ERR invalid bulk write count\r\n"));
920 resetClient(c);
921 return 1;
922 }
923 c->argc--;
924 c->bulklen = bulklen+2; /* add two bytes for CR+LF */
925 return 1;
926 }
927 } else {
928 c->mbargv = zrealloc(c->mbargv,(sizeof(robj*))*(c->mbargc+1));
929 c->mbargv[c->mbargc] = c->argv[0];
930 c->mbargc++;
931 c->argc--;
932 c->multibulk--;
933 if (c->multibulk == 0) {
934 robj **auxargv;
935 int auxargc;
936
937 /* Here we need to swap the multi-bulk argc/argv with the
938 * normal argc/argv of the client structure. */
939 auxargv = c->argv;
940 c->argv = c->mbargv;
941 c->mbargv = auxargv;
942
943 auxargc = c->argc;
944 c->argc = c->mbargc;
945 c->mbargc = auxargc;
946
947 /* We need to set bulklen to something different than -1
948 * in order for the code below to process the command without
949 * to try to read the last argument of a bulk command as
950 * a special argument. */
951 c->bulklen = 0;
952 /* continue below and process the command */
953 } else {
954 c->bulklen = -1;
955 return 1;
956 }
957 }
958 }
959 /* -- end of multi bulk commands processing -- */
960
961 /* The QUIT command is handled as a special case. Normal command
962 * procs are unable to close the client connection safely */
963 if (!strcasecmp(c->argv[0]->ptr,"quit")) {
964 freeClient(c);
965 return 0;
966 }
967
968 /* Now lookup the command and check ASAP about trivial error conditions
969 * such wrong arity, bad command name and so forth. */
970 cmd = lookupCommand(c->argv[0]->ptr);
971 if (!cmd) {
972 addReplySds(c,
973 sdscatprintf(sdsempty(), "-ERR unknown command '%s'\r\n",
974 (char*)c->argv[0]->ptr));
975 resetClient(c);
976 return 1;
977 } else if ((cmd->arity > 0 && cmd->arity != c->argc) ||
978 (c->argc < -cmd->arity)) {
979 addReplySds(c,
980 sdscatprintf(sdsempty(),
981 "-ERR wrong number of arguments for '%s' command\r\n",
982 cmd->name));
983 resetClient(c);
984 return 1;
985 } else if (cmd->flags & REDIS_CMD_BULK && c->bulklen == -1) {
986 /* This is a bulk command, we have to read the last argument yet. */
987 int bulklen = atoi(c->argv[c->argc-1]->ptr);
988
989 decrRefCount(c->argv[c->argc-1]);
990 if (bulklen < 0 || bulklen > 1024*1024*1024) {
991 c->argc--;
992 addReplySds(c,sdsnew("-ERR invalid bulk write count\r\n"));
993 resetClient(c);
994 return 1;
995 }
996 c->argc--;
997 c->bulklen = bulklen+2; /* add two bytes for CR+LF */
998 /* It is possible that the bulk read is already in the
999 * buffer. Check this condition and handle it accordingly.
1000 * This is just a fast path, alternative to call processInputBuffer().
1001 * It's a good idea since the code is small and this condition
1002 * happens most of the times. */
1003 if ((signed)sdslen(c->querybuf) >= c->bulklen) {
1004 c->argv[c->argc] = createStringObject(c->querybuf,c->bulklen-2);
1005 c->argc++;
1006 c->querybuf = sdsrange(c->querybuf,c->bulklen,-1);
1007 } else {
1008 /* Otherwise return... there is to read the last argument
1009 * from the socket. */
1010 return 1;
1011 }
1012 }
1013 /* Let's try to encode the bulk object to save space. */
1014 if (cmd->flags & REDIS_CMD_BULK)
1015 c->argv[c->argc-1] = tryObjectEncoding(c->argv[c->argc-1]);
1016
1017 /* Check if the user is authenticated */
1018 if (server.requirepass && !c->authenticated && cmd->proc != authCommand) {
1019 addReplySds(c,sdsnew("-ERR operation not permitted\r\n"));
1020 resetClient(c);
1021 return 1;
1022 }
1023
1024 /* Handle the maxmemory directive */
1025 if (server.maxmemory && (cmd->flags & REDIS_CMD_DENYOOM) &&
1026 zmalloc_used_memory() > server.maxmemory)
1027 {
1028 addReplySds(c,sdsnew("-ERR command not allowed when used memory > 'maxmemory'\r\n"));
1029 resetClient(c);
1030 return 1;
1031 }
1032
1033 /* Only allow SUBSCRIBE and UNSUBSCRIBE in the context of Pub/Sub */
1034 if ((dictSize(c->pubsub_channels) > 0 || listLength(c->pubsub_patterns) > 0)
1035 &&
1036 cmd->proc != subscribeCommand && cmd->proc != unsubscribeCommand &&
1037 cmd->proc != psubscribeCommand && cmd->proc != punsubscribeCommand) {
1038 addReplySds(c,sdsnew("-ERR only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context\r\n"));
1039 resetClient(c);
1040 return 1;
1041 }
1042
1043 /* Exec the command */
1044 if (c->flags & REDIS_MULTI &&
1045 cmd->proc != execCommand && cmd->proc != discardCommand &&
1046 cmd->proc != multiCommand && cmd->proc != watchCommand)
1047 {
1048 queueMultiCommand(c,cmd);
1049 addReply(c,shared.queued);
1050 } else {
1051 if (server.vm_enabled && server.vm_max_threads > 0 &&
1052 blockClientOnSwappedKeys(c,cmd)) return 1;
1053 call(c,cmd);
1054 }
1055
1056 /* Prepare the client for the next command */
1057 resetClient(c);
1058 return 1;
1059}
1060
1061/*================================== Shutdown =============================== */
1062
1063int prepareForShutdown() {
1064 redisLog(REDIS_WARNING,"User requested shutdown, saving DB...");
1065 /* Kill the saving child if there is a background saving in progress.
1066 We want to avoid race conditions, for instance our saving child may
1067 overwrite the synchronous saving did by SHUTDOWN. */
1068 if (server.bgsavechildpid != -1) {
1069 redisLog(REDIS_WARNING,"There is a live saving child. Killing it!");
1070 kill(server.bgsavechildpid,SIGKILL);
1071 rdbRemoveTempFile(server.bgsavechildpid);
1072 }
1073 if (server.appendonly) {
1074 /* Append only file: fsync() the AOF and exit */
1075 aof_fsync(server.appendfd);
1076 if (server.vm_enabled) unlink(server.vm_swap_file);
1077 } else {
1078 /* Snapshotting. Perform a SYNC SAVE and exit */
1079 if (rdbSave(server.dbfilename) == REDIS_OK) {
1080 if (server.daemonize)
1081 unlink(server.pidfile);
1082 redisLog(REDIS_WARNING,"%zu bytes used at exit",zmalloc_used_memory());
1083 } else {
1084 /* Ooops.. error saving! The best we can do is to continue
1085 * operating. Note that if there was a background saving process,
1086 * in the next cron() Redis will be notified that the background
1087 * saving aborted, handling special stuff like slaves pending for
1088 * synchronization... */
1089 redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit");
1090 return REDIS_ERR;
1091 }
1092 }
1093 redisLog(REDIS_WARNING,"Server exit now, bye bye...");
1094 return REDIS_OK;
1095}
1096
1097/*================================== Commands =============================== */
1098
1099void authCommand(redisClient *c) {
1100 if (!server.requirepass || !strcmp(c->argv[1]->ptr, server.requirepass)) {
1101 c->authenticated = 1;
1102 addReply(c,shared.ok);
1103 } else {
1104 c->authenticated = 0;
1105 addReplySds(c,sdscatprintf(sdsempty(),"-ERR invalid password\r\n"));
1106 }
1107}
1108
1109void pingCommand(redisClient *c) {
1110 addReply(c,shared.pong);
1111}
1112
1113void echoCommand(redisClient *c) {
1114 addReplyBulk(c,c->argv[1]);
1115}
1116
1117/* Convert an amount of bytes into a human readable string in the form
1118 * of 100B, 2G, 100M, 4K, and so forth. */
1119void bytesToHuman(char *s, unsigned long long n) {
1120 double d;
1121
1122 if (n < 1024) {
1123 /* Bytes */
1124 sprintf(s,"%lluB",n);
1125 return;
1126 } else if (n < (1024*1024)) {
1127 d = (double)n/(1024);
1128 sprintf(s,"%.2fK",d);
1129 } else if (n < (1024LL*1024*1024)) {
1130 d = (double)n/(1024*1024);
1131 sprintf(s,"%.2fM",d);
1132 } else if (n < (1024LL*1024*1024*1024)) {
1133 d = (double)n/(1024LL*1024*1024);
1134 sprintf(s,"%.2fG",d);
1135 }
1136}
1137
1138/* Create the string returned by the INFO command. This is decoupled
1139 * by the INFO command itself as we need to report the same information
1140 * on memory corruption problems. */
1141sds genRedisInfoString(void) {
1142 sds info;
1143 time_t uptime = time(NULL)-server.stat_starttime;
1144 int j;
1145 char hmem[64];
1146
1147 bytesToHuman(hmem,zmalloc_used_memory());
1148 info = sdscatprintf(sdsempty(),
1149 "redis_version:%s\r\n"
1150 "redis_git_sha1:%s\r\n"
1151 "redis_git_dirty:%d\r\n"
1152 "arch_bits:%s\r\n"
1153 "multiplexing_api:%s\r\n"
1154 "process_id:%ld\r\n"
1155 "uptime_in_seconds:%ld\r\n"
1156 "uptime_in_days:%ld\r\n"
1157 "connected_clients:%d\r\n"
1158 "connected_slaves:%d\r\n"
1159 "blocked_clients:%d\r\n"
1160 "used_memory:%zu\r\n"
1161 "used_memory_human:%s\r\n"
1162 "changes_since_last_save:%lld\r\n"
1163 "bgsave_in_progress:%d\r\n"
1164 "last_save_time:%ld\r\n"
1165 "bgrewriteaof_in_progress:%d\r\n"
1166 "total_connections_received:%lld\r\n"
1167 "total_commands_processed:%lld\r\n"
1168 "expired_keys:%lld\r\n"
1169 "hash_max_zipmap_entries:%zu\r\n"
1170 "hash_max_zipmap_value:%zu\r\n"
1171 "pubsub_channels:%ld\r\n"
1172 "pubsub_patterns:%u\r\n"
1173 "vm_enabled:%d\r\n"
1174 "role:%s\r\n"
1175 ,REDIS_VERSION,
1176 redisGitSHA1(),
1177 strtol(redisGitDirty(),NULL,10) > 0,
1178 (sizeof(long) == 8) ? "64" : "32",
1179 aeGetApiName(),
1180 (long) getpid(),
1181 uptime,
1182 uptime/(3600*24),
1183 listLength(server.clients)-listLength(server.slaves),
1184 listLength(server.slaves),
1185 server.blpop_blocked_clients,
1186 zmalloc_used_memory(),
1187 hmem,
1188 server.dirty,
1189 server.bgsavechildpid != -1,
1190 server.lastsave,
1191 server.bgrewritechildpid != -1,
1192 server.stat_numconnections,
1193 server.stat_numcommands,
1194 server.stat_expiredkeys,
1195 server.hash_max_zipmap_entries,
1196 server.hash_max_zipmap_value,
1197 dictSize(server.pubsub_channels),
1198 listLength(server.pubsub_patterns),
1199 server.vm_enabled != 0,
1200 server.masterhost == NULL ? "master" : "slave"
1201 );
1202 if (server.masterhost) {
1203 info = sdscatprintf(info,
1204 "master_host:%s\r\n"
1205 "master_port:%d\r\n"
1206 "master_link_status:%s\r\n"
1207 "master_last_io_seconds_ago:%d\r\n"
1208 ,server.masterhost,
1209 server.masterport,
1210 (server.replstate == REDIS_REPL_CONNECTED) ?
1211 "up" : "down",
1212 server.master ? ((int)(time(NULL)-server.master->lastinteraction)) : -1
1213 );
1214 }
1215 if (server.vm_enabled) {
1216 lockThreadedIO();
1217 info = sdscatprintf(info,
1218 "vm_conf_max_memory:%llu\r\n"
1219 "vm_conf_page_size:%llu\r\n"
1220 "vm_conf_pages:%llu\r\n"
1221 "vm_stats_used_pages:%llu\r\n"
1222 "vm_stats_swapped_objects:%llu\r\n"
1223 "vm_stats_swappin_count:%llu\r\n"
1224 "vm_stats_swappout_count:%llu\r\n"
1225 "vm_stats_io_newjobs_len:%lu\r\n"
1226 "vm_stats_io_processing_len:%lu\r\n"
1227 "vm_stats_io_processed_len:%lu\r\n"
1228 "vm_stats_io_active_threads:%lu\r\n"
1229 "vm_stats_blocked_clients:%lu\r\n"
1230 ,(unsigned long long) server.vm_max_memory,
1231 (unsigned long long) server.vm_page_size,
1232 (unsigned long long) server.vm_pages,
1233 (unsigned long long) server.vm_stats_used_pages,
1234 (unsigned long long) server.vm_stats_swapped_objects,
1235 (unsigned long long) server.vm_stats_swapins,
1236 (unsigned long long) server.vm_stats_swapouts,
1237 (unsigned long) listLength(server.io_newjobs),
1238 (unsigned long) listLength(server.io_processing),
1239 (unsigned long) listLength(server.io_processed),
1240 (unsigned long) server.io_active_threads,
1241 (unsigned long) server.vm_blocked_clients
1242 );
1243 unlockThreadedIO();
1244 }
1245 for (j = 0; j < server.dbnum; j++) {
1246 long long keys, vkeys;
1247
1248 keys = dictSize(server.db[j].dict);
1249 vkeys = dictSize(server.db[j].expires);
1250 if (keys || vkeys) {
1251 info = sdscatprintf(info, "db%d:keys=%lld,expires=%lld\r\n",
1252 j, keys, vkeys);
1253 }
1254 }
1255 return info;
1256}
1257
1258void infoCommand(redisClient *c) {
1259 sds info = genRedisInfoString();
1260 addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
1261 (unsigned long)sdslen(info)));
1262 addReplySds(c,info);
1263 addReply(c,shared.crlf);
1264}
1265
1266void monitorCommand(redisClient *c) {
1267 /* ignore MONITOR if aleady slave or in monitor mode */
1268 if (c->flags & REDIS_SLAVE) return;
1269
1270 c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
1271 c->slaveseldb = 0;
1272 listAddNodeTail(server.monitors,c);
1273 addReply(c,shared.ok);
1274}
1275
1276/* ============================ Maxmemory directive ======================== */
1277
1278/* Try to free one object form the pre-allocated objects free list.
1279 * This is useful under low mem conditions as by default we take 1 million
1280 * free objects allocated. On success REDIS_OK is returned, otherwise
1281 * REDIS_ERR. */
1282int tryFreeOneObjectFromFreelist(void) {
1283 robj *o;
1284
1285 if (server.vm_enabled) pthread_mutex_lock(&server.obj_freelist_mutex);
1286 if (listLength(server.objfreelist)) {
1287 listNode *head = listFirst(server.objfreelist);
1288 o = listNodeValue(head);
1289 listDelNode(server.objfreelist,head);
1290 if (server.vm_enabled) pthread_mutex_unlock(&server.obj_freelist_mutex);
1291 zfree(o);
1292 return REDIS_OK;
1293 } else {
1294 if (server.vm_enabled) pthread_mutex_unlock(&server.obj_freelist_mutex);
1295 return REDIS_ERR;
1296 }
1297}
1298
1299/* This function gets called when 'maxmemory' is set on the config file to limit
1300 * the max memory used by the server, and we are out of memory.
1301 * This function will try to, in order:
1302 *
1303 * - Free objects from the free list
1304 * - Try to remove keys with an EXPIRE set
1305 *
1306 * It is not possible to free enough memory to reach used-memory < maxmemory
1307 * the server will start refusing commands that will enlarge even more the
1308 * memory usage.
1309 */
1310void freeMemoryIfNeeded(void) {
1311 while (server.maxmemory && zmalloc_used_memory() > server.maxmemory) {
1312 int j, k, freed = 0;
1313
1314 if (tryFreeOneObjectFromFreelist() == REDIS_OK) continue;
1315 for (j = 0; j < server.dbnum; j++) {
1316 int minttl = -1;
1317 robj *minkey = NULL;
1318 struct dictEntry *de;
1319
1320 if (dictSize(server.db[j].expires)) {
1321 freed = 1;
1322 /* From a sample of three keys drop the one nearest to
1323 * the natural expire */
1324 for (k = 0; k < 3; k++) {
1325 time_t t;
1326
1327 de = dictGetRandomKey(server.db[j].expires);
1328 t = (time_t) dictGetEntryVal(de);
1329 if (minttl == -1 || t < minttl) {
1330 minkey = dictGetEntryKey(de);
1331 minttl = t;
1332 }
1333 }
1334 dbDelete(server.db+j,minkey);
1335 }
1336 }
1337 if (!freed) return; /* nothing to free... */
1338 }
1339}
1340
1341/* =================================== Main! ================================ */
1342
1343#ifdef __linux__
1344int linuxOvercommitMemoryValue(void) {
1345 FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r");
1346 char buf[64];
1347
1348 if (!fp) return -1;
1349 if (fgets(buf,64,fp) == NULL) {
1350 fclose(fp);
1351 return -1;
1352 }
1353 fclose(fp);
1354
1355 return atoi(buf);
1356}
1357
1358void linuxOvercommitMemoryWarning(void) {
1359 if (linuxOvercommitMemoryValue() == 0) {
1360 redisLog(REDIS_WARNING,"WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. 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.");
1361 }
1362}
1363#endif /* __linux__ */
1364
1365void daemonize(void) {
1366 int fd;
1367 FILE *fp;
1368
1369 if (fork() != 0) exit(0); /* parent exits */
1370 setsid(); /* create a new session */
1371
1372 /* Every output goes to /dev/null. If Redis is daemonized but
1373 * the 'logfile' is set to 'stdout' in the configuration file
1374 * it will not log at all. */
1375 if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
1376 dup2(fd, STDIN_FILENO);
1377 dup2(fd, STDOUT_FILENO);
1378 dup2(fd, STDERR_FILENO);
1379 if (fd > STDERR_FILENO) close(fd);
1380 }
1381 /* Try to write the pid file */
1382 fp = fopen(server.pidfile,"w");
1383 if (fp) {
1384 fprintf(fp,"%d\n",getpid());
1385 fclose(fp);
1386 }
1387}
1388
1389void version() {
1390 printf("Redis server version %s (%s:%d)\n", REDIS_VERSION,
1391 redisGitSHA1(), atoi(redisGitDirty()) > 0);
1392 exit(0);
1393}
1394
1395void usage() {
1396 fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n");
1397 fprintf(stderr," ./redis-server - (read config from stdin)\n");
1398 exit(1);
1399}
1400
1401int main(int argc, char **argv) {
1402 time_t start;
1403
1404 initServerConfig();
1405 sortCommandTable();
1406 if (argc == 2) {
1407 if (strcmp(argv[1], "-v") == 0 ||
1408 strcmp(argv[1], "--version") == 0) version();
1409 if (strcmp(argv[1], "--help") == 0) usage();
1410 resetServerSaveParams();
1411 loadServerConfig(argv[1]);
1412 } else if ((argc > 2)) {
1413 usage();
1414 } else {
1415 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'");
1416 }
1417 if (server.daemonize) daemonize();
1418 initServer();
1419 redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION);
1420#ifdef __linux__
1421 linuxOvercommitMemoryWarning();
1422#endif
1423 start = time(NULL);
1424 if (server.appendonly) {
1425 if (loadAppendOnlyFile(server.appendfilename) == REDIS_OK)
1426 redisLog(REDIS_NOTICE,"DB loaded from append only file: %ld seconds",time(NULL)-start);
1427 } else {
1428 if (rdbLoad(server.dbfilename) == REDIS_OK)
1429 redisLog(REDIS_NOTICE,"DB loaded from disk: %ld seconds",time(NULL)-start);
1430 }
1431 redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);
1432 aeSetBeforeSleepProc(server.el,beforeSleep);
1433 aeMain(server.el);
1434 aeDeleteEventLoop(server.el);
1435 return 0;
1436}
1437
1438/* ============================= Backtrace support ========================= */
1439
1440#ifdef HAVE_BACKTRACE
1441void *getMcontextEip(ucontext_t *uc) {
1442#if defined(__FreeBSD__)
1443 return (void*) uc->uc_mcontext.mc_eip;
1444#elif defined(__dietlibc__)
1445 return (void*) uc->uc_mcontext.eip;
1446#elif defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
1447 #if __x86_64__
1448 return (void*) uc->uc_mcontext->__ss.__rip;
1449 #else
1450 return (void*) uc->uc_mcontext->__ss.__eip;
1451 #endif
1452#elif defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)
1453 #if defined(_STRUCT_X86_THREAD_STATE64) && !defined(__i386__)
1454 return (void*) uc->uc_mcontext->__ss.__rip;
1455 #else
1456 return (void*) uc->uc_mcontext->__ss.__eip;
1457 #endif
3688d7f3 1458#elif defined(__i386__)
1459 return (void*) uc->uc_mcontext.gregs[14]; /* Linux 32 */
1460#elif defined(__X86_64__) || defined(__x86_64__)
1461 return (void*) uc->uc_mcontext.gregs[16]; /* Linux 64 */
e2641e09 1462#elif defined(__ia64__) /* Linux IA64 */
1463 return (void*) uc->uc_mcontext.sc_ip;
1464#else
1465 return NULL;
1466#endif
1467}
1468
1469void segvHandler(int sig, siginfo_t *info, void *secret) {
1470 void *trace[100];
1471 char **messages = NULL;
1472 int i, trace_size = 0;
1473 ucontext_t *uc = (ucontext_t*) secret;
1474 sds infostring;
1475 REDIS_NOTUSED(info);
1476
1477 redisLog(REDIS_WARNING,
1478 "======= Ooops! Redis %s got signal: -%d- =======", REDIS_VERSION, sig);
1479 infostring = genRedisInfoString();
1480 redisLog(REDIS_WARNING, "%s",infostring);
1481 /* It's not safe to sdsfree() the returned string under memory
1482 * corruption conditions. Let it leak as we are going to abort */
1483
1484 trace_size = backtrace(trace, 100);
1485 /* overwrite sigaction with caller's address */
1486 if (getMcontextEip(uc) != NULL) {
1487 trace[1] = getMcontextEip(uc);
1488 }
1489 messages = backtrace_symbols(trace, trace_size);
1490
1491 for (i=1; i<trace_size; ++i)
1492 redisLog(REDIS_WARNING,"%s", messages[i]);
1493
1494 /* free(messages); Don't call free() with possibly corrupted memory. */
1495 _exit(0);
1496}
1497
1498void sigtermHandler(int sig) {
1499 REDIS_NOTUSED(sig);
1500
1501 redisLog(REDIS_WARNING,"SIGTERM received, scheduling shutting down...");
1502 server.shutdown_asap = 1;
1503}
1504
1505void setupSigSegvAction(void) {
1506 struct sigaction act;
1507
1508 sigemptyset (&act.sa_mask);
1509 /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction
1510 * is used. Otherwise, sa_handler is used */
1511 act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;
1512 act.sa_sigaction = segvHandler;
1513 sigaction (SIGSEGV, &act, NULL);
1514 sigaction (SIGBUS, &act, NULL);
1515 sigaction (SIGFPE, &act, NULL);
1516 sigaction (SIGILL, &act, NULL);
1517 sigaction (SIGBUS, &act, NULL);
1518
1519 act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;
1520 act.sa_handler = sigtermHandler;
1521 sigaction (SIGTERM, &act, NULL);
1522 return;
1523}
1524
1525#else /* HAVE_BACKTRACE */
1526void setupSigSegvAction(void) {
1527}
1528#endif /* HAVE_BACKTRACE */
1529
1530/* The End */