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