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