]> git.saurik.com Git - redis.git/blob - src/redis.c
Number of iteration of --test-memory is now 300 (several minutes per gigabyte). Memte...
[redis.git] / src / redis.c
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 #include "slowlog.h"
32 #include "bio.h"
33
34 #include <time.h>
35 #include <signal.h>
36 #include <sys/wait.h>
37 #include <errno.h>
38 #include <assert.h>
39 #include <ctype.h>
40 #include <stdarg.h>
41 #include <arpa/inet.h>
42 #include <sys/stat.h>
43 #include <fcntl.h>
44 #include <sys/time.h>
45 #include <sys/resource.h>
46 #include <sys/uio.h>
47 #include <limits.h>
48 #include <float.h>
49 #include <math.h>
50 #include <sys/resource.h>
51
52 /* Our shared "common" objects */
53
54 struct sharedObjectsStruct shared;
55
56 /* Global vars that are actually used as constants. The following double
57 * values are used for double on-disk serialization, and are initialized
58 * at runtime to avoid strange compiler optimizations. */
59
60 double R_Zero, R_PosInf, R_NegInf, R_Nan;
61
62 /*================================= Globals ================================= */
63
64 /* Global vars */
65 struct redisServer server; /* server global state */
66 struct redisCommand *commandTable;
67
68 /* Our command table.
69 *
70 * Every entry is composed of the following fields:
71 *
72 * name: a string representing the command name.
73 * function: pointer to the C function implementing the command.
74 * arity: number of arguments, it is possible to use -N to say >= N
75 * sflags: command flags as string. See below for a table of flags.
76 * flags: flags as bitmask. Computed by Redis using the 'sflags' field.
77 * get_keys_proc: an optional function to get key arguments from a command.
78 * This is only used when the following three fields are not
79 * enough to specify what arguments are keys.
80 * first_key_index: first argument that is a key
81 * last_key_index: last argument that is a key
82 * key_step: step to get all the keys from first to last argument. For instance
83 * in MSET the step is two since arguments are key,val,key,val,...
84 * microseconds: microseconds of total execution time for this command.
85 * calls: total number of calls of this command.
86 *
87 * The flags, microseconds and calls fields are computed by Redis and should
88 * always be set to zero.
89 *
90 * Command flags are expressed using strings where every character represents
91 * a flag. Later the populateCommandTable() function will take care of
92 * populating the real 'flags' field using this characters.
93 *
94 * This is the meaning of the flags:
95 *
96 * w: write command (may modify the key space).
97 * r: read command (will never modify the key space).
98 * m: may increase memory usage once called. Don't allow if out of memory.
99 * a: admin command, like SAVE or SHUTDOWN.
100 * p: Pub/Sub related command.
101 * f: force replication of this command, regarless of server.dirty.
102 * s: command not allowed in scripts.
103 * R: random command. Command is not deterministic, that is, the same command
104 * with the same arguments, with the same key space, may have different
105 * results. For instance SPOP and RANDOMKEY are two random commands.
106 * S: Sort command output array if called from script, so that the output
107 * is deterministic.
108 */
109 struct redisCommand redisCommandTable[] = {
110 {"get",getCommand,2,"r",0,NULL,1,1,1,0,0},
111 {"set",setCommand,3,"wm",0,noPreloadGetKeys,1,1,1,0,0},
112 {"setnx",setnxCommand,3,"wm",0,noPreloadGetKeys,1,1,1,0,0},
113 {"setex",setexCommand,4,"wm",0,noPreloadGetKeys,1,1,1,0,0},
114 {"psetex",psetexCommand,4,"wm",0,noPreloadGetKeys,1,1,1,0,0},
115 {"append",appendCommand,3,"wm",0,NULL,1,1,1,0,0},
116 {"strlen",strlenCommand,2,"r",0,NULL,1,1,1,0,0},
117 {"del",delCommand,-2,"w",0,noPreloadGetKeys,1,-1,1,0,0},
118 {"exists",existsCommand,2,"r",0,NULL,1,1,1,0,0},
119 {"setbit",setbitCommand,4,"wm",0,NULL,1,1,1,0,0},
120 {"getbit",getbitCommand,3,"r",0,NULL,1,1,1,0,0},
121 {"setrange",setrangeCommand,4,"wm",0,NULL,1,1,1,0,0},
122 {"getrange",getrangeCommand,4,"r",0,NULL,1,1,1,0,0},
123 {"substr",getrangeCommand,4,"r",0,NULL,1,1,1,0,0},
124 {"incr",incrCommand,2,"wm",0,NULL,1,1,1,0,0},
125 {"decr",decrCommand,2,"wm",0,NULL,1,1,1,0,0},
126 {"mget",mgetCommand,-2,"r",0,NULL,1,-1,1,0,0},
127 {"rpush",rpushCommand,-3,"wm",0,NULL,1,1,1,0,0},
128 {"lpush",lpushCommand,-3,"wm",0,NULL,1,1,1,0,0},
129 {"rpushx",rpushxCommand,3,"wm",0,NULL,1,1,1,0,0},
130 {"lpushx",lpushxCommand,3,"wm",0,NULL,1,1,1,0,0},
131 {"linsert",linsertCommand,5,"wm",0,NULL,1,1,1,0,0},
132 {"rpop",rpopCommand,2,"w",0,NULL,1,1,1,0,0},
133 {"lpop",lpopCommand,2,"w",0,NULL,1,1,1,0,0},
134 {"brpop",brpopCommand,-3,"ws",0,NULL,1,1,1,0,0},
135 {"brpoplpush",brpoplpushCommand,4,"wms",0,NULL,1,2,1,0,0},
136 {"blpop",blpopCommand,-3,"ws",0,NULL,1,-2,1,0,0},
137 {"llen",llenCommand,2,"r",0,NULL,1,1,1,0,0},
138 {"lindex",lindexCommand,3,"r",0,NULL,1,1,1,0,0},
139 {"lset",lsetCommand,4,"wm",0,NULL,1,1,1,0,0},
140 {"lrange",lrangeCommand,4,"r",0,NULL,1,1,1,0,0},
141 {"ltrim",ltrimCommand,4,"w",0,NULL,1,1,1,0,0},
142 {"lrem",lremCommand,4,"w",0,NULL,1,1,1,0,0},
143 {"rpoplpush",rpoplpushCommand,3,"wm",0,NULL,1,2,1,0,0},
144 {"sadd",saddCommand,-3,"wm",0,NULL,1,1,1,0,0},
145 {"srem",sremCommand,-3,"w",0,NULL,1,1,1,0,0},
146 {"smove",smoveCommand,4,"w",0,NULL,1,2,1,0,0},
147 {"sismember",sismemberCommand,3,"r",0,NULL,1,1,1,0,0},
148 {"scard",scardCommand,2,"r",0,NULL,1,1,1,0,0},
149 {"spop",spopCommand,2,"wRs",0,NULL,1,1,1,0,0},
150 {"srandmember",srandmemberCommand,2,"rR",0,NULL,1,1,1,0,0},
151 {"sinter",sinterCommand,-2,"rS",0,NULL,1,-1,1,0,0},
152 {"sinterstore",sinterstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
153 {"sunion",sunionCommand,-2,"rS",0,NULL,1,-1,1,0,0},
154 {"sunionstore",sunionstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
155 {"sdiff",sdiffCommand,-2,"rS",0,NULL,1,-1,1,0,0},
156 {"sdiffstore",sdiffstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
157 {"smembers",sinterCommand,2,"rS",0,NULL,1,1,1,0,0},
158 {"zadd",zaddCommand,-4,"wm",0,NULL,1,1,1,0,0},
159 {"zincrby",zincrbyCommand,4,"wm",0,NULL,1,1,1,0,0},
160 {"zrem",zremCommand,-3,"w",0,NULL,1,1,1,0,0},
161 {"zremrangebyscore",zremrangebyscoreCommand,4,"w",0,NULL,1,1,1,0,0},
162 {"zremrangebyrank",zremrangebyrankCommand,4,"w",0,NULL,1,1,1,0,0},
163 {"zunionstore",zunionstoreCommand,-4,"wm",0,zunionInterGetKeys,0,0,0,0,0},
164 {"zinterstore",zinterstoreCommand,-4,"wm",0,zunionInterGetKeys,0,0,0,0,0},
165 {"zrange",zrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
166 {"zrangebyscore",zrangebyscoreCommand,-4,"r",0,NULL,1,1,1,0,0},
167 {"zrevrangebyscore",zrevrangebyscoreCommand,-4,"r",0,NULL,1,1,1,0,0},
168 {"zcount",zcountCommand,4,"r",0,NULL,1,1,1,0,0},
169 {"zrevrange",zrevrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
170 {"zcard",zcardCommand,2,"r",0,NULL,1,1,1,0,0},
171 {"zscore",zscoreCommand,3,"r",0,NULL,1,1,1,0,0},
172 {"zrank",zrankCommand,3,"r",0,NULL,1,1,1,0,0},
173 {"zrevrank",zrevrankCommand,3,"r",0,NULL,1,1,1,0,0},
174 {"hset",hsetCommand,4,"wm",0,NULL,1,1,1,0,0},
175 {"hsetnx",hsetnxCommand,4,"wm",0,NULL,1,1,1,0,0},
176 {"hget",hgetCommand,3,"r",0,NULL,1,1,1,0,0},
177 {"hmset",hmsetCommand,-4,"wm",0,NULL,1,1,1,0,0},
178 {"hmget",hmgetCommand,-3,"r",0,NULL,1,1,1,0,0},
179 {"hincrby",hincrbyCommand,4,"wm",0,NULL,1,1,1,0,0},
180 {"hincrbyfloat",hincrbyfloatCommand,4,"wm",0,NULL,1,1,1,0,0},
181 {"hdel",hdelCommand,-3,"w",0,NULL,1,1,1,0,0},
182 {"hlen",hlenCommand,2,"r",0,NULL,1,1,1,0,0},
183 {"hkeys",hkeysCommand,2,"rS",0,NULL,1,1,1,0,0},
184 {"hvals",hvalsCommand,2,"rS",0,NULL,1,1,1,0,0},
185 {"hgetall",hgetallCommand,2,"r",0,NULL,1,1,1,0,0},
186 {"hexists",hexistsCommand,3,"r",0,NULL,1,1,1,0,0},
187 {"incrby",incrbyCommand,3,"wm",0,NULL,1,1,1,0,0},
188 {"decrby",decrbyCommand,3,"wm",0,NULL,1,1,1,0,0},
189 {"incrbyfloat",incrbyfloatCommand,3,"wm",0,NULL,1,1,1,0,0},
190 {"getset",getsetCommand,3,"wm",0,NULL,1,1,1,0,0},
191 {"mset",msetCommand,-3,"wm",0,NULL,1,-1,2,0,0},
192 {"msetnx",msetnxCommand,-3,"wm",0,NULL,1,-1,2,0,0},
193 {"randomkey",randomkeyCommand,1,"rR",0,NULL,0,0,0,0,0},
194 {"select",selectCommand,2,"r",0,NULL,0,0,0,0,0},
195 {"move",moveCommand,3,"w",0,NULL,1,1,1,0,0},
196 {"rename",renameCommand,3,"w",0,renameGetKeys,1,2,1,0,0},
197 {"renamenx",renamenxCommand,3,"w",0,renameGetKeys,1,2,1,0,0},
198 {"expire",expireCommand,3,"w",0,NULL,1,1,1,0,0},
199 {"expireat",expireatCommand,3,"w",0,NULL,1,1,1,0,0},
200 {"pexpire",pexpireCommand,3,"w",0,NULL,1,1,1,0,0},
201 {"pexpireat",pexpireatCommand,3,"w",0,NULL,1,1,1,0,0},
202 {"keys",keysCommand,2,"rS",0,NULL,0,0,0,0,0},
203 {"dbsize",dbsizeCommand,1,"r",0,NULL,0,0,0,0,0},
204 {"auth",authCommand,2,"rs",0,NULL,0,0,0,0,0},
205 {"ping",pingCommand,1,"r",0,NULL,0,0,0,0,0},
206 {"echo",echoCommand,2,"r",0,NULL,0,0,0,0,0},
207 {"save",saveCommand,1,"ars",0,NULL,0,0,0,0,0},
208 {"bgsave",bgsaveCommand,1,"ar",0,NULL,0,0,0,0,0},
209 {"bgrewriteaof",bgrewriteaofCommand,1,"ar",0,NULL,0,0,0,0,0},
210 {"shutdown",shutdownCommand,-1,"ar",0,NULL,0,0,0,0,0},
211 {"lastsave",lastsaveCommand,1,"r",0,NULL,0,0,0,0,0},
212 {"type",typeCommand,2,"r",0,NULL,1,1,1,0,0},
213 {"multi",multiCommand,1,"rs",0,NULL,0,0,0,0,0},
214 {"exec",execCommand,1,"wms",0,NULL,0,0,0,0,0},
215 {"discard",discardCommand,1,"rs",0,NULL,0,0,0,0,0},
216 {"sync",syncCommand,1,"ars",0,NULL,0,0,0,0,0},
217 {"flushdb",flushdbCommand,1,"w",0,NULL,0,0,0,0,0},
218 {"flushall",flushallCommand,1,"w",0,NULL,0,0,0,0,0},
219 {"sort",sortCommand,-2,"wmS",0,NULL,1,1,1,0,0},
220 {"info",infoCommand,-1,"r",0,NULL,0,0,0,0,0},
221 {"monitor",monitorCommand,1,"ars",0,NULL,0,0,0,0,0},
222 {"ttl",ttlCommand,2,"r",0,NULL,1,1,1,0,0},
223 {"pttl",pttlCommand,2,"r",0,NULL,1,1,1,0,0},
224 {"persist",persistCommand,2,"w",0,NULL,1,1,1,0,0},
225 {"slaveof",slaveofCommand,3,"aws",0,NULL,0,0,0,0,0},
226 {"debug",debugCommand,-2,"aws",0,NULL,0,0,0,0,0},
227 {"config",configCommand,-2,"ar",0,NULL,0,0,0,0,0},
228 {"subscribe",subscribeCommand,-2,"rps",0,NULL,0,0,0,0,0},
229 {"unsubscribe",unsubscribeCommand,-1,"rps",0,NULL,0,0,0,0,0},
230 {"psubscribe",psubscribeCommand,-2,"rps",0,NULL,0,0,0,0,0},
231 {"punsubscribe",punsubscribeCommand,-1,"rps",0,NULL,0,0,0,0,0},
232 {"publish",publishCommand,3,"rpf",0,NULL,0,0,0,0,0},
233 {"watch",watchCommand,-2,"rs",0,noPreloadGetKeys,1,-1,1,0,0},
234 {"unwatch",unwatchCommand,1,"rs",0,NULL,0,0,0,0,0},
235 {"cluster",clusterCommand,-2,"ar",0,NULL,0,0,0,0,0},
236 {"restore",restoreCommand,4,"awm",0,NULL,1,1,1,0,0},
237 {"migrate",migrateCommand,6,"aw",0,NULL,0,0,0,0,0},
238 {"asking",askingCommand,1,"r",0,NULL,0,0,0,0,0},
239 {"dump",dumpCommand,2,"ar",0,NULL,1,1,1,0,0},
240 {"object",objectCommand,-2,"r",0,NULL,2,2,2,0,0},
241 {"client",clientCommand,-2,"ar",0,NULL,0,0,0,0,0},
242 {"eval",evalCommand,-3,"wms",0,zunionInterGetKeys,0,0,0,0,0},
243 {"evalsha",evalShaCommand,-3,"wms",0,zunionInterGetKeys,0,0,0,0,0},
244 {"slowlog",slowlogCommand,-2,"r",0,NULL,0,0,0,0,0},
245 {"script",scriptCommand,-2,"ras",0,NULL,0,0,0,0,0},
246 {"time",timeCommand,1,"rR",0,NULL,0,0,0,0,0}
247 };
248
249 /*============================ Utility functions ============================ */
250
251 /* Low level logging. To use only for very big messages, otherwise
252 * redisLog() is to prefer. */
253 void redisLogRaw(int level, const char *msg) {
254 const int syslogLevelMap[] = { LOG_DEBUG, LOG_INFO, LOG_NOTICE, LOG_WARNING };
255 const char *c = ".-*#";
256 time_t now = time(NULL);
257 FILE *fp;
258 char buf[64];
259 int rawmode = (level & REDIS_LOG_RAW);
260
261 level &= 0xff; /* clear flags */
262 if (level < server.verbosity) return;
263
264 fp = (server.logfile == NULL) ? stdout : fopen(server.logfile,"a");
265 if (!fp) return;
266
267 if (rawmode) {
268 fprintf(fp,"%s",msg);
269 } else {
270 strftime(buf,sizeof(buf),"%d %b %H:%M:%S",localtime(&now));
271 fprintf(fp,"[%d] %s %c %s\n",(int)getpid(),buf,c[level],msg);
272 }
273 fflush(fp);
274
275 if (server.logfile) fclose(fp);
276
277 if (server.syslog_enabled) syslog(syslogLevelMap[level], "%s", msg);
278 }
279
280 /* Like redisLogRaw() but with printf-alike support. This is the funciton that
281 * is used across the code. The raw version is only used in order to dump
282 * the INFO output on crash. */
283 void redisLog(int level, const char *fmt, ...) {
284 va_list ap;
285 char msg[REDIS_MAX_LOGMSG_LEN];
286
287 if ((level&0xff) < server.verbosity) return;
288
289 va_start(ap, fmt);
290 vsnprintf(msg, sizeof(msg), fmt, ap);
291 va_end(ap);
292
293 redisLogRaw(level,msg);
294 }
295
296 /* Redis generally does not try to recover from out of memory conditions
297 * when allocating objects or strings, it is not clear if it will be possible
298 * to report this condition to the client since the networking layer itself
299 * is based on heap allocation for send buffers, so we simply abort.
300 * At least the code will be simpler to read... */
301 void oom(const char *msg) {
302 redisLog(REDIS_WARNING, "%s: Out of memory\n",msg);
303 sleep(1);
304 abort();
305 }
306
307 /* Return the UNIX time in microseconds */
308 long long ustime(void) {
309 struct timeval tv;
310 long long ust;
311
312 gettimeofday(&tv, NULL);
313 ust = ((long long)tv.tv_sec)*1000000;
314 ust += tv.tv_usec;
315 return ust;
316 }
317
318 /* Return the UNIX time in milliseconds */
319 long long mstime(void) {
320 return ustime()/1000;
321 }
322
323 /*====================== Hash table type implementation ==================== */
324
325 /* This is an hash table type that uses the SDS dynamic strings libary as
326 * keys and radis objects as values (objects can hold SDS strings,
327 * lists, sets). */
328
329 void dictVanillaFree(void *privdata, void *val)
330 {
331 DICT_NOTUSED(privdata);
332 zfree(val);
333 }
334
335 void dictListDestructor(void *privdata, void *val)
336 {
337 DICT_NOTUSED(privdata);
338 listRelease((list*)val);
339 }
340
341 int dictSdsKeyCompare(void *privdata, const void *key1,
342 const void *key2)
343 {
344 int l1,l2;
345 DICT_NOTUSED(privdata);
346
347 l1 = sdslen((sds)key1);
348 l2 = sdslen((sds)key2);
349 if (l1 != l2) return 0;
350 return memcmp(key1, key2, l1) == 0;
351 }
352
353 /* A case insensitive version used for the command lookup table. */
354 int dictSdsKeyCaseCompare(void *privdata, const void *key1,
355 const void *key2)
356 {
357 DICT_NOTUSED(privdata);
358
359 return strcasecmp(key1, key2) == 0;
360 }
361
362 void dictRedisObjectDestructor(void *privdata, void *val)
363 {
364 DICT_NOTUSED(privdata);
365
366 if (val == NULL) return; /* Values of swapped out keys as set to NULL */
367 decrRefCount(val);
368 }
369
370 void dictSdsDestructor(void *privdata, void *val)
371 {
372 DICT_NOTUSED(privdata);
373
374 sdsfree(val);
375 }
376
377 int dictObjKeyCompare(void *privdata, const void *key1,
378 const void *key2)
379 {
380 const robj *o1 = key1, *o2 = key2;
381 return dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
382 }
383
384 unsigned int dictObjHash(const void *key) {
385 const robj *o = key;
386 return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
387 }
388
389 unsigned int dictSdsHash(const void *key) {
390 return dictGenHashFunction((unsigned char*)key, sdslen((char*)key));
391 }
392
393 unsigned int dictSdsCaseHash(const void *key) {
394 return dictGenCaseHashFunction((unsigned char*)key, sdslen((char*)key));
395 }
396
397 int dictEncObjKeyCompare(void *privdata, const void *key1,
398 const void *key2)
399 {
400 robj *o1 = (robj*) key1, *o2 = (robj*) key2;
401 int cmp;
402
403 if (o1->encoding == REDIS_ENCODING_INT &&
404 o2->encoding == REDIS_ENCODING_INT)
405 return o1->ptr == o2->ptr;
406
407 o1 = getDecodedObject(o1);
408 o2 = getDecodedObject(o2);
409 cmp = dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
410 decrRefCount(o1);
411 decrRefCount(o2);
412 return cmp;
413 }
414
415 unsigned int dictEncObjHash(const void *key) {
416 robj *o = (robj*) key;
417
418 if (o->encoding == REDIS_ENCODING_RAW) {
419 return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
420 } else {
421 if (o->encoding == REDIS_ENCODING_INT) {
422 char buf[32];
423 int len;
424
425 len = ll2string(buf,32,(long)o->ptr);
426 return dictGenHashFunction((unsigned char*)buf, len);
427 } else {
428 unsigned int hash;
429
430 o = getDecodedObject(o);
431 hash = dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
432 decrRefCount(o);
433 return hash;
434 }
435 }
436 }
437
438 /* Sets type hash table */
439 dictType setDictType = {
440 dictEncObjHash, /* hash function */
441 NULL, /* key dup */
442 NULL, /* val dup */
443 dictEncObjKeyCompare, /* key compare */
444 dictRedisObjectDestructor, /* key destructor */
445 NULL /* val destructor */
446 };
447
448 /* Sorted sets hash (note: a skiplist is used in addition to the hash table) */
449 dictType zsetDictType = {
450 dictEncObjHash, /* hash function */
451 NULL, /* key dup */
452 NULL, /* val dup */
453 dictEncObjKeyCompare, /* key compare */
454 dictRedisObjectDestructor, /* key destructor */
455 NULL /* val destructor */
456 };
457
458 /* Db->dict, keys are sds strings, vals are Redis objects. */
459 dictType dbDictType = {
460 dictSdsHash, /* hash function */
461 NULL, /* key dup */
462 NULL, /* val dup */
463 dictSdsKeyCompare, /* key compare */
464 dictSdsDestructor, /* key destructor */
465 dictRedisObjectDestructor /* val destructor */
466 };
467
468 /* Db->expires */
469 dictType keyptrDictType = {
470 dictSdsHash, /* hash function */
471 NULL, /* key dup */
472 NULL, /* val dup */
473 dictSdsKeyCompare, /* key compare */
474 NULL, /* key destructor */
475 NULL /* val destructor */
476 };
477
478 /* Command table. sds string -> command struct pointer. */
479 dictType commandTableDictType = {
480 dictSdsCaseHash, /* hash function */
481 NULL, /* key dup */
482 NULL, /* val dup */
483 dictSdsKeyCaseCompare, /* key compare */
484 dictSdsDestructor, /* key destructor */
485 NULL /* val destructor */
486 };
487
488 /* Hash type hash table (note that small hashes are represented with zimpaps) */
489 dictType hashDictType = {
490 dictEncObjHash, /* hash function */
491 NULL, /* key dup */
492 NULL, /* val dup */
493 dictEncObjKeyCompare, /* key compare */
494 dictRedisObjectDestructor, /* key destructor */
495 dictRedisObjectDestructor /* val destructor */
496 };
497
498 /* Keylist hash table type has unencoded redis objects as keys and
499 * lists as values. It's used for blocking operations (BLPOP) and to
500 * map swapped keys to a list of clients waiting for this keys to be loaded. */
501 dictType keylistDictType = {
502 dictObjHash, /* hash function */
503 NULL, /* key dup */
504 NULL, /* val dup */
505 dictObjKeyCompare, /* key compare */
506 dictRedisObjectDestructor, /* key destructor */
507 dictListDestructor /* val destructor */
508 };
509
510 /* Cluster nodes hash table, mapping nodes addresses 1.2.3.4:6379 to
511 * clusterNode structures. */
512 dictType clusterNodesDictType = {
513 dictSdsHash, /* hash function */
514 NULL, /* key dup */
515 NULL, /* val dup */
516 dictSdsKeyCompare, /* key compare */
517 dictSdsDestructor, /* key destructor */
518 NULL /* val destructor */
519 };
520
521 int htNeedsResize(dict *dict) {
522 long long size, used;
523
524 size = dictSlots(dict);
525 used = dictSize(dict);
526 return (size && used && size > DICT_HT_INITIAL_SIZE &&
527 (used*100/size < REDIS_HT_MINFILL));
528 }
529
530 /* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
531 * we resize the hash table to save memory */
532 void tryResizeHashTables(void) {
533 int j;
534
535 for (j = 0; j < server.dbnum; j++) {
536 if (htNeedsResize(server.db[j].dict))
537 dictResize(server.db[j].dict);
538 if (htNeedsResize(server.db[j].expires))
539 dictResize(server.db[j].expires);
540 }
541 }
542
543 /* Our hash table implementation performs rehashing incrementally while
544 * we write/read from the hash table. Still if the server is idle, the hash
545 * table will use two tables for a long time. So we try to use 1 millisecond
546 * of CPU time at every serverCron() loop in order to rehash some key. */
547 void incrementallyRehash(void) {
548 int j;
549
550 for (j = 0; j < server.dbnum; j++) {
551 if (dictIsRehashing(server.db[j].dict)) {
552 dictRehashMilliseconds(server.db[j].dict,1);
553 break; /* already used our millisecond for this loop... */
554 }
555 }
556 }
557
558 /* This function is called once a background process of some kind terminates,
559 * as we want to avoid resizing the hash tables when there is a child in order
560 * to play well with copy-on-write (otherwise when a resize happens lots of
561 * memory pages are copied). The goal of this function is to update the ability
562 * for dict.c to resize the hash tables accordingly to the fact we have o not
563 * running childs. */
564 void updateDictResizePolicy(void) {
565 if (server.rdb_child_pid == -1 && server.aof_child_pid == -1)
566 dictEnableResize();
567 else
568 dictDisableResize();
569 }
570
571 /* ======================= Cron: called every 100 ms ======================== */
572
573 /* Try to expire a few timed out keys. The algorithm used is adaptive and
574 * will use few CPU cycles if there are few expiring keys, otherwise
575 * it will get more aggressive to avoid that too much memory is used by
576 * keys that can be removed from the keyspace. */
577 void activeExpireCycle(void) {
578 int j;
579
580 for (j = 0; j < server.dbnum; j++) {
581 int expired;
582 redisDb *db = server.db+j;
583
584 /* Continue to expire if at the end of the cycle more than 25%
585 * of the keys were expired. */
586 do {
587 long num = dictSize(db->expires);
588 long long now = mstime();
589
590 expired = 0;
591 if (num > REDIS_EXPIRELOOKUPS_PER_CRON)
592 num = REDIS_EXPIRELOOKUPS_PER_CRON;
593 while (num--) {
594 dictEntry *de;
595 long long t;
596
597 if ((de = dictGetRandomKey(db->expires)) == NULL) break;
598 t = dictGetSignedIntegerVal(de);
599 if (now > t) {
600 sds key = dictGetKey(de);
601 robj *keyobj = createStringObject(key,sdslen(key));
602
603 propagateExpire(db,keyobj);
604 dbDelete(db,keyobj);
605 decrRefCount(keyobj);
606 expired++;
607 server.stat_expiredkeys++;
608 }
609 }
610 } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4);
611 }
612 }
613
614 void updateLRUClock(void) {
615 server.lruclock = (time(NULL)/REDIS_LRU_CLOCK_RESOLUTION) &
616 REDIS_LRU_CLOCK_MAX;
617 }
618
619
620 /* Add a sample to the operations per second array of samples. */
621 void trackOperationsPerSecond(void) {
622 long long t = mstime() - server.ops_sec_last_sample_time;
623 long long ops = server.stat_numcommands - server.ops_sec_last_sample_ops;
624 long long ops_sec;
625
626 ops_sec = t > 0 ? (ops*1000/t) : 0;
627
628 server.ops_sec_samples[server.ops_sec_idx] = ops_sec;
629 server.ops_sec_idx = (server.ops_sec_idx+1) % REDIS_OPS_SEC_SAMPLES;
630 server.ops_sec_last_sample_time = mstime();
631 server.ops_sec_last_sample_ops = server.stat_numcommands;
632 }
633
634 /* Return the mean of all the samples. */
635 long long getOperationsPerSecond(void) {
636 int j;
637 long long sum = 0;
638
639 for (j = 0; j < REDIS_OPS_SEC_SAMPLES; j++)
640 sum += server.ops_sec_samples[j];
641 return sum / REDIS_OPS_SEC_SAMPLES;
642 }
643
644 /* Check for timeouts. Returns non-zero if the client was terminated */
645 int clientsCronHandleTimeout(redisClient *c) {
646 time_t now = server.unixtime;
647
648 if (server.maxidletime &&
649 !(c->flags & REDIS_SLAVE) && /* no timeout for slaves */
650 !(c->flags & REDIS_MASTER) && /* no timeout for masters */
651 !(c->flags & REDIS_BLOCKED) && /* no timeout for BLPOP */
652 dictSize(c->pubsub_channels) == 0 && /* no timeout for pubsub */
653 listLength(c->pubsub_patterns) == 0 &&
654 (now - c->lastinteraction > server.maxidletime))
655 {
656 redisLog(REDIS_VERBOSE,"Closing idle client");
657 freeClient(c);
658 return 1;
659 } else if (c->flags & REDIS_BLOCKED) {
660 if (c->bpop.timeout != 0 && c->bpop.timeout < now) {
661 addReply(c,shared.nullmultibulk);
662 unblockClientWaitingData(c);
663 }
664 }
665 return 0;
666 }
667
668 /* The client query buffer is an sds.c string that can end with a lot of
669 * free space not used, this function reclaims space if needed.
670 *
671 * The funciton always returns 0 as it never terminates the client. */
672 int clientsCronResizeQueryBuffer(redisClient *c) {
673 size_t querybuf_size = sdsAllocSize(c->querybuf);
674 time_t idletime = server.unixtime - c->lastinteraction;
675
676 /* There are two conditions to resize the query buffer:
677 * 1) Query buffer is > BIG_ARG and too big for latest peak.
678 * 2) Client is inactive and the buffer is bigger than 1k. */
679 if (((querybuf_size > REDIS_MBULK_BIG_ARG) &&
680 (querybuf_size/(c->querybuf_peak+1)) > 2) ||
681 (querybuf_size > 1024 && idletime > 2))
682 {
683 /* Only resize the query buffer if it is actually wasting space. */
684 if (sdsavail(c->querybuf) > 1024) {
685 c->querybuf = sdsRemoveFreeSpace(c->querybuf);
686 }
687 }
688 /* Reset the peak again to capture the peak memory usage in the next
689 * cycle. */
690 c->querybuf_peak = 0;
691 return 0;
692 }
693
694 void clientsCron(void) {
695 /* Make sure to process at least 1/100 of clients per call.
696 * Since this function is called 10 times per second we are sure that
697 * in the worst case we process all the clients in 10 seconds.
698 * In normal conditions (a reasonable number of clients) we process
699 * all the clients in a shorter time. */
700 int numclients = listLength(server.clients);
701 int iterations = numclients/100;
702
703 if (iterations < 50)
704 iterations = (numclients < 50) ? numclients : 50;
705 while(listLength(server.clients) && iterations--) {
706 redisClient *c;
707 listNode *head;
708
709 /* Rotate the list, take the current head, process.
710 * This way if the client must be removed from the list it's the
711 * first element and we don't incur into O(N) computation. */
712 listRotate(server.clients);
713 head = listFirst(server.clients);
714 c = listNodeValue(head);
715 /* The following functions do different service checks on the client.
716 * The protocol is that they return non-zero if the client was
717 * terminated. */
718 if (clientsCronHandleTimeout(c)) continue;
719 if (clientsCronResizeQueryBuffer(c)) continue;
720 }
721 }
722
723 int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
724 int j, loops = server.cronloops;
725 REDIS_NOTUSED(eventLoop);
726 REDIS_NOTUSED(id);
727 REDIS_NOTUSED(clientData);
728
729 /* We take a cached value of the unix time in the global state because
730 * with virtual memory and aging there is to store the current time
731 * in objects at every object access, and accuracy is not needed.
732 * To access a global var is faster than calling time(NULL) */
733 server.unixtime = time(NULL);
734
735 trackOperationsPerSecond();
736
737 /* We have just 22 bits per object for LRU information.
738 * So we use an (eventually wrapping) LRU clock with 10 seconds resolution.
739 * 2^22 bits with 10 seconds resoluton is more or less 1.5 years.
740 *
741 * Note that even if this will wrap after 1.5 years it's not a problem,
742 * everything will still work but just some object will appear younger
743 * to Redis. But for this to happen a given object should never be touched
744 * for 1.5 years.
745 *
746 * Note that you can change the resolution altering the
747 * REDIS_LRU_CLOCK_RESOLUTION define.
748 */
749 updateLRUClock();
750
751 /* Record the max memory used since the server was started. */
752 if (zmalloc_used_memory() > server.stat_peak_memory)
753 server.stat_peak_memory = zmalloc_used_memory();
754
755 /* We received a SIGTERM, shutting down here in a safe way, as it is
756 * not ok doing so inside the signal handler. */
757 if (server.shutdown_asap) {
758 if (prepareForShutdown(0) == REDIS_OK) exit(0);
759 redisLog(REDIS_WARNING,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
760 }
761
762 /* Show some info about non-empty databases */
763 for (j = 0; j < server.dbnum; j++) {
764 long long size, used, vkeys;
765
766 size = dictSlots(server.db[j].dict);
767 used = dictSize(server.db[j].dict);
768 vkeys = dictSize(server.db[j].expires);
769 if (!(loops % 50) && (used || vkeys)) {
770 redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
771 /* dictPrintStats(server.dict); */
772 }
773 }
774
775 /* We don't want to resize the hash tables while a bacground saving
776 * is in progress: the saving child is created using fork() that is
777 * implemented with a copy-on-write semantic in most modern systems, so
778 * if we resize the HT while there is the saving child at work actually
779 * a lot of memory movements in the parent will cause a lot of pages
780 * copied. */
781 if (server.rdb_child_pid == -1 && server.aof_child_pid == -1) {
782 if (!(loops % 10)) tryResizeHashTables();
783 if (server.activerehashing) incrementallyRehash();
784 }
785
786 /* Show information about connected clients */
787 if (!(loops % 50)) {
788 redisLog(REDIS_VERBOSE,"%d clients connected (%d slaves), %zu bytes in use",
789 listLength(server.clients)-listLength(server.slaves),
790 listLength(server.slaves),
791 zmalloc_used_memory());
792 }
793
794 /* We need to do a few operations on clients asynchronously. */
795 clientsCron();
796
797 /* Start a scheduled AOF rewrite if this was requested by the user while
798 * a BGSAVE was in progress. */
799 if (server.rdb_child_pid == -1 && server.aof_child_pid == -1 &&
800 server.aof_rewrite_scheduled)
801 {
802 rewriteAppendOnlyFileBackground();
803 }
804
805 /* Check if a background saving or AOF rewrite in progress terminated. */
806 if (server.rdb_child_pid != -1 || server.aof_child_pid != -1) {
807 int statloc;
808 pid_t pid;
809
810 if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
811 int exitcode = WEXITSTATUS(statloc);
812 int bysignal = 0;
813
814 if (WIFSIGNALED(statloc)) bysignal = WTERMSIG(statloc);
815
816 if (pid == server.rdb_child_pid) {
817 backgroundSaveDoneHandler(exitcode,bysignal);
818 } else {
819 backgroundRewriteDoneHandler(exitcode,bysignal);
820 }
821 updateDictResizePolicy();
822 }
823 } else {
824 time_t now = time(NULL);
825
826 /* If there is not a background saving/rewrite in progress check if
827 * we have to save/rewrite now */
828 for (j = 0; j < server.saveparamslen; j++) {
829 struct saveparam *sp = server.saveparams+j;
830
831 if (server.dirty >= sp->changes &&
832 now-server.lastsave > sp->seconds) {
833 redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
834 sp->changes, sp->seconds);
835 rdbSaveBackground(server.rdb_filename);
836 break;
837 }
838 }
839
840 /* Trigger an AOF rewrite if needed */
841 if (server.rdb_child_pid == -1 &&
842 server.aof_child_pid == -1 &&
843 server.aof_rewrite_perc &&
844 server.aof_current_size > server.aof_rewrite_min_size)
845 {
846 long long base = server.aof_rewrite_base_size ?
847 server.aof_rewrite_base_size : 1;
848 long long growth = (server.aof_current_size*100/base) - 100;
849 if (growth >= server.aof_rewrite_perc) {
850 redisLog(REDIS_NOTICE,"Starting automatic rewriting of AOF on %lld%% growth",growth);
851 rewriteAppendOnlyFileBackground();
852 }
853 }
854 }
855
856
857 /* If we postponed an AOF buffer flush, let's try to do it every time the
858 * cron function is called. */
859 if (server.aof_flush_postponed_start) flushAppendOnlyFile(0);
860
861 /* Expire a few keys per cycle, only if this is a master.
862 * On slaves we wait for DEL operations synthesized by the master
863 * in order to guarantee a strict consistency. */
864 if (server.masterhost == NULL) activeExpireCycle();
865
866 /* Close clients that need to be closed asynchronous */
867 freeClientsInAsyncFreeQueue();
868
869 /* Replication cron function -- used to reconnect to master and
870 * to detect transfer failures. */
871 if (!(loops % 10)) replicationCron();
872
873 /* Run other sub-systems specific cron jobs */
874 if (server.cluster_enabled && !(loops % 10)) clusterCron();
875
876 server.cronloops++;
877 return 100;
878 }
879
880 /* This function gets called every time Redis is entering the
881 * main loop of the event driven library, that is, before to sleep
882 * for ready file descriptors. */
883 void beforeSleep(struct aeEventLoop *eventLoop) {
884 REDIS_NOTUSED(eventLoop);
885 listNode *ln;
886 redisClient *c;
887
888 /* Try to process pending commands for clients that were just unblocked. */
889 while (listLength(server.unblocked_clients)) {
890 ln = listFirst(server.unblocked_clients);
891 redisAssert(ln != NULL);
892 c = ln->value;
893 listDelNode(server.unblocked_clients,ln);
894 c->flags &= ~REDIS_UNBLOCKED;
895
896 /* Process remaining data in the input buffer. */
897 if (c->querybuf && sdslen(c->querybuf) > 0) {
898 server.current_client = c;
899 processInputBuffer(c);
900 server.current_client = NULL;
901 }
902 }
903
904 /* Write the AOF buffer on disk */
905 flushAppendOnlyFile(0);
906 }
907
908 /* =========================== Server initialization ======================== */
909
910 void createSharedObjects(void) {
911 int j;
912
913 shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
914 shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
915 shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
916 shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
917 shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
918 shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
919 shared.cnegone = createObject(REDIS_STRING,sdsnew(":-1\r\n"));
920 shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
921 shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
922 shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
923 shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
924 shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n"));
925 shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
926 "-ERR Operation against a key holding the wrong kind of value\r\n"));
927 shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
928 "-ERR no such key\r\n"));
929 shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
930 "-ERR syntax error\r\n"));
931 shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
932 "-ERR source and destination objects are the same\r\n"));
933 shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
934 "-ERR index out of range\r\n"));
935 shared.noscripterr = createObject(REDIS_STRING,sdsnew(
936 "-NOSCRIPT No matching script. Please use EVAL.\r\n"));
937 shared.loadingerr = createObject(REDIS_STRING,sdsnew(
938 "-LOADING Redis is loading the dataset in memory\r\n"));
939 shared.slowscripterr = createObject(REDIS_STRING,sdsnew(
940 "-BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.\r\n"));
941 shared.bgsaveerr = createObject(REDIS_STRING,sdsnew(
942 "-MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk. Write commands are disabled. Please check Redis logs for details about the error.\r\n"));
943 shared.space = createObject(REDIS_STRING,sdsnew(" "));
944 shared.colon = createObject(REDIS_STRING,sdsnew(":"));
945 shared.plus = createObject(REDIS_STRING,sdsnew("+"));
946 shared.select0 = createStringObject("select 0\r\n",10);
947 shared.select1 = createStringObject("select 1\r\n",10);
948 shared.select2 = createStringObject("select 2\r\n",10);
949 shared.select3 = createStringObject("select 3\r\n",10);
950 shared.select4 = createStringObject("select 4\r\n",10);
951 shared.select5 = createStringObject("select 5\r\n",10);
952 shared.select6 = createStringObject("select 6\r\n",10);
953 shared.select7 = createStringObject("select 7\r\n",10);
954 shared.select8 = createStringObject("select 8\r\n",10);
955 shared.select9 = createStringObject("select 9\r\n",10);
956 shared.messagebulk = createStringObject("$7\r\nmessage\r\n",13);
957 shared.pmessagebulk = createStringObject("$8\r\npmessage\r\n",14);
958 shared.subscribebulk = createStringObject("$9\r\nsubscribe\r\n",15);
959 shared.unsubscribebulk = createStringObject("$11\r\nunsubscribe\r\n",18);
960 shared.psubscribebulk = createStringObject("$10\r\npsubscribe\r\n",17);
961 shared.punsubscribebulk = createStringObject("$12\r\npunsubscribe\r\n",19);
962 shared.del = createStringObject("DEL",3);
963 shared.rpop = createStringObject("RPOP",4);
964 shared.lpop = createStringObject("LPOP",4);
965 for (j = 0; j < REDIS_SHARED_INTEGERS; j++) {
966 shared.integers[j] = createObject(REDIS_STRING,(void*)(long)j);
967 shared.integers[j]->encoding = REDIS_ENCODING_INT;
968 }
969 for (j = 0; j < REDIS_SHARED_BULKHDR_LEN; j++) {
970 shared.mbulkhdr[j] = createObject(REDIS_STRING,
971 sdscatprintf(sdsempty(),"*%d\r\n",j));
972 shared.bulkhdr[j] = createObject(REDIS_STRING,
973 sdscatprintf(sdsempty(),"$%d\r\n",j));
974 }
975 }
976
977 void initServerConfig() {
978 getRandomHexChars(server.runid,REDIS_RUN_ID_SIZE);
979 server.runid[REDIS_RUN_ID_SIZE] = '\0';
980 server.arch_bits = (sizeof(long) == 8) ? 64 : 32;
981 server.port = REDIS_SERVERPORT;
982 server.bindaddr = NULL;
983 server.unixsocket = NULL;
984 server.unixsocketperm = 0;
985 server.ipfd = -1;
986 server.sofd = -1;
987 server.dbnum = REDIS_DEFAULT_DBNUM;
988 server.verbosity = REDIS_NOTICE;
989 server.maxidletime = REDIS_MAXIDLETIME;
990 server.client_max_querybuf_len = REDIS_MAX_QUERYBUF_LEN;
991 server.saveparams = NULL;
992 server.loading = 0;
993 server.logfile = NULL; /* NULL = log on standard output */
994 server.syslog_enabled = 0;
995 server.syslog_ident = zstrdup("redis");
996 server.syslog_facility = LOG_LOCAL0;
997 server.daemonize = 0;
998 server.aof_state = REDIS_AOF_OFF;
999 server.aof_fsync = AOF_FSYNC_EVERYSEC;
1000 server.aof_no_fsync_on_rewrite = 0;
1001 server.aof_rewrite_perc = REDIS_AOF_REWRITE_PERC;
1002 server.aof_rewrite_min_size = REDIS_AOF_REWRITE_MIN_SIZE;
1003 server.aof_rewrite_base_size = 0;
1004 server.aof_rewrite_scheduled = 0;
1005 server.aof_last_fsync = time(NULL);
1006 server.aof_fd = -1;
1007 server.aof_selected_db = -1; /* Make sure the first time will not match */
1008 server.aof_flush_postponed_start = 0;
1009 server.pidfile = zstrdup("/var/run/redis.pid");
1010 server.rdb_filename = zstrdup("dump.rdb");
1011 server.aof_filename = zstrdup("appendonly.aof");
1012 server.requirepass = NULL;
1013 server.rdb_compression = 1;
1014 server.activerehashing = 1;
1015 server.maxclients = REDIS_MAX_CLIENTS;
1016 server.bpop_blocked_clients = 0;
1017 server.maxmemory = 0;
1018 server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
1019 server.maxmemory_samples = 3;
1020 server.hash_max_ziplist_entries = REDIS_HASH_MAX_ZIPLIST_ENTRIES;
1021 server.hash_max_ziplist_value = REDIS_HASH_MAX_ZIPLIST_VALUE;
1022 server.list_max_ziplist_entries = REDIS_LIST_MAX_ZIPLIST_ENTRIES;
1023 server.list_max_ziplist_value = REDIS_LIST_MAX_ZIPLIST_VALUE;
1024 server.set_max_intset_entries = REDIS_SET_MAX_INTSET_ENTRIES;
1025 server.zset_max_ziplist_entries = REDIS_ZSET_MAX_ZIPLIST_ENTRIES;
1026 server.zset_max_ziplist_value = REDIS_ZSET_MAX_ZIPLIST_VALUE;
1027 server.shutdown_asap = 0;
1028 server.repl_ping_slave_period = REDIS_REPL_PING_SLAVE_PERIOD;
1029 server.repl_timeout = REDIS_REPL_TIMEOUT;
1030 server.cluster_enabled = 0;
1031 server.cluster.configfile = zstrdup("nodes.conf");
1032 server.lua_caller = NULL;
1033 server.lua_time_limit = REDIS_LUA_TIME_LIMIT;
1034 server.lua_client = NULL;
1035 server.lua_timedout = 0;
1036
1037 updateLRUClock();
1038 resetServerSaveParams();
1039
1040 appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
1041 appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
1042 appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
1043 /* Replication related */
1044 server.masterauth = NULL;
1045 server.masterhost = NULL;
1046 server.masterport = 6379;
1047 server.master = NULL;
1048 server.repl_state = REDIS_REPL_NONE;
1049 server.repl_syncio_timeout = REDIS_REPL_SYNCIO_TIMEOUT;
1050 server.repl_serve_stale_data = 1;
1051 server.repl_down_since = -1;
1052
1053 /* Client output buffer limits */
1054 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_NORMAL].hard_limit_bytes = 0;
1055 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_NORMAL].soft_limit_bytes = 0;
1056 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_NORMAL].soft_limit_seconds = 0;
1057 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_SLAVE].hard_limit_bytes = 1024*1024*256;
1058 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_SLAVE].soft_limit_bytes = 1024*1024*64;
1059 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_SLAVE].soft_limit_seconds = 60;
1060 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_PUBSUB].hard_limit_bytes = 1024*1024*32;
1061 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_PUBSUB].soft_limit_bytes = 1024*1024*8;
1062 server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_PUBSUB].soft_limit_seconds = 60;
1063
1064 /* Double constants initialization */
1065 R_Zero = 0.0;
1066 R_PosInf = 1.0/R_Zero;
1067 R_NegInf = -1.0/R_Zero;
1068 R_Nan = R_Zero/R_Zero;
1069
1070 /* Command table -- we intiialize it here as it is part of the
1071 * initial configuration, since command names may be changed via
1072 * redis.conf using the rename-command directive. */
1073 server.commands = dictCreate(&commandTableDictType,NULL);
1074 populateCommandTable();
1075 server.delCommand = lookupCommandByCString("del");
1076 server.multiCommand = lookupCommandByCString("multi");
1077 server.lpushCommand = lookupCommandByCString("lpush");
1078
1079 /* Slow log */
1080 server.slowlog_log_slower_than = REDIS_SLOWLOG_LOG_SLOWER_THAN;
1081 server.slowlog_max_len = REDIS_SLOWLOG_MAX_LEN;
1082
1083 /* Assert */
1084 server.assert_failed = "<no assertion failed>";
1085 server.assert_file = "<no file>";
1086 server.assert_line = 0;
1087 server.bug_report_start = 0;
1088 }
1089
1090 /* This function will try to raise the max number of open files accordingly to
1091 * the configured max number of clients. It will also account for 32 additional
1092 * file descriptors as we need a few more for persistence, listening
1093 * sockets, log files and so forth.
1094 *
1095 * If it will not be possible to set the limit accordingly to the configured
1096 * max number of clients, the function will do the reverse setting
1097 * server.maxclients to the value that we can actually handle. */
1098 void adjustOpenFilesLimit(void) {
1099 rlim_t maxfiles = server.maxclients+32;
1100 struct rlimit limit;
1101
1102 if (maxfiles < 1024) maxfiles = 1024;
1103 if (getrlimit(RLIMIT_NOFILE,&limit) == -1) {
1104 redisLog(REDIS_WARNING,"Unable to obtain the current NOFILE limit (%s), assuming 1024 and setting the max clients configuration accordingly.",
1105 strerror(errno));
1106 server.maxclients = 1024-32;
1107 } else {
1108 rlim_t oldlimit = limit.rlim_cur;
1109
1110 /* Set the max number of files if the current limit is not enough
1111 * for our needs. */
1112 if (oldlimit < maxfiles) {
1113 limit.rlim_cur = maxfiles;
1114 limit.rlim_max = maxfiles;
1115 if (setrlimit(RLIMIT_NOFILE,&limit) == -1) {
1116 server.maxclients = oldlimit-32;
1117 redisLog(REDIS_WARNING,"Unable to set the max number of files limit to %d (%s), setting the max clients configuration to %d.",
1118 (int) maxfiles, strerror(errno), (int) server.maxclients);
1119 } else {
1120 redisLog(REDIS_NOTICE,"Max number of open files set to %d",
1121 (int) maxfiles);
1122 }
1123 }
1124 }
1125 }
1126
1127 void initServer() {
1128 int j;
1129
1130 signal(SIGHUP, SIG_IGN);
1131 signal(SIGPIPE, SIG_IGN);
1132 setupSignalHandlers();
1133
1134 if (server.syslog_enabled) {
1135 openlog(server.syslog_ident, LOG_PID | LOG_NDELAY | LOG_NOWAIT,
1136 server.syslog_facility);
1137 }
1138
1139 server.current_client = NULL;
1140 server.clients = listCreate();
1141 server.clients_to_close = listCreate();
1142 server.slaves = listCreate();
1143 server.monitors = listCreate();
1144 server.unblocked_clients = listCreate();
1145
1146 createSharedObjects();
1147 adjustOpenFilesLimit();
1148 server.el = aeCreateEventLoop(server.maxclients+1024);
1149 server.db = zmalloc(sizeof(redisDb)*server.dbnum);
1150
1151 if (server.port != 0) {
1152 server.ipfd = anetTcpServer(server.neterr,server.port,server.bindaddr);
1153 if (server.ipfd == ANET_ERR) {
1154 redisLog(REDIS_WARNING, "Opening port %d: %s",
1155 server.port, server.neterr);
1156 exit(1);
1157 }
1158 }
1159 if (server.unixsocket != NULL) {
1160 unlink(server.unixsocket); /* don't care if this fails */
1161 server.sofd = anetUnixServer(server.neterr,server.unixsocket,server.unixsocketperm);
1162 if (server.sofd == ANET_ERR) {
1163 redisLog(REDIS_WARNING, "Opening socket: %s", server.neterr);
1164 exit(1);
1165 }
1166 }
1167 if (server.ipfd < 0 && server.sofd < 0) {
1168 redisLog(REDIS_WARNING, "Configured to not listen anywhere, exiting.");
1169 exit(1);
1170 }
1171 for (j = 0; j < server.dbnum; j++) {
1172 server.db[j].dict = dictCreate(&dbDictType,NULL);
1173 server.db[j].expires = dictCreate(&keyptrDictType,NULL);
1174 server.db[j].blocking_keys = dictCreate(&keylistDictType,NULL);
1175 server.db[j].watched_keys = dictCreate(&keylistDictType,NULL);
1176 server.db[j].id = j;
1177 }
1178 server.pubsub_channels = dictCreate(&keylistDictType,NULL);
1179 server.pubsub_patterns = listCreate();
1180 listSetFreeMethod(server.pubsub_patterns,freePubsubPattern);
1181 listSetMatchMethod(server.pubsub_patterns,listMatchPubsubPattern);
1182 server.cronloops = 0;
1183 server.rdb_child_pid = -1;
1184 server.aof_child_pid = -1;
1185 server.aof_rewrite_buf = sdsempty();
1186 server.aof_buf = sdsempty();
1187 server.lastsave = time(NULL);
1188 server.dirty = 0;
1189 server.stat_numcommands = 0;
1190 server.stat_numconnections = 0;
1191 server.stat_expiredkeys = 0;
1192 server.stat_evictedkeys = 0;
1193 server.stat_starttime = time(NULL);
1194 server.stat_keyspace_misses = 0;
1195 server.stat_keyspace_hits = 0;
1196 server.stat_peak_memory = 0;
1197 server.stat_fork_time = 0;
1198 server.stat_rejected_conn = 0;
1199 memset(server.ops_sec_samples,0,sizeof(server.ops_sec_samples));
1200 server.ops_sec_idx = 0;
1201 server.ops_sec_last_sample_time = mstime();
1202 server.ops_sec_last_sample_ops = 0;
1203 server.unixtime = time(NULL);
1204 server.lastbgsave_status = REDIS_OK;
1205 server.stop_writes_on_bgsave_err = 1;
1206 aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL);
1207 if (server.ipfd > 0 && aeCreateFileEvent(server.el,server.ipfd,AE_READABLE,
1208 acceptTcpHandler,NULL) == AE_ERR) oom("creating file event");
1209 if (server.sofd > 0 && aeCreateFileEvent(server.el,server.sofd,AE_READABLE,
1210 acceptUnixHandler,NULL) == AE_ERR) oom("creating file event");
1211
1212 if (server.aof_state == REDIS_AOF_ON) {
1213 server.aof_fd = open(server.aof_filename,
1214 O_WRONLY|O_APPEND|O_CREAT,0644);
1215 if (server.aof_fd == -1) {
1216 redisLog(REDIS_WARNING, "Can't open the append-only file: %s",
1217 strerror(errno));
1218 exit(1);
1219 }
1220 }
1221
1222 /* 32 bit instances are limited to 4GB of address space, so if there is
1223 * no explicit limit in the user provided configuration we set a limit
1224 * at 3.5GB using maxmemory with 'noeviction' policy'. This saves
1225 * useless crashes of the Redis instance. */
1226 if (server.arch_bits == 32 && server.maxmemory == 0) {
1227 redisLog(REDIS_WARNING,"Warning: 32 bit instance detected but no memory limit set. Setting 3.5 GB maxmemory limit with 'noeviction' policy now.");
1228 server.maxmemory = 3584LL*(1024*1024); /* 3584 MB = 3.5 GB */
1229 server.maxmemory_policy = REDIS_MAXMEMORY_NO_EVICTION;
1230 }
1231
1232 if (server.cluster_enabled) clusterInit();
1233 scriptingInit();
1234 slowlogInit();
1235 bioInit();
1236 }
1237
1238 /* Populates the Redis Command Table starting from the hard coded list
1239 * we have on top of redis.c file. */
1240 void populateCommandTable(void) {
1241 int j;
1242 int numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
1243
1244 for (j = 0; j < numcommands; j++) {
1245 struct redisCommand *c = redisCommandTable+j;
1246 char *f = c->sflags;
1247 int retval;
1248
1249 while(*f != '\0') {
1250 switch(*f) {
1251 case 'w': c->flags |= REDIS_CMD_WRITE; break;
1252 case 'r': c->flags |= REDIS_CMD_READONLY; break;
1253 case 'm': c->flags |= REDIS_CMD_DENYOOM; break;
1254 case 'a': c->flags |= REDIS_CMD_ADMIN; break;
1255 case 'p': c->flags |= REDIS_CMD_PUBSUB; break;
1256 case 'f': c->flags |= REDIS_CMD_FORCE_REPLICATION; break;
1257 case 's': c->flags |= REDIS_CMD_NOSCRIPT; break;
1258 case 'R': c->flags |= REDIS_CMD_RANDOM; break;
1259 case 'S': c->flags |= REDIS_CMD_SORT_FOR_SCRIPT; break;
1260 default: redisPanic("Unsupported command flag"); break;
1261 }
1262 f++;
1263 }
1264
1265 retval = dictAdd(server.commands, sdsnew(c->name), c);
1266 assert(retval == DICT_OK);
1267 }
1268 }
1269
1270 void resetCommandTableStats(void) {
1271 int numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
1272 int j;
1273
1274 for (j = 0; j < numcommands; j++) {
1275 struct redisCommand *c = redisCommandTable+j;
1276
1277 c->microseconds = 0;
1278 c->calls = 0;
1279 }
1280 }
1281
1282 /* ========================== Redis OP Array API ============================ */
1283
1284 void redisOpArrayInit(redisOpArray *oa) {
1285 oa->ops = NULL;
1286 oa->numops = 0;
1287 }
1288
1289 int redisOpArrayAppend(redisOpArray *oa, struct redisCommand *cmd, int dbid,
1290 robj **argv, int argc, int target)
1291 {
1292 redisOp *op;
1293
1294 oa->ops = zrealloc(oa->ops,sizeof(redisOp)*(oa->numops+1));
1295 op = oa->ops+oa->numops;
1296 op->cmd = cmd;
1297 op->dbid = dbid;
1298 op->argv = argv;
1299 op->argc = argc;
1300 op->target = target;
1301 oa->numops++;
1302 return oa->numops;
1303 }
1304
1305 void redisOpArrayFree(redisOpArray *oa) {
1306 while(oa->numops) {
1307 int j;
1308 redisOp *op;
1309
1310 oa->numops--;
1311 op = oa->ops+oa->numops;
1312 for (j = 0; j < op->argc; j++)
1313 decrRefCount(op->argv[j]);
1314 zfree(op->argv);
1315 }
1316 zfree(oa->ops);
1317 }
1318
1319 /* ====================== Commands lookup and execution ===================== */
1320
1321 struct redisCommand *lookupCommand(sds name) {
1322 return dictFetchValue(server.commands, name);
1323 }
1324
1325 struct redisCommand *lookupCommandByCString(char *s) {
1326 struct redisCommand *cmd;
1327 sds name = sdsnew(s);
1328
1329 cmd = dictFetchValue(server.commands, name);
1330 sdsfree(name);
1331 return cmd;
1332 }
1333
1334 /* Propagate the specified command (in the context of the specified database id)
1335 * to AOF, Slaves and Monitors.
1336 *
1337 * flags are an xor between:
1338 * + REDIS_PROPAGATE_NONE (no propagation of command at all)
1339 * + REDIS_PROPAGATE_AOF (propagate into the AOF file if is enabled)
1340 * + REDIS_PROPAGATE_REPL (propagate into the replication link)
1341 */
1342 void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
1343 int flags)
1344 {
1345 if (server.aof_state != REDIS_AOF_OFF && flags & REDIS_PROPAGATE_AOF)
1346 feedAppendOnlyFile(cmd,dbid,argv,argc);
1347 if (flags & REDIS_PROPAGATE_REPL && listLength(server.slaves))
1348 replicationFeedSlaves(server.slaves,dbid,argv,argc);
1349 }
1350
1351 /* Used inside commands to schedule the propagation of additional commands
1352 * after the current command is propagated to AOF / Replication. */
1353 void alsoPropagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
1354 int target)
1355 {
1356 redisOpArrayAppend(&server.also_propagate,cmd,dbid,argv,argc,target);
1357 }
1358
1359 /* Call() is the core of Redis execution of a command */
1360 void call(redisClient *c, int flags) {
1361 long long dirty, start = ustime(), duration;
1362
1363 /* Sent the command to clients in MONITOR mode, only if the commands are
1364 * not geneated from reading an AOF. */
1365 if (listLength(server.monitors) && !server.loading)
1366 replicationFeedMonitors(c,server.monitors,c->db->id,c->argv,c->argc);
1367
1368 /* Call the command. */
1369 redisOpArrayInit(&server.also_propagate);
1370 dirty = server.dirty;
1371 c->cmd->proc(c);
1372 dirty = server.dirty-dirty;
1373 duration = ustime()-start;
1374
1375 /* When EVAL is called loading the AOF we don't want commands called
1376 * from Lua to go into the slowlog or to populate statistics. */
1377 if (server.loading && c->flags & REDIS_LUA_CLIENT)
1378 flags &= ~(REDIS_CALL_SLOWLOG | REDIS_CALL_STATS);
1379
1380 /* Log the command into the Slow log if needed, and populate the
1381 * per-command statistics that we show in INFO commandstats. */
1382 if (flags & REDIS_CALL_SLOWLOG)
1383 slowlogPushEntryIfNeeded(c->argv,c->argc,duration);
1384 if (flags & REDIS_CALL_STATS) {
1385 c->cmd->microseconds += duration;
1386 c->cmd->calls++;
1387 }
1388
1389 /* Propagate the command into the AOF and replication link */
1390 if (flags & REDIS_CALL_PROPAGATE) {
1391 int flags = REDIS_PROPAGATE_NONE;
1392
1393 if (c->cmd->flags & REDIS_CMD_FORCE_REPLICATION)
1394 flags |= REDIS_PROPAGATE_REPL;
1395 if (dirty)
1396 flags |= (REDIS_PROPAGATE_REPL | REDIS_PROPAGATE_AOF);
1397 if (flags != REDIS_PROPAGATE_NONE)
1398 propagate(c->cmd,c->db->id,c->argv,c->argc,flags);
1399 }
1400 /* Commands such as LPUSH or BRPOPLPUSH may propagate an additional
1401 * PUSH command. */
1402 if (server.also_propagate.numops) {
1403 int j;
1404 redisOp *rop;
1405
1406 for (j = 0; j < server.also_propagate.numops; j++) {
1407 rop = &server.also_propagate.ops[j];
1408 propagate(rop->cmd, rop->dbid, rop->argv, rop->argc, rop->target);
1409 }
1410 redisOpArrayFree(&server.also_propagate);
1411 }
1412 server.stat_numcommands++;
1413 }
1414
1415 /* If this function gets called we already read a whole
1416 * command, argments are in the client argv/argc fields.
1417 * processCommand() execute the command or prepare the
1418 * server for a bulk read from the client.
1419 *
1420 * If 1 is returned the client is still alive and valid and
1421 * and other operations can be performed by the caller. Otherwise
1422 * if 0 is returned the client was destroied (i.e. after QUIT). */
1423 int processCommand(redisClient *c) {
1424 /* The QUIT command is handled separately. Normal command procs will
1425 * go through checking for replication and QUIT will cause trouble
1426 * when FORCE_REPLICATION is enabled and would be implemented in
1427 * a regular command proc. */
1428 if (!strcasecmp(c->argv[0]->ptr,"quit")) {
1429 addReply(c,shared.ok);
1430 c->flags |= REDIS_CLOSE_AFTER_REPLY;
1431 return REDIS_ERR;
1432 }
1433
1434 /* Now lookup the command and check ASAP about trivial error conditions
1435 * such as wrong arity, bad command name and so forth. */
1436 c->cmd = c->lastcmd = lookupCommand(c->argv[0]->ptr);
1437 if (!c->cmd) {
1438 addReplyErrorFormat(c,"unknown command '%s'",
1439 (char*)c->argv[0]->ptr);
1440 return REDIS_OK;
1441 } else if ((c->cmd->arity > 0 && c->cmd->arity != c->argc) ||
1442 (c->argc < -c->cmd->arity)) {
1443 addReplyErrorFormat(c,"wrong number of arguments for '%s' command",
1444 c->cmd->name);
1445 return REDIS_OK;
1446 }
1447
1448 /* Check if the user is authenticated */
1449 if (server.requirepass && !c->authenticated && c->cmd->proc != authCommand)
1450 {
1451 addReplyError(c,"operation not permitted");
1452 return REDIS_OK;
1453 }
1454
1455 /* If cluster is enabled, redirect here */
1456 if (server.cluster_enabled &&
1457 !(c->cmd->getkeys_proc == NULL && c->cmd->firstkey == 0)) {
1458 int hashslot;
1459
1460 if (server.cluster.state != REDIS_CLUSTER_OK) {
1461 addReplyError(c,"The cluster is down. Check with CLUSTER INFO for more information");
1462 return REDIS_OK;
1463 } else {
1464 int ask;
1465 clusterNode *n = getNodeByQuery(c,c->cmd,c->argv,c->argc,&hashslot,&ask);
1466 if (n == NULL) {
1467 addReplyError(c,"Multi keys request invalid in cluster");
1468 return REDIS_OK;
1469 } else if (n != server.cluster.myself) {
1470 addReplySds(c,sdscatprintf(sdsempty(),
1471 "-%s %d %s:%d\r\n", ask ? "ASK" : "MOVED",
1472 hashslot,n->ip,n->port));
1473 return REDIS_OK;
1474 }
1475 }
1476 }
1477
1478 /* Handle the maxmemory directive.
1479 *
1480 * First we try to free some memory if possible (if there are volatile
1481 * keys in the dataset). If there are not the only thing we can do
1482 * is returning an error. */
1483 if (server.maxmemory) {
1484 int retval = freeMemoryIfNeeded();
1485 if ((c->cmd->flags & REDIS_CMD_DENYOOM) && retval == REDIS_ERR) {
1486 addReplyError(c,
1487 "command not allowed when used memory > 'maxmemory'");
1488 return REDIS_OK;
1489 }
1490 }
1491
1492 /* Don't accept write commands if there are problems persisting on disk. */
1493 if (server.stop_writes_on_bgsave_err &&
1494 server.saveparamslen > 0
1495 && server.lastbgsave_status == REDIS_ERR &&
1496 c->cmd->flags & REDIS_CMD_WRITE)
1497 {
1498 addReply(c, shared.bgsaveerr);
1499 return REDIS_OK;
1500 }
1501
1502 /* Only allow SUBSCRIBE and UNSUBSCRIBE in the context of Pub/Sub */
1503 if ((dictSize(c->pubsub_channels) > 0 || listLength(c->pubsub_patterns) > 0)
1504 &&
1505 c->cmd->proc != subscribeCommand &&
1506 c->cmd->proc != unsubscribeCommand &&
1507 c->cmd->proc != psubscribeCommand &&
1508 c->cmd->proc != punsubscribeCommand) {
1509 addReplyError(c,"only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context");
1510 return REDIS_OK;
1511 }
1512
1513 /* Only allow INFO and SLAVEOF when slave-serve-stale-data is no and
1514 * we are a slave with a broken link with master. */
1515 if (server.masterhost && server.repl_state != REDIS_REPL_CONNECTED &&
1516 server.repl_serve_stale_data == 0 &&
1517 c->cmd->proc != infoCommand && c->cmd->proc != slaveofCommand)
1518 {
1519 addReplyError(c,
1520 "link with MASTER is down and slave-serve-stale-data is set to no");
1521 return REDIS_OK;
1522 }
1523
1524 /* Loading DB? Return an error if the command is not INFO */
1525 if (server.loading && c->cmd->proc != infoCommand) {
1526 addReply(c, shared.loadingerr);
1527 return REDIS_OK;
1528 }
1529
1530 /* Lua script too slow? Only allow SHUTDOWN NOSAVE and SCRIPT KILL. */
1531 if (server.lua_timedout &&
1532 !(c->cmd->proc != shutdownCommand &&
1533 c->argc == 2 &&
1534 tolower(((char*)c->argv[1]->ptr)[0]) == 'n') &&
1535 !(c->cmd->proc == scriptCommand &&
1536 c->argc == 2 &&
1537 tolower(((char*)c->argv[1]->ptr)[0]) == 'k'))
1538 {
1539 addReply(c, shared.slowscripterr);
1540 return REDIS_OK;
1541 }
1542
1543 /* Exec the command */
1544 if (c->flags & REDIS_MULTI &&
1545 c->cmd->proc != execCommand && c->cmd->proc != discardCommand &&
1546 c->cmd->proc != multiCommand && c->cmd->proc != watchCommand)
1547 {
1548 queueMultiCommand(c);
1549 addReply(c,shared.queued);
1550 } else {
1551 call(c,REDIS_CALL_FULL);
1552 }
1553 return REDIS_OK;
1554 }
1555
1556 /*================================== Shutdown =============================== */
1557
1558 int prepareForShutdown(int flags) {
1559 int save = flags & REDIS_SHUTDOWN_SAVE;
1560 int nosave = flags & REDIS_SHUTDOWN_NOSAVE;
1561
1562 redisLog(REDIS_WARNING,"User requested shutdown...");
1563 /* Kill the saving child if there is a background saving in progress.
1564 We want to avoid race conditions, for instance our saving child may
1565 overwrite the synchronous saving did by SHUTDOWN. */
1566 if (server.rdb_child_pid != -1) {
1567 redisLog(REDIS_WARNING,"There is a child saving an .rdb. Killing it!");
1568 kill(server.rdb_child_pid,SIGKILL);
1569 rdbRemoveTempFile(server.rdb_child_pid);
1570 }
1571 if (server.aof_state != REDIS_AOF_OFF) {
1572 /* Kill the AOF saving child as the AOF we already have may be longer
1573 * but contains the full dataset anyway. */
1574 if (server.aof_child_pid != -1) {
1575 redisLog(REDIS_WARNING,
1576 "There is a child rewriting the AOF. Killing it!");
1577 kill(server.aof_child_pid,SIGKILL);
1578 }
1579 /* Append only file: fsync() the AOF and exit */
1580 redisLog(REDIS_NOTICE,"Calling fsync() on the AOF file.");
1581 aof_fsync(server.aof_fd);
1582 }
1583 if ((server.saveparamslen > 0 && !nosave) || save) {
1584 redisLog(REDIS_NOTICE,"Saving the final RDB snapshot before exiting.");
1585 /* Snapshotting. Perform a SYNC SAVE and exit */
1586 if (rdbSave(server.rdb_filename) != REDIS_OK) {
1587 /* Ooops.. error saving! The best we can do is to continue
1588 * operating. Note that if there was a background saving process,
1589 * in the next cron() Redis will be notified that the background
1590 * saving aborted, handling special stuff like slaves pending for
1591 * synchronization... */
1592 redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit.");
1593 return REDIS_ERR;
1594 }
1595 }
1596 if (server.daemonize) {
1597 redisLog(REDIS_NOTICE,"Removing the pid file.");
1598 unlink(server.pidfile);
1599 }
1600 /* Close the listening sockets. Apparently this allows faster restarts. */
1601 if (server.ipfd != -1) close(server.ipfd);
1602 if (server.sofd != -1) close(server.sofd);
1603 if (server.unixsocket) {
1604 redisLog(REDIS_NOTICE,"Removing the unix socket file.");
1605 unlink(server.unixsocket); /* don't care if this fails */
1606 }
1607
1608 redisLog(REDIS_WARNING,"Redis is now ready to exit, bye bye...");
1609 return REDIS_OK;
1610 }
1611
1612 /*================================== Commands =============================== */
1613
1614 void authCommand(redisClient *c) {
1615 if (!server.requirepass) {
1616 addReplyError(c,"Client sent AUTH, but no password is set");
1617 } else if (!strcmp(c->argv[1]->ptr, server.requirepass)) {
1618 c->authenticated = 1;
1619 addReply(c,shared.ok);
1620 } else {
1621 c->authenticated = 0;
1622 addReplyError(c,"invalid password");
1623 }
1624 }
1625
1626 void pingCommand(redisClient *c) {
1627 addReply(c,shared.pong);
1628 }
1629
1630 void echoCommand(redisClient *c) {
1631 addReplyBulk(c,c->argv[1]);
1632 }
1633
1634 void timeCommand(redisClient *c) {
1635 struct timeval tv;
1636
1637 /* gettimeofday() can only fail if &tv is a bad addresss so we
1638 * don't check for errors. */
1639 gettimeofday(&tv,NULL);
1640 addReplyMultiBulkLen(c,2);
1641 addReplyBulkLongLong(c,tv.tv_sec);
1642 addReplyBulkLongLong(c,tv.tv_usec);
1643 }
1644
1645 /* Convert an amount of bytes into a human readable string in the form
1646 * of 100B, 2G, 100M, 4K, and so forth. */
1647 void bytesToHuman(char *s, unsigned long long n) {
1648 double d;
1649
1650 if (n < 1024) {
1651 /* Bytes */
1652 sprintf(s,"%lluB",n);
1653 return;
1654 } else if (n < (1024*1024)) {
1655 d = (double)n/(1024);
1656 sprintf(s,"%.2fK",d);
1657 } else if (n < (1024LL*1024*1024)) {
1658 d = (double)n/(1024*1024);
1659 sprintf(s,"%.2fM",d);
1660 } else if (n < (1024LL*1024*1024*1024)) {
1661 d = (double)n/(1024LL*1024*1024);
1662 sprintf(s,"%.2fG",d);
1663 }
1664 }
1665
1666 /* Create the string returned by the INFO command. This is decoupled
1667 * by the INFO command itself as we need to report the same information
1668 * on memory corruption problems. */
1669 sds genRedisInfoString(char *section) {
1670 sds info = sdsempty();
1671 time_t uptime = time(NULL)-server.stat_starttime;
1672 int j, numcommands;
1673 struct rusage self_ru, c_ru;
1674 unsigned long lol, bib;
1675 int allsections = 0, defsections = 0;
1676 int sections = 0;
1677
1678 if (section) {
1679 allsections = strcasecmp(section,"all") == 0;
1680 defsections = strcasecmp(section,"default") == 0;
1681 }
1682
1683 getrusage(RUSAGE_SELF, &self_ru);
1684 getrusage(RUSAGE_CHILDREN, &c_ru);
1685 getClientsMaxBuffers(&lol,&bib);
1686
1687 /* Server */
1688 if (allsections || defsections || !strcasecmp(section,"server")) {
1689 if (sections++) info = sdscat(info,"\r\n");
1690 info = sdscatprintf(info,
1691 "# Server\r\n"
1692 "redis_version:%s\r\n"
1693 "redis_git_sha1:%s\r\n"
1694 "redis_git_dirty:%d\r\n"
1695 "arch_bits:%d\r\n"
1696 "multiplexing_api:%s\r\n"
1697 "gcc_version:%d.%d.%d\r\n"
1698 "process_id:%ld\r\n"
1699 "run_id:%s\r\n"
1700 "tcp_port:%d\r\n"
1701 "uptime_in_seconds:%ld\r\n"
1702 "uptime_in_days:%ld\r\n"
1703 "lru_clock:%ld\r\n",
1704 REDIS_VERSION,
1705 redisGitSHA1(),
1706 strtol(redisGitDirty(),NULL,10) > 0,
1707 server.arch_bits,
1708 aeGetApiName(),
1709 #ifdef __GNUC__
1710 __GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__,
1711 #else
1712 0,0,0,
1713 #endif
1714 (long) getpid(),
1715 server.runid,
1716 server.port,
1717 uptime,
1718 uptime/(3600*24),
1719 (unsigned long) server.lruclock);
1720 }
1721
1722 /* Clients */
1723 if (allsections || defsections || !strcasecmp(section,"clients")) {
1724 if (sections++) info = sdscat(info,"\r\n");
1725 info = sdscatprintf(info,
1726 "# Clients\r\n"
1727 "connected_clients:%lu\r\n"
1728 "client_longest_output_list:%lu\r\n"
1729 "client_biggest_input_buf:%lu\r\n"
1730 "blocked_clients:%d\r\n",
1731 listLength(server.clients)-listLength(server.slaves),
1732 lol, bib,
1733 server.bpop_blocked_clients);
1734 }
1735
1736 /* Memory */
1737 if (allsections || defsections || !strcasecmp(section,"memory")) {
1738 char hmem[64];
1739 char peak_hmem[64];
1740
1741 bytesToHuman(hmem,zmalloc_used_memory());
1742 bytesToHuman(peak_hmem,server.stat_peak_memory);
1743 if (sections++) info = sdscat(info,"\r\n");
1744 info = sdscatprintf(info,
1745 "# Memory\r\n"
1746 "used_memory:%zu\r\n"
1747 "used_memory_human:%s\r\n"
1748 "used_memory_rss:%zu\r\n"
1749 "used_memory_peak:%zu\r\n"
1750 "used_memory_peak_human:%s\r\n"
1751 "used_memory_lua:%lld\r\n"
1752 "mem_fragmentation_ratio:%.2f\r\n"
1753 "mem_allocator:%s\r\n",
1754 zmalloc_used_memory(),
1755 hmem,
1756 zmalloc_get_rss(),
1757 server.stat_peak_memory,
1758 peak_hmem,
1759 ((long long)lua_gc(server.lua,LUA_GCCOUNT,0))*1024LL,
1760 zmalloc_get_fragmentation_ratio(),
1761 ZMALLOC_LIB
1762 );
1763 }
1764
1765 /* Persistence */
1766 if (allsections || defsections || !strcasecmp(section,"persistence")) {
1767 if (sections++) info = sdscat(info,"\r\n");
1768 info = sdscatprintf(info,
1769 "# Persistence\r\n"
1770 "loading:%d\r\n"
1771 "aof_enabled:%d\r\n"
1772 "changes_since_last_save:%lld\r\n"
1773 "bgsave_in_progress:%d\r\n"
1774 "last_save_time:%ld\r\n"
1775 "last_bgsave_status:%s\r\n"
1776 "bgrewriteaof_in_progress:%d\r\n",
1777 server.loading,
1778 server.aof_state != REDIS_AOF_OFF,
1779 server.dirty,
1780 server.rdb_child_pid != -1,
1781 server.lastsave,
1782 server.lastbgsave_status == REDIS_OK ? "ok" : "err",
1783 server.aof_child_pid != -1);
1784
1785 if (server.aof_state != REDIS_AOF_OFF) {
1786 info = sdscatprintf(info,
1787 "aof_current_size:%lld\r\n"
1788 "aof_base_size:%lld\r\n"
1789 "aof_pending_rewrite:%d\r\n"
1790 "aof_buffer_length:%zu\r\n"
1791 "aof_pending_bio_fsync:%llu\r\n",
1792 (long long) server.aof_current_size,
1793 (long long) server.aof_rewrite_base_size,
1794 server.aof_rewrite_scheduled,
1795 sdslen(server.aof_buf),
1796 bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC));
1797 }
1798
1799 if (server.loading) {
1800 double perc;
1801 time_t eta, elapsed;
1802 off_t remaining_bytes = server.loading_total_bytes-
1803 server.loading_loaded_bytes;
1804
1805 perc = ((double)server.loading_loaded_bytes /
1806 server.loading_total_bytes) * 100;
1807
1808 elapsed = time(NULL)-server.loading_start_time;
1809 if (elapsed == 0) {
1810 eta = 1; /* A fake 1 second figure if we don't have
1811 enough info */
1812 } else {
1813 eta = (elapsed*remaining_bytes)/server.loading_loaded_bytes;
1814 }
1815
1816 info = sdscatprintf(info,
1817 "loading_start_time:%ld\r\n"
1818 "loading_total_bytes:%llu\r\n"
1819 "loading_loaded_bytes:%llu\r\n"
1820 "loading_loaded_perc:%.2f\r\n"
1821 "loading_eta_seconds:%ld\r\n"
1822 ,(unsigned long) server.loading_start_time,
1823 (unsigned long long) server.loading_total_bytes,
1824 (unsigned long long) server.loading_loaded_bytes,
1825 perc,
1826 eta
1827 );
1828 }
1829 }
1830
1831 /* Stats */
1832 if (allsections || defsections || !strcasecmp(section,"stats")) {
1833 if (sections++) info = sdscat(info,"\r\n");
1834 info = sdscatprintf(info,
1835 "# Stats\r\n"
1836 "total_connections_received:%lld\r\n"
1837 "total_commands_processed:%lld\r\n"
1838 "instantaneous_ops_per_sec:%lld\r\n"
1839 "rejected_connections:%lld\r\n"
1840 "expired_keys:%lld\r\n"
1841 "evicted_keys:%lld\r\n"
1842 "keyspace_hits:%lld\r\n"
1843 "keyspace_misses:%lld\r\n"
1844 "pubsub_channels:%ld\r\n"
1845 "pubsub_patterns:%lu\r\n"
1846 "latest_fork_usec:%lld\r\n",
1847 server.stat_numconnections,
1848 server.stat_numcommands,
1849 getOperationsPerSecond(),
1850 server.stat_rejected_conn,
1851 server.stat_expiredkeys,
1852 server.stat_evictedkeys,
1853 server.stat_keyspace_hits,
1854 server.stat_keyspace_misses,
1855 dictSize(server.pubsub_channels),
1856 listLength(server.pubsub_patterns),
1857 server.stat_fork_time);
1858 }
1859
1860 /* Replication */
1861 if (allsections || defsections || !strcasecmp(section,"replication")) {
1862 if (sections++) info = sdscat(info,"\r\n");
1863 info = sdscatprintf(info,
1864 "# Replication\r\n"
1865 "role:%s\r\n",
1866 server.masterhost == NULL ? "master" : "slave");
1867 if (server.masterhost) {
1868 info = sdscatprintf(info,
1869 "master_host:%s\r\n"
1870 "master_port:%d\r\n"
1871 "master_link_status:%s\r\n"
1872 "master_last_io_seconds_ago:%d\r\n"
1873 "master_sync_in_progress:%d\r\n"
1874 ,server.masterhost,
1875 server.masterport,
1876 (server.repl_state == REDIS_REPL_CONNECTED) ?
1877 "up" : "down",
1878 server.master ?
1879 ((int)(time(NULL)-server.master->lastinteraction)) : -1,
1880 server.repl_state == REDIS_REPL_TRANSFER
1881 );
1882
1883 if (server.repl_state == REDIS_REPL_TRANSFER) {
1884 info = sdscatprintf(info,
1885 "master_sync_left_bytes:%ld\r\n"
1886 "master_sync_last_io_seconds_ago:%d\r\n"
1887 ,(long)server.repl_transfer_left,
1888 (int)(time(NULL)-server.repl_transfer_lastio)
1889 );
1890 }
1891
1892 if (server.repl_state != REDIS_REPL_CONNECTED) {
1893 info = sdscatprintf(info,
1894 "master_link_down_since_seconds:%ld\r\n",
1895 (long)time(NULL)-server.repl_down_since);
1896 }
1897 }
1898 info = sdscatprintf(info,
1899 "connected_slaves:%lu\r\n",
1900 listLength(server.slaves));
1901 if (listLength(server.slaves)) {
1902 int slaveid = 0;
1903 listNode *ln;
1904 listIter li;
1905
1906 listRewind(server.slaves,&li);
1907 while((ln = listNext(&li))) {
1908 redisClient *slave = listNodeValue(ln);
1909 char *state = NULL;
1910 char ip[32];
1911 int port;
1912
1913 if (anetPeerToString(slave->fd,ip,&port) == -1) continue;
1914 switch(slave->replstate) {
1915 case REDIS_REPL_WAIT_BGSAVE_START:
1916 case REDIS_REPL_WAIT_BGSAVE_END:
1917 state = "wait_bgsave";
1918 break;
1919 case REDIS_REPL_SEND_BULK:
1920 state = "send_bulk";
1921 break;
1922 case REDIS_REPL_ONLINE:
1923 state = "online";
1924 break;
1925 }
1926 if (state == NULL) continue;
1927 info = sdscatprintf(info,"slave%d:%s,%d,%s\r\n",
1928 slaveid,ip,port,state);
1929 slaveid++;
1930 }
1931 }
1932 }
1933
1934 /* CPU */
1935 if (allsections || defsections || !strcasecmp(section,"cpu")) {
1936 if (sections++) info = sdscat(info,"\r\n");
1937 info = sdscatprintf(info,
1938 "# CPU\r\n"
1939 "used_cpu_sys:%.2f\r\n"
1940 "used_cpu_user:%.2f\r\n"
1941 "used_cpu_sys_children:%.2f\r\n"
1942 "used_cpu_user_children:%.2f\r\n",
1943 (float)self_ru.ru_stime.tv_sec+(float)self_ru.ru_stime.tv_usec/1000000,
1944 (float)self_ru.ru_utime.tv_sec+(float)self_ru.ru_utime.tv_usec/1000000,
1945 (float)c_ru.ru_stime.tv_sec+(float)c_ru.ru_stime.tv_usec/1000000,
1946 (float)c_ru.ru_utime.tv_sec+(float)c_ru.ru_utime.tv_usec/1000000);
1947 }
1948
1949 /* cmdtime */
1950 if (allsections || !strcasecmp(section,"commandstats")) {
1951 if (sections++) info = sdscat(info,"\r\n");
1952 info = sdscatprintf(info, "# Commandstats\r\n");
1953 numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
1954 for (j = 0; j < numcommands; j++) {
1955 struct redisCommand *c = redisCommandTable+j;
1956
1957 if (!c->calls) continue;
1958 info = sdscatprintf(info,
1959 "cmdstat_%s:calls=%lld,usec=%lld,usec_per_call=%.2f\r\n",
1960 c->name, c->calls, c->microseconds,
1961 (c->calls == 0) ? 0 : ((float)c->microseconds/c->calls));
1962 }
1963 }
1964
1965 /* Clusetr */
1966 if (allsections || defsections || !strcasecmp(section,"cluster")) {
1967 if (sections++) info = sdscat(info,"\r\n");
1968 info = sdscatprintf(info,
1969 "# Cluster\r\n"
1970 "cluster_enabled:%d\r\n",
1971 server.cluster_enabled);
1972 }
1973
1974 /* Key space */
1975 if (allsections || defsections || !strcasecmp(section,"keyspace")) {
1976 if (sections++) info = sdscat(info,"\r\n");
1977 info = sdscatprintf(info, "# Keyspace\r\n");
1978 for (j = 0; j < server.dbnum; j++) {
1979 long long keys, vkeys;
1980
1981 keys = dictSize(server.db[j].dict);
1982 vkeys = dictSize(server.db[j].expires);
1983 if (keys || vkeys) {
1984 info = sdscatprintf(info, "db%d:keys=%lld,expires=%lld\r\n",
1985 j, keys, vkeys);
1986 }
1987 }
1988 }
1989 return info;
1990 }
1991
1992 void infoCommand(redisClient *c) {
1993 char *section = c->argc == 2 ? c->argv[1]->ptr : "default";
1994
1995 if (c->argc > 2) {
1996 addReply(c,shared.syntaxerr);
1997 return;
1998 }
1999 sds info = genRedisInfoString(section);
2000 addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
2001 (unsigned long)sdslen(info)));
2002 addReplySds(c,info);
2003 addReply(c,shared.crlf);
2004 }
2005
2006 void monitorCommand(redisClient *c) {
2007 /* ignore MONITOR if aleady slave or in monitor mode */
2008 if (c->flags & REDIS_SLAVE) return;
2009
2010 c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
2011 c->slaveseldb = 0;
2012 listAddNodeTail(server.monitors,c);
2013 addReply(c,shared.ok);
2014 }
2015
2016 /* ============================ Maxmemory directive ======================== */
2017
2018 /* This function gets called when 'maxmemory' is set on the config file to limit
2019 * the max memory used by the server, before processing a command.
2020 *
2021 * The goal of the function is to free enough memory to keep Redis under the
2022 * configured memory limit.
2023 *
2024 * The function starts calculating how many bytes should be freed to keep
2025 * Redis under the limit, and enters a loop selecting the best keys to
2026 * evict accordingly to the configured policy.
2027 *
2028 * If all the bytes needed to return back under the limit were freed the
2029 * function returns REDIS_OK, otherwise REDIS_ERR is returned, and the caller
2030 * should block the execution of commands that will result in more memory
2031 * used by the server.
2032 */
2033 int freeMemoryIfNeeded(void) {
2034 size_t mem_used, mem_tofree, mem_freed;
2035 int slaves = listLength(server.slaves);
2036
2037 /* Remove the size of slaves output buffers and AOF buffer from the
2038 * count of used memory. */
2039 mem_used = zmalloc_used_memory();
2040 if (slaves) {
2041 listIter li;
2042 listNode *ln;
2043
2044 listRewind(server.slaves,&li);
2045 while((ln = listNext(&li))) {
2046 redisClient *slave = listNodeValue(ln);
2047 unsigned long obuf_bytes = getClientOutputBufferMemoryUsage(slave);
2048 if (obuf_bytes > mem_used)
2049 mem_used = 0;
2050 else
2051 mem_used -= obuf_bytes;
2052 }
2053 }
2054 if (server.aof_state != REDIS_AOF_OFF) {
2055 mem_used -= sdslen(server.aof_buf);
2056 mem_used -= sdslen(server.aof_rewrite_buf);
2057 }
2058
2059 /* Check if we are over the memory limit. */
2060 if (mem_used <= server.maxmemory) return REDIS_OK;
2061
2062 if (server.maxmemory_policy == REDIS_MAXMEMORY_NO_EVICTION)
2063 return REDIS_ERR; /* We need to free memory, but policy forbids. */
2064
2065 /* Compute how much memory we need to free. */
2066 mem_tofree = mem_used - server.maxmemory;
2067 mem_freed = 0;
2068 while (mem_freed < mem_tofree) {
2069 int j, k, keys_freed = 0;
2070
2071 for (j = 0; j < server.dbnum; j++) {
2072 long bestval = 0; /* just to prevent warning */
2073 sds bestkey = NULL;
2074 struct dictEntry *de;
2075 redisDb *db = server.db+j;
2076 dict *dict;
2077
2078 if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
2079 server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM)
2080 {
2081 dict = server.db[j].dict;
2082 } else {
2083 dict = server.db[j].expires;
2084 }
2085 if (dictSize(dict) == 0) continue;
2086
2087 /* volatile-random and allkeys-random policy */
2088 if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM ||
2089 server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
2090 {
2091 de = dictGetRandomKey(dict);
2092 bestkey = dictGetKey(de);
2093 }
2094
2095 /* volatile-lru and allkeys-lru policy */
2096 else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
2097 server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
2098 {
2099 for (k = 0; k < server.maxmemory_samples; k++) {
2100 sds thiskey;
2101 long thisval;
2102 robj *o;
2103
2104 de = dictGetRandomKey(dict);
2105 thiskey = dictGetKey(de);
2106 /* When policy is volatile-lru we need an additonal lookup
2107 * to locate the real key, as dict is set to db->expires. */
2108 if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
2109 de = dictFind(db->dict, thiskey);
2110 o = dictGetVal(de);
2111 thisval = estimateObjectIdleTime(o);
2112
2113 /* Higher idle time is better candidate for deletion */
2114 if (bestkey == NULL || thisval > bestval) {
2115 bestkey = thiskey;
2116 bestval = thisval;
2117 }
2118 }
2119 }
2120
2121 /* volatile-ttl */
2122 else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) {
2123 for (k = 0; k < server.maxmemory_samples; k++) {
2124 sds thiskey;
2125 long thisval;
2126
2127 de = dictGetRandomKey(dict);
2128 thiskey = dictGetKey(de);
2129 thisval = (long) dictGetVal(de);
2130
2131 /* Expire sooner (minor expire unix timestamp) is better
2132 * candidate for deletion */
2133 if (bestkey == NULL || thisval < bestval) {
2134 bestkey = thiskey;
2135 bestval = thisval;
2136 }
2137 }
2138 }
2139
2140 /* Finally remove the selected key. */
2141 if (bestkey) {
2142 long long delta;
2143
2144 robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
2145 propagateExpire(db,keyobj);
2146 /* We compute the amount of memory freed by dbDelete() alone.
2147 * It is possible that actually the memory needed to propagate
2148 * the DEL in AOF and replication link is greater than the one
2149 * we are freeing removing the key, but we can't account for
2150 * that otherwise we would never exit the loop.
2151 *
2152 * AOF and Output buffer memory will be freed eventually so
2153 * we only care about memory used by the key space. */
2154 delta = (long long) zmalloc_used_memory();
2155 dbDelete(db,keyobj);
2156 delta -= (long long) zmalloc_used_memory();
2157 mem_freed += delta;
2158 server.stat_evictedkeys++;
2159 decrRefCount(keyobj);
2160 keys_freed++;
2161
2162 /* When the memory to free starts to be big enough, we may
2163 * start spending so much time here that is impossible to
2164 * deliver data to the slaves fast enough, so we force the
2165 * transmission here inside the loop. */
2166 if (slaves) flushSlavesOutputBuffers();
2167 }
2168 }
2169 if (!keys_freed) return REDIS_ERR; /* nothing to free... */
2170 }
2171 return REDIS_OK;
2172 }
2173
2174 /* =================================== Main! ================================ */
2175
2176 #ifdef __linux__
2177 int linuxOvercommitMemoryValue(void) {
2178 FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r");
2179 char buf[64];
2180
2181 if (!fp) return -1;
2182 if (fgets(buf,64,fp) == NULL) {
2183 fclose(fp);
2184 return -1;
2185 }
2186 fclose(fp);
2187
2188 return atoi(buf);
2189 }
2190
2191 void linuxOvercommitMemoryWarning(void) {
2192 if (linuxOvercommitMemoryValue() == 0) {
2193 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.");
2194 }
2195 }
2196 #endif /* __linux__ */
2197
2198 void createPidFile(void) {
2199 /* Try to write the pid file in a best-effort way. */
2200 FILE *fp = fopen(server.pidfile,"w");
2201 if (fp) {
2202 fprintf(fp,"%d\n",(int)getpid());
2203 fclose(fp);
2204 }
2205 }
2206
2207 void daemonize(void) {
2208 int fd;
2209
2210 if (fork() != 0) exit(0); /* parent exits */
2211 setsid(); /* create a new session */
2212
2213 /* Every output goes to /dev/null. If Redis is daemonized but
2214 * the 'logfile' is set to 'stdout' in the configuration file
2215 * it will not log at all. */
2216 if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
2217 dup2(fd, STDIN_FILENO);
2218 dup2(fd, STDOUT_FILENO);
2219 dup2(fd, STDERR_FILENO);
2220 if (fd > STDERR_FILENO) close(fd);
2221 }
2222 }
2223
2224 void version() {
2225 printf("Redis server version %s (%s:%d)\n", REDIS_VERSION,
2226 redisGitSHA1(), atoi(redisGitDirty()) > 0);
2227 exit(0);
2228 }
2229
2230 void usage() {
2231 fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf] [options]\n");
2232 fprintf(stderr," ./redis-server - (read config from stdin)\n");
2233 fprintf(stderr," ./redis-server -v or --version\n");
2234 fprintf(stderr," ./redis-server -h or --help\n");
2235 fprintf(stderr," ./redis-server --test-memory <megabytes>\n\n");
2236 fprintf(stderr,"Examples:\n");
2237 fprintf(stderr," ./redis-server (run the server with default conf)\n");
2238 fprintf(stderr," ./redis-server /etc/redis/6379.conf\n");
2239 fprintf(stderr," ./redis-server --port 7777\n");
2240 fprintf(stderr," ./redis-server --port 7777 --slaveof 127.0.0.1 8888\n");
2241 fprintf(stderr," ./redis-server /etc/myredis.conf --loglevel verbose\n");
2242 exit(1);
2243 }
2244
2245 void redisAsciiArt(void) {
2246 #include "asciilogo.h"
2247 char *buf = zmalloc(1024*16);
2248
2249 snprintf(buf,1024*16,ascii_logo,
2250 REDIS_VERSION,
2251 redisGitSHA1(),
2252 strtol(redisGitDirty(),NULL,10) > 0,
2253 (sizeof(long) == 8) ? "64" : "32",
2254 server.cluster_enabled ? "cluster" : "stand alone",
2255 server.port,
2256 (long) getpid()
2257 );
2258 redisLogRaw(REDIS_NOTICE|REDIS_LOG_RAW,buf);
2259 zfree(buf);
2260 }
2261
2262 static void sigtermHandler(int sig) {
2263 REDIS_NOTUSED(sig);
2264
2265 redisLog(REDIS_WARNING,"Received SIGTERM, scheduling shutdown...");
2266 server.shutdown_asap = 1;
2267 }
2268
2269 void setupSignalHandlers(void) {
2270 struct sigaction act;
2271
2272 /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction is used.
2273 * Otherwise, sa_handler is used. */
2274 sigemptyset(&act.sa_mask);
2275 act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;
2276 act.sa_handler = sigtermHandler;
2277 sigaction(SIGTERM, &act, NULL);
2278
2279 #ifdef HAVE_BACKTRACE
2280 sigemptyset(&act.sa_mask);
2281 act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;
2282 act.sa_sigaction = sigsegvHandler;
2283 sigaction(SIGSEGV, &act, NULL);
2284 sigaction(SIGBUS, &act, NULL);
2285 sigaction(SIGFPE, &act, NULL);
2286 sigaction(SIGILL, &act, NULL);
2287 #endif
2288 return;
2289 }
2290
2291 void memtest(size_t megabytes, int passes);
2292
2293 int main(int argc, char **argv) {
2294 long long start;
2295 struct timeval tv;
2296
2297 /* We need to initialize our libraries, and the server configuration. */
2298 zmalloc_enable_thread_safeness();
2299 srand(time(NULL)^getpid());
2300 gettimeofday(&tv,NULL);
2301 dictSetHashFunctionSeed(tv.tv_sec^tv.tv_usec^getpid());
2302 initServerConfig();
2303
2304 if (argc >= 2) {
2305 int j = 1; /* First option to parse in argv[] */
2306 sds options = sdsempty();
2307 char *configfile = NULL;
2308
2309 /* Handle special options --help and --version */
2310 if (strcmp(argv[1], "-v") == 0 ||
2311 strcmp(argv[1], "--version") == 0) version();
2312 if (strcmp(argv[1], "--help") == 0 ||
2313 strcmp(argv[1], "-h") == 0) usage();
2314 if (strcmp(argv[1], "--test-memory") == 0) {
2315 if (argc == 3) {
2316 memtest(atoi(argv[2]),300);
2317 exit(0);
2318 } else {
2319 fprintf(stderr,"Please specify the amount of memory to test in megabytes.\n");
2320 fprintf(stderr,"Example: ./redis-server --test-memory 4096\n\n");
2321 exit(1);
2322 }
2323 }
2324
2325 /* First argument is the config file name? */
2326 if (argv[j][0] != '-' || argv[j][1] != '-')
2327 configfile = argv[j++];
2328 /* All the other options are parsed and conceptually appended to the
2329 * configuration file. For instance --port 6380 will generate the
2330 * string "port 6380\n" to be parsed after the actual file name
2331 * is parsed, if any. */
2332 while(j != argc) {
2333 if (argv[j][0] == '-' && argv[j][1] == '-') {
2334 /* Option name */
2335 if (sdslen(options)) options = sdscat(options,"\n");
2336 options = sdscat(options,argv[j]+2);
2337 options = sdscat(options," ");
2338 } else {
2339 /* Option argument */
2340 options = sdscatrepr(options,argv[j],strlen(argv[j]));
2341 options = sdscat(options," ");
2342 }
2343 j++;
2344 }
2345 resetServerSaveParams();
2346 loadServerConfig(configfile,options);
2347 sdsfree(options);
2348 } else {
2349 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'");
2350 }
2351 if (server.daemonize) daemonize();
2352 initServer();
2353 if (server.daemonize) createPidFile();
2354 redisAsciiArt();
2355 redisLog(REDIS_WARNING,"Server started, Redis version " REDIS_VERSION);
2356 #ifdef __linux__
2357 linuxOvercommitMemoryWarning();
2358 #endif
2359 start = ustime();
2360 if (server.aof_state == REDIS_AOF_ON) {
2361 if (loadAppendOnlyFile(server.aof_filename) == REDIS_OK)
2362 redisLog(REDIS_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);
2363 } else {
2364 if (rdbLoad(server.rdb_filename) == REDIS_OK) {
2365 redisLog(REDIS_NOTICE,"DB loaded from disk: %.3f seconds",
2366 (float)(ustime()-start)/1000000);
2367 } else if (errno != ENOENT) {
2368 redisLog(REDIS_WARNING,"Fatal error loading the DB. Exiting.");
2369 exit(1);
2370 }
2371 }
2372 if (server.ipfd > 0)
2373 redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);
2374 if (server.sofd > 0)
2375 redisLog(REDIS_NOTICE,"The server is now ready to accept connections at %s", server.unixsocket);
2376 aeSetBeforeSleepProc(server.el,beforeSleep);
2377 aeMain(server.el);
2378 aeDeleteEventLoop(server.el);
2379 return 0;
2380 }
2381
2382 /* The End */