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