2 * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
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.
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.
41 #include <arpa/inet.h>
45 #include <sys/resource.h>
50 #include <sys/resource.h>
52 /* Our shared "common" objects */
54 struct sharedObjectsStruct shared
;
56 /* Global vars that are actually used as constants. The following double
57 * values are used for double on-disk serialization, and are initialized
58 * at runtime to avoid strange compiler optimizations. */
60 double R_Zero
, R_PosInf
, R_NegInf
, R_Nan
;
62 /*================================= Globals ================================= */
65 struct redisServer server
; /* server global state */
66 struct redisCommand
*commandTable
;
70 * Every entry is composed of the following fields:
72 * name: a string representing the command name.
73 * function: pointer to the C function implementing the command.
74 * arity: number of arguments, it is possible to use -N to say >= N
75 * sflags: command flags as string. See below for a table of flags.
76 * flags: flags as bitmask. Computed by Redis using the 'sflags' field.
77 * get_keys_proc: an optional function to get key arguments from a command.
78 * This is only used when the following three fields are not
79 * enough to specify what arguments are keys.
80 * first_key_index: first argument that is a key
81 * last_key_index: last argument that is a key
82 * key_step: step to get all the keys from first to last argument. For instance
83 * in MSET the step is two since arguments are key,val,key,val,...
84 * microseconds: microseconds of total execution time for this command.
85 * calls: total number of calls of this command.
87 * The flags, microseconds and calls fields are computed by Redis and should
88 * always be set to zero.
90 * Command flags are expressed using strings where every character represents
91 * a flag. Later the populateCommandTable() function will take care of
92 * populating the real 'flags' field using this characters.
94 * This is the meaning of the flags:
96 * w: write command (may modify the key space).
97 * r: read command (will never modify the key space).
98 * m: may increase memory usage once called. Don't allow if out of memory.
99 * a: admin command, like SAVE or SHUTDOWN.
100 * p: Pub/Sub related command.
101 * f: force replication of this command, regarless of server.dirty.
102 * s: command not allowed in scripts.
103 * R: random command. Command is not deterministic, that is, the same command
104 * with the same arguments, with the same key space, may have different
105 * results. For instance SPOP and RANDOMKEY are two random commands.
106 * S: Sort command output array if called from script, so that the output
109 struct redisCommand redisCommandTable
[] = {
110 {"get",getCommand
,2,"r",0,NULL
,1,1,1,0,0},
111 {"set",setCommand
,3,"wm",0,noPreloadGetKeys
,1,1,1,0,0},
112 {"setnx",setnxCommand
,3,"wm",0,noPreloadGetKeys
,1,1,1,0,0},
113 {"setex",setexCommand
,4,"wm",0,noPreloadGetKeys
,1,1,1,0,0},
114 {"psetex",psetexCommand
,4,"wm",0,noPreloadGetKeys
,1,1,1,0,0},
115 {"append",appendCommand
,3,"wm",0,NULL
,1,1,1,0,0},
116 {"strlen",strlenCommand
,2,"r",0,NULL
,1,1,1,0,0},
117 {"del",delCommand
,-2,"w",0,noPreloadGetKeys
,1,-1,1,0,0},
118 {"exists",existsCommand
,2,"r",0,NULL
,1,1,1,0,0},
119 {"setbit",setbitCommand
,4,"wm",0,NULL
,1,1,1,0,0},
120 {"getbit",getbitCommand
,3,"r",0,NULL
,1,1,1,0,0},
121 {"setrange",setrangeCommand
,4,"wm",0,NULL
,1,1,1,0,0},
122 {"getrange",getrangeCommand
,4,"r",0,NULL
,1,1,1,0,0},
123 {"substr",getrangeCommand
,4,"r",0,NULL
,1,1,1,0,0},
124 {"incr",incrCommand
,2,"wm",0,NULL
,1,1,1,0,0},
125 {"decr",decrCommand
,2,"wm",0,NULL
,1,1,1,0,0},
126 {"mget",mgetCommand
,-2,"r",0,NULL
,1,-1,1,0,0},
127 {"rpush",rpushCommand
,-3,"wm",0,NULL
,1,1,1,0,0},
128 {"lpush",lpushCommand
,-3,"wm",0,NULL
,1,1,1,0,0},
129 {"rpushx",rpushxCommand
,3,"wm",0,NULL
,1,1,1,0,0},
130 {"lpushx",lpushxCommand
,3,"wm",0,NULL
,1,1,1,0,0},
131 {"linsert",linsertCommand
,5,"wm",0,NULL
,1,1,1,0,0},
132 {"rpop",rpopCommand
,2,"w",0,NULL
,1,1,1,0,0},
133 {"lpop",lpopCommand
,2,"w",0,NULL
,1,1,1,0,0},
134 {"brpop",brpopCommand
,-3,"ws",0,NULL
,1,1,1,0,0},
135 {"brpoplpush",brpoplpushCommand
,4,"wms",0,NULL
,1,2,1,0,0},
136 {"blpop",blpopCommand
,-3,"ws",0,NULL
,1,-2,1,0,0},
137 {"llen",llenCommand
,2,"r",0,NULL
,1,1,1,0,0},
138 {"lindex",lindexCommand
,3,"r",0,NULL
,1,1,1,0,0},
139 {"lset",lsetCommand
,4,"wm",0,NULL
,1,1,1,0,0},
140 {"lrange",lrangeCommand
,4,"r",0,NULL
,1,1,1,0,0},
141 {"ltrim",ltrimCommand
,4,"w",0,NULL
,1,1,1,0,0},
142 {"lrem",lremCommand
,4,"w",0,NULL
,1,1,1,0,0},
143 {"rpoplpush",rpoplpushCommand
,3,"wm",0,NULL
,1,2,1,0,0},
144 {"sadd",saddCommand
,-3,"wm",0,NULL
,1,1,1,0,0},
145 {"srem",sremCommand
,-3,"w",0,NULL
,1,1,1,0,0},
146 {"smove",smoveCommand
,4,"w",0,NULL
,1,2,1,0,0},
147 {"sismember",sismemberCommand
,3,"r",0,NULL
,1,1,1,0,0},
148 {"scard",scardCommand
,2,"r",0,NULL
,1,1,1,0,0},
149 {"spop",spopCommand
,2,"wRs",0,NULL
,1,1,1,0,0},
150 {"srandmember",srandmemberCommand
,2,"rR",0,NULL
,1,1,1,0,0},
151 {"sinter",sinterCommand
,-2,"rS",0,NULL
,1,-1,1,0,0},
152 {"sinterstore",sinterstoreCommand
,-3,"wm",0,NULL
,1,-1,1,0,0},
153 {"sunion",sunionCommand
,-2,"rS",0,NULL
,1,-1,1,0,0},
154 {"sunionstore",sunionstoreCommand
,-3,"wm",0,NULL
,1,-1,1,0,0},
155 {"sdiff",sdiffCommand
,-2,"rS",0,NULL
,1,-1,1,0,0},
156 {"sdiffstore",sdiffstoreCommand
,-3,"wm",0,NULL
,1,-1,1,0,0},
157 {"smembers",sinterCommand
,2,"rS",0,NULL
,1,1,1,0,0},
158 {"zadd",zaddCommand
,-4,"wm",0,NULL
,1,1,1,0,0},
159 {"zincrby",zincrbyCommand
,4,"wm",0,NULL
,1,1,1,0,0},
160 {"zrem",zremCommand
,-3,"w",0,NULL
,1,1,1,0,0},
161 {"zremrangebyscore",zremrangebyscoreCommand
,4,"w",0,NULL
,1,1,1,0,0},
162 {"zremrangebyrank",zremrangebyrankCommand
,4,"w",0,NULL
,1,1,1,0,0},
163 {"zunionstore",zunionstoreCommand
,-4,"wm",0,zunionInterGetKeys
,0,0,0,0,0},
164 {"zinterstore",zinterstoreCommand
,-4,"wm",0,zunionInterGetKeys
,0,0,0,0,0},
165 {"zrange",zrangeCommand
,-4,"r",0,NULL
,1,1,1,0,0},
166 {"zrangebyscore",zrangebyscoreCommand
,-4,"r",0,NULL
,1,1,1,0,0},
167 {"zrevrangebyscore",zrevrangebyscoreCommand
,-4,"r",0,NULL
,1,1,1,0,0},
168 {"zcount",zcountCommand
,4,"r",0,NULL
,1,1,1,0,0},
169 {"zrevrange",zrevrangeCommand
,-4,"r",0,NULL
,1,1,1,0,0},
170 {"zcard",zcardCommand
,2,"r",0,NULL
,1,1,1,0,0},
171 {"zscore",zscoreCommand
,3,"r",0,NULL
,1,1,1,0,0},
172 {"zrank",zrankCommand
,3,"r",0,NULL
,1,1,1,0,0},
173 {"zrevrank",zrevrankCommand
,3,"r",0,NULL
,1,1,1,0,0},
174 {"hset",hsetCommand
,4,"wm",0,NULL
,1,1,1,0,0},
175 {"hsetnx",hsetnxCommand
,4,"wm",0,NULL
,1,1,1,0,0},
176 {"hget",hgetCommand
,3,"r",0,NULL
,1,1,1,0,0},
177 {"hmset",hmsetCommand
,-4,"wm",0,NULL
,1,1,1,0,0},
178 {"hmget",hmgetCommand
,-3,"r",0,NULL
,1,1,1,0,0},
179 {"hincrby",hincrbyCommand
,4,"wm",0,NULL
,1,1,1,0,0},
180 {"hincrbyfloat",hincrbyfloatCommand
,4,"wm",0,NULL
,1,1,1,0,0},
181 {"hdel",hdelCommand
,-3,"w",0,NULL
,1,1,1,0,0},
182 {"hlen",hlenCommand
,2,"r",0,NULL
,1,1,1,0,0},
183 {"hkeys",hkeysCommand
,2,"rS",0,NULL
,1,1,1,0,0},
184 {"hvals",hvalsCommand
,2,"rS",0,NULL
,1,1,1,0,0},
185 {"hgetall",hgetallCommand
,2,"r",0,NULL
,1,1,1,0,0},
186 {"hexists",hexistsCommand
,3,"r",0,NULL
,1,1,1,0,0},
187 {"incrby",incrbyCommand
,3,"wm",0,NULL
,1,1,1,0,0},
188 {"decrby",decrbyCommand
,3,"wm",0,NULL
,1,1,1,0,0},
189 {"incrbyfloat",incrbyfloatCommand
,3,"wm",0,NULL
,1,1,1,0,0},
190 {"getset",getsetCommand
,3,"wm",0,NULL
,1,1,1,0,0},
191 {"mset",msetCommand
,-3,"wm",0,NULL
,1,-1,2,0,0},
192 {"msetnx",msetnxCommand
,-3,"wm",0,NULL
,1,-1,2,0,0},
193 {"randomkey",randomkeyCommand
,1,"rR",0,NULL
,0,0,0,0,0},
194 {"select",selectCommand
,2,"r",0,NULL
,0,0,0,0,0},
195 {"move",moveCommand
,3,"w",0,NULL
,1,1,1,0,0},
196 {"rename",renameCommand
,3,"w",0,renameGetKeys
,1,2,1,0,0},
197 {"renamenx",renamenxCommand
,3,"w",0,renameGetKeys
,1,2,1,0,0},
198 {"expire",expireCommand
,3,"w",0,NULL
,1,1,1,0,0},
199 {"expireat",expireatCommand
,3,"w",0,NULL
,1,1,1,0,0},
200 {"pexpire",pexpireCommand
,3,"w",0,NULL
,1,1,1,0,0},
201 {"pexpireat",pexpireatCommand
,3,"w",0,NULL
,1,1,1,0,0},
202 {"keys",keysCommand
,2,"rS",0,NULL
,0,0,0,0,0},
203 {"dbsize",dbsizeCommand
,1,"r",0,NULL
,0,0,0,0,0},
204 {"auth",authCommand
,2,"rs",0,NULL
,0,0,0,0,0},
205 {"ping",pingCommand
,1,"r",0,NULL
,0,0,0,0,0},
206 {"echo",echoCommand
,2,"r",0,NULL
,0,0,0,0,0},
207 {"save",saveCommand
,1,"ars",0,NULL
,0,0,0,0,0},
208 {"bgsave",bgsaveCommand
,1,"ar",0,NULL
,0,0,0,0,0},
209 {"bgrewriteaof",bgrewriteaofCommand
,1,"ar",0,NULL
,0,0,0,0,0},
210 {"shutdown",shutdownCommand
,-1,"ar",0,NULL
,0,0,0,0,0},
211 {"lastsave",lastsaveCommand
,1,"r",0,NULL
,0,0,0,0,0},
212 {"type",typeCommand
,2,"r",0,NULL
,1,1,1,0,0},
213 {"multi",multiCommand
,1,"rs",0,NULL
,0,0,0,0,0},
214 {"exec",execCommand
,1,"wms",0,NULL
,0,0,0,0,0},
215 {"discard",discardCommand
,1,"rs",0,NULL
,0,0,0,0,0},
216 {"sync",syncCommand
,1,"ars",0,NULL
,0,0,0,0,0},
217 {"flushdb",flushdbCommand
,1,"w",0,NULL
,0,0,0,0,0},
218 {"flushall",flushallCommand
,1,"w",0,NULL
,0,0,0,0,0},
219 {"sort",sortCommand
,-2,"wmS",0,NULL
,1,1,1,0,0},
220 {"info",infoCommand
,-1,"r",0,NULL
,0,0,0,0,0},
221 {"monitor",monitorCommand
,1,"ars",0,NULL
,0,0,0,0,0},
222 {"ttl",ttlCommand
,2,"r",0,NULL
,1,1,1,0,0},
223 {"pttl",pttlCommand
,2,"r",0,NULL
,1,1,1,0,0},
224 {"persist",persistCommand
,2,"w",0,NULL
,1,1,1,0,0},
225 {"slaveof",slaveofCommand
,3,"aws",0,NULL
,0,0,0,0,0},
226 {"debug",debugCommand
,-2,"aws",0,NULL
,0,0,0,0,0},
227 {"config",configCommand
,-2,"ar",0,NULL
,0,0,0,0,0},
228 {"subscribe",subscribeCommand
,-2,"rps",0,NULL
,0,0,0,0,0},
229 {"unsubscribe",unsubscribeCommand
,-1,"rps",0,NULL
,0,0,0,0,0},
230 {"psubscribe",psubscribeCommand
,-2,"rps",0,NULL
,0,0,0,0,0},
231 {"punsubscribe",punsubscribeCommand
,-1,"rps",0,NULL
,0,0,0,0,0},
232 {"publish",publishCommand
,3,"rpf",0,NULL
,0,0,0,0,0},
233 {"watch",watchCommand
,-2,"rs",0,noPreloadGetKeys
,1,-1,1,0,0},
234 {"unwatch",unwatchCommand
,1,"rs",0,NULL
,0,0,0,0,0},
235 {"cluster",clusterCommand
,-2,"ar",0,NULL
,0,0,0,0,0},
236 {"restore",restoreCommand
,4,"awm",0,NULL
,1,1,1,0,0},
237 {"migrate",migrateCommand
,6,"aw",0,NULL
,0,0,0,0,0},
238 {"asking",askingCommand
,1,"r",0,NULL
,0,0,0,0,0},
239 {"dump",dumpCommand
,2,"ar",0,NULL
,1,1,1,0,0},
240 {"object",objectCommand
,-2,"r",0,NULL
,2,2,2,0,0},
241 {"client",clientCommand
,-2,"ar",0,NULL
,0,0,0,0,0},
242 {"eval",evalCommand
,-3,"wms",0,zunionInterGetKeys
,0,0,0,0,0},
243 {"evalsha",evalShaCommand
,-3,"wms",0,zunionInterGetKeys
,0,0,0,0,0},
244 {"slowlog",slowlogCommand
,-2,"r",0,NULL
,0,0,0,0,0},
245 {"script",scriptCommand
,-2,"ras",0,NULL
,0,0,0,0,0},
246 {"time",timeCommand
,1,"rR",0,NULL
,0,0,0,0,0}
249 /*============================ Utility functions ============================ */
251 /* Low level logging. To use only for very big messages, otherwise
252 * redisLog() is to prefer. */
253 void redisLogRaw(int level
, const char *msg
) {
254 const int syslogLevelMap
[] = { LOG_DEBUG
, LOG_INFO
, LOG_NOTICE
, LOG_WARNING
};
255 const char *c
= ".-*#";
256 time_t now
= time(NULL
);
259 int rawmode
= (level
& REDIS_LOG_RAW
);
261 level
&= 0xff; /* clear flags */
262 if (level
< server
.verbosity
) return;
264 fp
= (server
.logfile
== NULL
) ? stdout
: fopen(server
.logfile
,"a");
268 fprintf(fp
,"%s",msg
);
270 strftime(buf
,sizeof(buf
),"%d %b %H:%M:%S",localtime(&now
));
271 fprintf(fp
,"[%d] %s %c %s\n",(int)getpid(),buf
,c
[level
],msg
);
275 if (server
.logfile
) fclose(fp
);
277 if (server
.syslog_enabled
) syslog(syslogLevelMap
[level
], "%s", msg
);
280 /* Like redisLogRaw() but with printf-alike support. This is the funciton that
281 * is used across the code. The raw version is only used in order to dump
282 * the INFO output on crash. */
283 void redisLog(int level
, const char *fmt
, ...) {
285 char msg
[REDIS_MAX_LOGMSG_LEN
];
287 if ((level
&0xff) < server
.verbosity
) return;
290 vsnprintf(msg
, sizeof(msg
), fmt
, ap
);
293 redisLogRaw(level
,msg
);
296 /* Redis generally does not try to recover from out of memory conditions
297 * when allocating objects or strings, it is not clear if it will be possible
298 * to report this condition to the client since the networking layer itself
299 * is based on heap allocation for send buffers, so we simply abort.
300 * At least the code will be simpler to read... */
301 void oom(const char *msg
) {
302 redisLog(REDIS_WARNING
, "%s: Out of memory\n",msg
);
307 /* Return the UNIX time in microseconds */
308 long long ustime(void) {
312 gettimeofday(&tv
, NULL
);
313 ust
= ((long long)tv
.tv_sec
)*1000000;
318 /* Return the UNIX time in milliseconds */
319 long long mstime(void) {
320 return ustime()/1000;
323 /*====================== Hash table type implementation ==================== */
325 /* This is an hash table type that uses the SDS dynamic strings libary as
326 * keys and radis objects as values (objects can hold SDS strings,
329 void dictVanillaFree(void *privdata
, void *val
)
331 DICT_NOTUSED(privdata
);
335 void dictListDestructor(void *privdata
, void *val
)
337 DICT_NOTUSED(privdata
);
338 listRelease((list
*)val
);
341 int dictSdsKeyCompare(void *privdata
, const void *key1
,
345 DICT_NOTUSED(privdata
);
347 l1
= sdslen((sds
)key1
);
348 l2
= sdslen((sds
)key2
);
349 if (l1
!= l2
) return 0;
350 return memcmp(key1
, key2
, l1
) == 0;
353 /* A case insensitive version used for the command lookup table. */
354 int dictSdsKeyCaseCompare(void *privdata
, const void *key1
,
357 DICT_NOTUSED(privdata
);
359 return strcasecmp(key1
, key2
) == 0;
362 void dictRedisObjectDestructor(void *privdata
, void *val
)
364 DICT_NOTUSED(privdata
);
366 if (val
== NULL
) return; /* Values of swapped out keys as set to NULL */
370 void dictSdsDestructor(void *privdata
, void *val
)
372 DICT_NOTUSED(privdata
);
377 int dictObjKeyCompare(void *privdata
, const void *key1
,
380 const robj
*o1
= key1
, *o2
= key2
;
381 return dictSdsKeyCompare(privdata
,o1
->ptr
,o2
->ptr
);
384 unsigned int dictObjHash(const void *key
) {
386 return dictGenHashFunction(o
->ptr
, sdslen((sds
)o
->ptr
));
389 unsigned int dictSdsHash(const void *key
) {
390 return dictGenHashFunction((unsigned char*)key
, sdslen((char*)key
));
393 unsigned int dictSdsCaseHash(const void *key
) {
394 return dictGenCaseHashFunction((unsigned char*)key
, sdslen((char*)key
));
397 int dictEncObjKeyCompare(void *privdata
, const void *key1
,
400 robj
*o1
= (robj
*) key1
, *o2
= (robj
*) key2
;
403 if (o1
->encoding
== REDIS_ENCODING_INT
&&
404 o2
->encoding
== REDIS_ENCODING_INT
)
405 return o1
->ptr
== o2
->ptr
;
407 o1
= getDecodedObject(o1
);
408 o2
= getDecodedObject(o2
);
409 cmp
= dictSdsKeyCompare(privdata
,o1
->ptr
,o2
->ptr
);
415 unsigned int dictEncObjHash(const void *key
) {
416 robj
*o
= (robj
*) key
;
418 if (o
->encoding
== REDIS_ENCODING_RAW
) {
419 return dictGenHashFunction(o
->ptr
, sdslen((sds
)o
->ptr
));
421 if (o
->encoding
== REDIS_ENCODING_INT
) {
425 len
= ll2string(buf
,32,(long)o
->ptr
);
426 return dictGenHashFunction((unsigned char*)buf
, len
);
430 o
= getDecodedObject(o
);
431 hash
= dictGenHashFunction(o
->ptr
, sdslen((sds
)o
->ptr
));
438 /* Sets type hash table */
439 dictType setDictType
= {
440 dictEncObjHash
, /* hash function */
443 dictEncObjKeyCompare
, /* key compare */
444 dictRedisObjectDestructor
, /* key destructor */
445 NULL
/* val destructor */
448 /* Sorted sets hash (note: a skiplist is used in addition to the hash table) */
449 dictType zsetDictType
= {
450 dictEncObjHash
, /* hash function */
453 dictEncObjKeyCompare
, /* key compare */
454 dictRedisObjectDestructor
, /* key destructor */
455 NULL
/* val destructor */
458 /* Db->dict, keys are sds strings, vals are Redis objects. */
459 dictType dbDictType
= {
460 dictSdsHash
, /* hash function */
463 dictSdsKeyCompare
, /* key compare */
464 dictSdsDestructor
, /* key destructor */
465 dictRedisObjectDestructor
/* val destructor */
469 dictType keyptrDictType
= {
470 dictSdsHash
, /* hash function */
473 dictSdsKeyCompare
, /* key compare */
474 NULL
, /* key destructor */
475 NULL
/* val destructor */
478 /* Command table. sds string -> command struct pointer. */
479 dictType commandTableDictType
= {
480 dictSdsCaseHash
, /* hash function */
483 dictSdsKeyCaseCompare
, /* key compare */
484 dictSdsDestructor
, /* key destructor */
485 NULL
/* val destructor */
488 /* Hash type hash table (note that small hashes are represented with zimpaps) */
489 dictType hashDictType
= {
490 dictEncObjHash
, /* hash function */
493 dictEncObjKeyCompare
, /* key compare */
494 dictRedisObjectDestructor
, /* key destructor */
495 dictRedisObjectDestructor
/* val destructor */
498 /* Keylist hash table type has unencoded redis objects as keys and
499 * lists as values. It's used for blocking operations (BLPOP) and to
500 * map swapped keys to a list of clients waiting for this keys to be loaded. */
501 dictType keylistDictType
= {
502 dictObjHash
, /* hash function */
505 dictObjKeyCompare
, /* key compare */
506 dictRedisObjectDestructor
, /* key destructor */
507 dictListDestructor
/* val destructor */
510 /* Cluster nodes hash table, mapping nodes addresses 1.2.3.4:6379 to
511 * clusterNode structures. */
512 dictType clusterNodesDictType
= {
513 dictSdsHash
, /* hash function */
516 dictSdsKeyCompare
, /* key compare */
517 dictSdsDestructor
, /* key destructor */
518 NULL
/* val destructor */
521 int htNeedsResize(dict
*dict
) {
522 long long size
, used
;
524 size
= dictSlots(dict
);
525 used
= dictSize(dict
);
526 return (size
&& used
&& size
> DICT_HT_INITIAL_SIZE
&&
527 (used
*100/size
< REDIS_HT_MINFILL
));
530 /* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
531 * we resize the hash table to save memory */
532 void tryResizeHashTables(void) {
535 for (j
= 0; j
< server
.dbnum
; j
++) {
536 if (htNeedsResize(server
.db
[j
].dict
))
537 dictResize(server
.db
[j
].dict
);
538 if (htNeedsResize(server
.db
[j
].expires
))
539 dictResize(server
.db
[j
].expires
);
543 /* Our hash table implementation performs rehashing incrementally while
544 * we write/read from the hash table. Still if the server is idle, the hash
545 * table will use two tables for a long time. So we try to use 1 millisecond
546 * of CPU time at every serverCron() loop in order to rehash some key. */
547 void incrementallyRehash(void) {
550 for (j
= 0; j
< server
.dbnum
; j
++) {
551 if (dictIsRehashing(server
.db
[j
].dict
)) {
552 dictRehashMilliseconds(server
.db
[j
].dict
,1);
553 break; /* already used our millisecond for this loop... */
558 /* This function is called once a background process of some kind terminates,
559 * as we want to avoid resizing the hash tables when there is a child in order
560 * to play well with copy-on-write (otherwise when a resize happens lots of
561 * memory pages are copied). The goal of this function is to update the ability
562 * for dict.c to resize the hash tables accordingly to the fact we have o not
564 void updateDictResizePolicy(void) {
565 if (server
.rdb_child_pid
== -1 && server
.aof_child_pid
== -1)
571 /* ======================= Cron: called every 100 ms ======================== */
573 /* Try to expire a few timed out keys. The algorithm used is adaptive and
574 * will use few CPU cycles if there are few expiring keys, otherwise
575 * it will get more aggressive to avoid that too much memory is used by
576 * keys that can be removed from the keyspace. */
577 void activeExpireCycle(void) {
580 for (j
= 0; j
< server
.dbnum
; j
++) {
582 redisDb
*db
= server
.db
+j
;
584 /* Continue to expire if at the end of the cycle more than 25%
585 * of the keys were expired. */
587 long num
= dictSize(db
->expires
);
588 long long now
= mstime();
591 if (num
> REDIS_EXPIRELOOKUPS_PER_CRON
)
592 num
= REDIS_EXPIRELOOKUPS_PER_CRON
;
597 if ((de
= dictGetRandomKey(db
->expires
)) == NULL
) break;
598 t
= dictGetSignedIntegerVal(de
);
600 sds key
= dictGetKey(de
);
601 robj
*keyobj
= createStringObject(key
,sdslen(key
));
603 propagateExpire(db
,keyobj
);
605 decrRefCount(keyobj
);
607 server
.stat_expiredkeys
++;
610 } while (expired
> REDIS_EXPIRELOOKUPS_PER_CRON
/4);
614 void updateLRUClock(void) {
615 server
.lruclock
= (time(NULL
)/REDIS_LRU_CLOCK_RESOLUTION
) &
620 /* Add a sample to the operations per second array of samples. */
621 void trackOperationsPerSecond(void) {
622 long long t
= mstime() - server
.ops_sec_last_sample_time
;
623 long long ops
= server
.stat_numcommands
- server
.ops_sec_last_sample_ops
;
626 ops_sec
= t
> 0 ? (ops
*1000/t
) : 0;
628 server
.ops_sec_samples
[server
.ops_sec_idx
] = ops_sec
;
629 server
.ops_sec_idx
= (server
.ops_sec_idx
+1) % REDIS_OPS_SEC_SAMPLES
;
630 server
.ops_sec_last_sample_time
= mstime();
631 server
.ops_sec_last_sample_ops
= server
.stat_numcommands
;
634 /* Return the mean of all the samples. */
635 long long getOperationsPerSecond(void) {
639 for (j
= 0; j
< REDIS_OPS_SEC_SAMPLES
; j
++)
640 sum
+= server
.ops_sec_samples
[j
];
641 return sum
/ REDIS_OPS_SEC_SAMPLES
;
644 /* Check for timeouts. Returns non-zero if the client was terminated */
645 int clientsCronHandleTimeout(redisClient
*c
) {
646 time_t now
= server
.unixtime
;
648 if (server
.maxidletime
&&
649 !(c
->flags
& REDIS_SLAVE
) && /* no timeout for slaves */
650 !(c
->flags
& REDIS_MASTER
) && /* no timeout for masters */
651 !(c
->flags
& REDIS_BLOCKED
) && /* no timeout for BLPOP */
652 dictSize(c
->pubsub_channels
) == 0 && /* no timeout for pubsub */
653 listLength(c
->pubsub_patterns
) == 0 &&
654 (now
- c
->lastinteraction
> server
.maxidletime
))
656 redisLog(REDIS_VERBOSE
,"Closing idle client");
659 } else if (c
->flags
& REDIS_BLOCKED
) {
660 if (c
->bpop
.timeout
!= 0 && c
->bpop
.timeout
< now
) {
661 addReply(c
,shared
.nullmultibulk
);
662 unblockClientWaitingData(c
);
668 /* The client query buffer is an sds.c string that can end with a lot of
669 * free space not used, this function reclaims space if needed.
671 * The funciton always returns 0 as it never terminates the client. */
672 int clientsCronResizeQueryBuffer(redisClient
*c
) {
673 size_t querybuf_size
= sdsAllocSize(c
->querybuf
);
674 time_t idletime
= server
.unixtime
- c
->lastinteraction
;
676 /* There are two conditions to resize the query buffer:
677 * 1) Query buffer is > BIG_ARG and too big for latest peak.
678 * 2) Client is inactive and the buffer is bigger than 1k. */
679 if (((querybuf_size
> REDIS_MBULK_BIG_ARG
) &&
680 (querybuf_size
/(c
->querybuf_peak
+1)) > 2) ||
681 (querybuf_size
> 1024 && idletime
> 2))
683 /* Only resize the query buffer if it is actually wasting space. */
684 if (sdsavail(c
->querybuf
) > 1024) {
685 c
->querybuf
= sdsRemoveFreeSpace(c
->querybuf
);
688 /* Reset the peak again to capture the peak memory usage in the next
690 c
->querybuf_peak
= 0;
694 void clientsCron(void) {
695 /* Make sure to process at least 1/100 of clients per call.
696 * Since this function is called 10 times per second we are sure that
697 * in the worst case we process all the clients in 10 seconds.
698 * In normal conditions (a reasonable number of clients) we process
699 * all the clients in a shorter time. */
700 int numclients
= listLength(server
.clients
);
701 int iterations
= numclients
/100;
704 iterations
= (numclients
< 50) ? numclients
: 50;
705 while(listLength(server
.clients
) && iterations
--) {
709 /* Rotate the list, take the current head, process.
710 * This way if the client must be removed from the list it's the
711 * first element and we don't incur into O(N) computation. */
712 listRotate(server
.clients
);
713 head
= listFirst(server
.clients
);
714 c
= listNodeValue(head
);
715 /* The following functions do different service checks on the client.
716 * The protocol is that they return non-zero if the client was
718 if (clientsCronHandleTimeout(c
)) continue;
719 if (clientsCronResizeQueryBuffer(c
)) continue;
723 int serverCron(struct aeEventLoop
*eventLoop
, long long id
, void *clientData
) {
724 int j
, loops
= server
.cronloops
;
725 REDIS_NOTUSED(eventLoop
);
727 REDIS_NOTUSED(clientData
);
729 /* We take a cached value of the unix time in the global state because
730 * with virtual memory and aging there is to store the current time
731 * in objects at every object access, and accuracy is not needed.
732 * To access a global var is faster than calling time(NULL) */
733 server
.unixtime
= time(NULL
);
735 trackOperationsPerSecond();
737 /* We have just 22 bits per object for LRU information.
738 * So we use an (eventually wrapping) LRU clock with 10 seconds resolution.
739 * 2^22 bits with 10 seconds resoluton is more or less 1.5 years.
741 * Note that even if this will wrap after 1.5 years it's not a problem,
742 * everything will still work but just some object will appear younger
743 * to Redis. But for this to happen a given object should never be touched
746 * Note that you can change the resolution altering the
747 * REDIS_LRU_CLOCK_RESOLUTION define.
751 /* Record the max memory used since the server was started. */
752 if (zmalloc_used_memory() > server
.stat_peak_memory
)
753 server
.stat_peak_memory
= zmalloc_used_memory();
755 /* We received a SIGTERM, shutting down here in a safe way, as it is
756 * not ok doing so inside the signal handler. */
757 if (server
.shutdown_asap
) {
758 if (prepareForShutdown(0) == REDIS_OK
) exit(0);
759 redisLog(REDIS_WARNING
,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
762 /* Show some info about non-empty databases */
763 for (j
= 0; j
< server
.dbnum
; j
++) {
764 long long size
, used
, vkeys
;
766 size
= dictSlots(server
.db
[j
].dict
);
767 used
= dictSize(server
.db
[j
].dict
);
768 vkeys
= dictSize(server
.db
[j
].expires
);
769 if (!(loops
% 50) && (used
|| vkeys
)) {
770 redisLog(REDIS_VERBOSE
,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j
,used
,vkeys
,size
);
771 /* dictPrintStats(server.dict); */
775 /* We don't want to resize the hash tables while a bacground saving
776 * is in progress: the saving child is created using fork() that is
777 * implemented with a copy-on-write semantic in most modern systems, so
778 * if we resize the HT while there is the saving child at work actually
779 * a lot of memory movements in the parent will cause a lot of pages
781 if (server
.rdb_child_pid
== -1 && server
.aof_child_pid
== -1) {
782 if (!(loops
% 10)) tryResizeHashTables();
783 if (server
.activerehashing
) incrementallyRehash();
786 /* Show information about connected clients */
788 redisLog(REDIS_VERBOSE
,"%d clients connected (%d slaves), %zu bytes in use",
789 listLength(server
.clients
)-listLength(server
.slaves
),
790 listLength(server
.slaves
),
791 zmalloc_used_memory());
794 /* We need to do a few operations on clients asynchronously. */
797 /* Start a scheduled AOF rewrite if this was requested by the user while
798 * a BGSAVE was in progress. */
799 if (server
.rdb_child_pid
== -1 && server
.aof_child_pid
== -1 &&
800 server
.aof_rewrite_scheduled
)
802 rewriteAppendOnlyFileBackground();
805 /* Check if a background saving or AOF rewrite in progress terminated. */
806 if (server
.rdb_child_pid
!= -1 || server
.aof_child_pid
!= -1) {
810 if ((pid
= wait3(&statloc
,WNOHANG
,NULL
)) != 0) {
811 int exitcode
= WEXITSTATUS(statloc
);
814 if (WIFSIGNALED(statloc
)) bysignal
= WTERMSIG(statloc
);
816 if (pid
== server
.rdb_child_pid
) {
817 backgroundSaveDoneHandler(exitcode
,bysignal
);
819 backgroundRewriteDoneHandler(exitcode
,bysignal
);
821 updateDictResizePolicy();
824 time_t now
= time(NULL
);
826 /* If there is not a background saving/rewrite in progress check if
827 * we have to save/rewrite now */
828 for (j
= 0; j
< server
.saveparamslen
; j
++) {
829 struct saveparam
*sp
= server
.saveparams
+j
;
831 if (server
.dirty
>= sp
->changes
&&
832 now
-server
.lastsave
> sp
->seconds
) {
833 redisLog(REDIS_NOTICE
,"%d changes in %d seconds. Saving...",
834 sp
->changes
, sp
->seconds
);
835 rdbSaveBackground(server
.rdb_filename
);
840 /* Trigger an AOF rewrite if needed */
841 if (server
.rdb_child_pid
== -1 &&
842 server
.aof_child_pid
== -1 &&
843 server
.aof_rewrite_perc
&&
844 server
.aof_current_size
> server
.aof_rewrite_min_size
)
846 long long base
= server
.aof_rewrite_base_size
?
847 server
.aof_rewrite_base_size
: 1;
848 long long growth
= (server
.aof_current_size
*100/base
) - 100;
849 if (growth
>= server
.aof_rewrite_perc
) {
850 redisLog(REDIS_NOTICE
,"Starting automatic rewriting of AOF on %lld%% growth",growth
);
851 rewriteAppendOnlyFileBackground();
857 /* If we postponed an AOF buffer flush, let's try to do it every time the
858 * cron function is called. */
859 if (server
.aof_flush_postponed_start
) flushAppendOnlyFile(0);
861 /* Expire a few keys per cycle, only if this is a master.
862 * On slaves we wait for DEL operations synthesized by the master
863 * in order to guarantee a strict consistency. */
864 if (server
.masterhost
== NULL
) activeExpireCycle();
866 /* Close clients that need to be closed asynchronous */
867 freeClientsInAsyncFreeQueue();
869 /* Replication cron function -- used to reconnect to master and
870 * to detect transfer failures. */
871 if (!(loops
% 10)) replicationCron();
873 /* Run other sub-systems specific cron jobs */
874 if (server
.cluster_enabled
&& !(loops
% 10)) clusterCron();
880 /* This function gets called every time Redis is entering the
881 * main loop of the event driven library, that is, before to sleep
882 * for ready file descriptors. */
883 void beforeSleep(struct aeEventLoop
*eventLoop
) {
884 REDIS_NOTUSED(eventLoop
);
888 /* Try to process pending commands for clients that were just unblocked. */
889 while (listLength(server
.unblocked_clients
)) {
890 ln
= listFirst(server
.unblocked_clients
);
891 redisAssert(ln
!= NULL
);
893 listDelNode(server
.unblocked_clients
,ln
);
894 c
->flags
&= ~REDIS_UNBLOCKED
;
896 /* Process remaining data in the input buffer. */
897 if (c
->querybuf
&& sdslen(c
->querybuf
) > 0) {
898 server
.current_client
= c
;
899 processInputBuffer(c
);
900 server
.current_client
= NULL
;
904 /* Write the AOF buffer on disk */
905 flushAppendOnlyFile(0);
908 /* =========================== Server initialization ======================== */
910 void createSharedObjects(void) {
913 shared
.crlf
= createObject(REDIS_STRING
,sdsnew("\r\n"));
914 shared
.ok
= createObject(REDIS_STRING
,sdsnew("+OK\r\n"));
915 shared
.err
= createObject(REDIS_STRING
,sdsnew("-ERR\r\n"));
916 shared
.emptybulk
= createObject(REDIS_STRING
,sdsnew("$0\r\n\r\n"));
917 shared
.czero
= createObject(REDIS_STRING
,sdsnew(":0\r\n"));
918 shared
.cone
= createObject(REDIS_STRING
,sdsnew(":1\r\n"));
919 shared
.cnegone
= createObject(REDIS_STRING
,sdsnew(":-1\r\n"));
920 shared
.nullbulk
= createObject(REDIS_STRING
,sdsnew("$-1\r\n"));
921 shared
.nullmultibulk
= createObject(REDIS_STRING
,sdsnew("*-1\r\n"));
922 shared
.emptymultibulk
= createObject(REDIS_STRING
,sdsnew("*0\r\n"));
923 shared
.pong
= createObject(REDIS_STRING
,sdsnew("+PONG\r\n"));
924 shared
.queued
= createObject(REDIS_STRING
,sdsnew("+QUEUED\r\n"));
925 shared
.wrongtypeerr
= createObject(REDIS_STRING
,sdsnew(
926 "-ERR Operation against a key holding the wrong kind of value\r\n"));
927 shared
.nokeyerr
= createObject(REDIS_STRING
,sdsnew(
928 "-ERR no such key\r\n"));
929 shared
.syntaxerr
= createObject(REDIS_STRING
,sdsnew(
930 "-ERR syntax error\r\n"));
931 shared
.sameobjecterr
= createObject(REDIS_STRING
,sdsnew(
932 "-ERR source and destination objects are the same\r\n"));
933 shared
.outofrangeerr
= createObject(REDIS_STRING
,sdsnew(
934 "-ERR index out of range\r\n"));
935 shared
.noscripterr
= createObject(REDIS_STRING
,sdsnew(
936 "-NOSCRIPT No matching script. Please use EVAL.\r\n"));
937 shared
.loadingerr
= createObject(REDIS_STRING
,sdsnew(
938 "-LOADING Redis is loading the dataset in memory\r\n"));
939 shared
.slowscripterr
= createObject(REDIS_STRING
,sdsnew(
940 "-BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.\r\n"));
941 shared
.bgsaveerr
= createObject(REDIS_STRING
,sdsnew(
942 "-MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk. Write commands are disabled. Please check Redis logs for details about the error.\r\n"));
943 shared
.space
= createObject(REDIS_STRING
,sdsnew(" "));
944 shared
.colon
= createObject(REDIS_STRING
,sdsnew(":"));
945 shared
.plus
= createObject(REDIS_STRING
,sdsnew("+"));
946 shared
.select0
= createStringObject("select 0\r\n",10);
947 shared
.select1
= createStringObject("select 1\r\n",10);
948 shared
.select2
= createStringObject("select 2\r\n",10);
949 shared
.select3
= createStringObject("select 3\r\n",10);
950 shared
.select4
= createStringObject("select 4\r\n",10);
951 shared
.select5
= createStringObject("select 5\r\n",10);
952 shared
.select6
= createStringObject("select 6\r\n",10);
953 shared
.select7
= createStringObject("select 7\r\n",10);
954 shared
.select8
= createStringObject("select 8\r\n",10);
955 shared
.select9
= createStringObject("select 9\r\n",10);
956 shared
.messagebulk
= createStringObject("$7\r\nmessage\r\n",13);
957 shared
.pmessagebulk
= createStringObject("$8\r\npmessage\r\n",14);
958 shared
.subscribebulk
= createStringObject("$9\r\nsubscribe\r\n",15);
959 shared
.unsubscribebulk
= createStringObject("$11\r\nunsubscribe\r\n",18);
960 shared
.psubscribebulk
= createStringObject("$10\r\npsubscribe\r\n",17);
961 shared
.punsubscribebulk
= createStringObject("$12\r\npunsubscribe\r\n",19);
962 shared
.del
= createStringObject("DEL",3);
963 shared
.rpop
= createStringObject("RPOP",4);
964 shared
.lpop
= createStringObject("LPOP",4);
965 for (j
= 0; j
< REDIS_SHARED_INTEGERS
; j
++) {
966 shared
.integers
[j
] = createObject(REDIS_STRING
,(void*)(long)j
);
967 shared
.integers
[j
]->encoding
= REDIS_ENCODING_INT
;
969 for (j
= 0; j
< REDIS_SHARED_BULKHDR_LEN
; j
++) {
970 shared
.mbulkhdr
[j
] = createObject(REDIS_STRING
,
971 sdscatprintf(sdsempty(),"*%d\r\n",j
));
972 shared
.bulkhdr
[j
] = createObject(REDIS_STRING
,
973 sdscatprintf(sdsempty(),"$%d\r\n",j
));
977 void initServerConfig() {
978 getRandomHexChars(server
.runid
,REDIS_RUN_ID_SIZE
);
979 server
.runid
[REDIS_RUN_ID_SIZE
] = '\0';
980 server
.arch_bits
= (sizeof(long) == 8) ? 64 : 32;
981 server
.port
= REDIS_SERVERPORT
;
982 server
.bindaddr
= NULL
;
983 server
.unixsocket
= NULL
;
984 server
.unixsocketperm
= 0;
987 server
.dbnum
= REDIS_DEFAULT_DBNUM
;
988 server
.verbosity
= REDIS_NOTICE
;
989 server
.maxidletime
= REDIS_MAXIDLETIME
;
990 server
.client_max_querybuf_len
= REDIS_MAX_QUERYBUF_LEN
;
991 server
.saveparams
= NULL
;
993 server
.logfile
= NULL
; /* NULL = log on standard output */
994 server
.syslog_enabled
= 0;
995 server
.syslog_ident
= zstrdup("redis");
996 server
.syslog_facility
= LOG_LOCAL0
;
997 server
.daemonize
= 0;
998 server
.aof_state
= REDIS_AOF_OFF
;
999 server
.aof_fsync
= AOF_FSYNC_EVERYSEC
;
1000 server
.aof_no_fsync_on_rewrite
= 0;
1001 server
.aof_rewrite_perc
= REDIS_AOF_REWRITE_PERC
;
1002 server
.aof_rewrite_min_size
= REDIS_AOF_REWRITE_MIN_SIZE
;
1003 server
.aof_rewrite_base_size
= 0;
1004 server
.aof_rewrite_scheduled
= 0;
1005 server
.aof_last_fsync
= time(NULL
);
1007 server
.aof_selected_db
= -1; /* Make sure the first time will not match */
1008 server
.aof_flush_postponed_start
= 0;
1009 server
.pidfile
= zstrdup("/var/run/redis.pid");
1010 server
.rdb_filename
= zstrdup("dump.rdb");
1011 server
.aof_filename
= zstrdup("appendonly.aof");
1012 server
.requirepass
= NULL
;
1013 server
.rdb_compression
= 1;
1014 server
.activerehashing
= 1;
1015 server
.maxclients
= REDIS_MAX_CLIENTS
;
1016 server
.bpop_blocked_clients
= 0;
1017 server
.maxmemory
= 0;
1018 server
.maxmemory_policy
= REDIS_MAXMEMORY_VOLATILE_LRU
;
1019 server
.maxmemory_samples
= 3;
1020 server
.hash_max_ziplist_entries
= REDIS_HASH_MAX_ZIPLIST_ENTRIES
;
1021 server
.hash_max_ziplist_value
= REDIS_HASH_MAX_ZIPLIST_VALUE
;
1022 server
.list_max_ziplist_entries
= REDIS_LIST_MAX_ZIPLIST_ENTRIES
;
1023 server
.list_max_ziplist_value
= REDIS_LIST_MAX_ZIPLIST_VALUE
;
1024 server
.set_max_intset_entries
= REDIS_SET_MAX_INTSET_ENTRIES
;
1025 server
.zset_max_ziplist_entries
= REDIS_ZSET_MAX_ZIPLIST_ENTRIES
;
1026 server
.zset_max_ziplist_value
= REDIS_ZSET_MAX_ZIPLIST_VALUE
;
1027 server
.shutdown_asap
= 0;
1028 server
.repl_ping_slave_period
= REDIS_REPL_PING_SLAVE_PERIOD
;
1029 server
.repl_timeout
= REDIS_REPL_TIMEOUT
;
1030 server
.cluster_enabled
= 0;
1031 server
.cluster
.configfile
= zstrdup("nodes.conf");
1032 server
.lua_caller
= NULL
;
1033 server
.lua_time_limit
= REDIS_LUA_TIME_LIMIT
;
1034 server
.lua_client
= NULL
;
1035 server
.lua_timedout
= 0;
1038 resetServerSaveParams();
1040 appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
1041 appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
1042 appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
1043 /* Replication related */
1044 server
.masterauth
= NULL
;
1045 server
.masterhost
= NULL
;
1046 server
.masterport
= 6379;
1047 server
.master
= NULL
;
1048 server
.repl_state
= REDIS_REPL_NONE
;
1049 server
.repl_syncio_timeout
= REDIS_REPL_SYNCIO_TIMEOUT
;
1050 server
.repl_serve_stale_data
= 1;
1051 server
.repl_down_since
= -1;
1053 /* Client output buffer limits */
1054 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_NORMAL
].hard_limit_bytes
= 0;
1055 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_NORMAL
].soft_limit_bytes
= 0;
1056 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_NORMAL
].soft_limit_seconds
= 0;
1057 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_SLAVE
].hard_limit_bytes
= 1024*1024*256;
1058 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_SLAVE
].soft_limit_bytes
= 1024*1024*64;
1059 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_SLAVE
].soft_limit_seconds
= 60;
1060 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_PUBSUB
].hard_limit_bytes
= 1024*1024*32;
1061 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_PUBSUB
].soft_limit_bytes
= 1024*1024*8;
1062 server
.client_obuf_limits
[REDIS_CLIENT_LIMIT_CLASS_PUBSUB
].soft_limit_seconds
= 60;
1064 /* Double constants initialization */
1066 R_PosInf
= 1.0/R_Zero
;
1067 R_NegInf
= -1.0/R_Zero
;
1068 R_Nan
= R_Zero
/R_Zero
;
1070 /* Command table -- we intiialize it here as it is part of the
1071 * initial configuration, since command names may be changed via
1072 * redis.conf using the rename-command directive. */
1073 server
.commands
= dictCreate(&commandTableDictType
,NULL
);
1074 populateCommandTable();
1075 server
.delCommand
= lookupCommandByCString("del");
1076 server
.multiCommand
= lookupCommandByCString("multi");
1077 server
.lpushCommand
= lookupCommandByCString("lpush");
1080 server
.slowlog_log_slower_than
= REDIS_SLOWLOG_LOG_SLOWER_THAN
;
1081 server
.slowlog_max_len
= REDIS_SLOWLOG_MAX_LEN
;
1084 server
.assert_failed
= "<no assertion failed>";
1085 server
.assert_file
= "<no file>";
1086 server
.assert_line
= 0;
1087 server
.bug_report_start
= 0;
1090 /* This function will try to raise the max number of open files accordingly to
1091 * the configured max number of clients. It will also account for 32 additional
1092 * file descriptors as we need a few more for persistence, listening
1093 * sockets, log files and so forth.
1095 * If it will not be possible to set the limit accordingly to the configured
1096 * max number of clients, the function will do the reverse setting
1097 * server.maxclients to the value that we can actually handle. */
1098 void adjustOpenFilesLimit(void) {
1099 rlim_t maxfiles
= server
.maxclients
+32;
1100 struct rlimit limit
;
1102 if (maxfiles
< 1024) maxfiles
= 1024;
1103 if (getrlimit(RLIMIT_NOFILE
,&limit
) == -1) {
1104 redisLog(REDIS_WARNING
,"Unable to obtain the current NOFILE limit (%s), assuming 1024 and setting the max clients configuration accordingly.",
1106 server
.maxclients
= 1024-32;
1108 rlim_t oldlimit
= limit
.rlim_cur
;
1110 /* Set the max number of files if the current limit is not enough
1112 if (oldlimit
< maxfiles
) {
1113 limit
.rlim_cur
= maxfiles
;
1114 limit
.rlim_max
= maxfiles
;
1115 if (setrlimit(RLIMIT_NOFILE
,&limit
) == -1) {
1116 server
.maxclients
= oldlimit
-32;
1117 redisLog(REDIS_WARNING
,"Unable to set the max number of files limit to %d (%s), setting the max clients configuration to %d.",
1118 (int) maxfiles
, strerror(errno
), (int) server
.maxclients
);
1120 redisLog(REDIS_NOTICE
,"Max number of open files set to %d",
1130 signal(SIGHUP
, SIG_IGN
);
1131 signal(SIGPIPE
, SIG_IGN
);
1132 setupSignalHandlers();
1134 if (server
.syslog_enabled
) {
1135 openlog(server
.syslog_ident
, LOG_PID
| LOG_NDELAY
| LOG_NOWAIT
,
1136 server
.syslog_facility
);
1139 server
.current_client
= NULL
;
1140 server
.clients
= listCreate();
1141 server
.clients_to_close
= listCreate();
1142 server
.slaves
= listCreate();
1143 server
.monitors
= listCreate();
1144 server
.unblocked_clients
= listCreate();
1146 createSharedObjects();
1147 adjustOpenFilesLimit();
1148 server
.el
= aeCreateEventLoop(server
.maxclients
+1024);
1149 server
.db
= zmalloc(sizeof(redisDb
)*server
.dbnum
);
1151 if (server
.port
!= 0) {
1152 server
.ipfd
= anetTcpServer(server
.neterr
,server
.port
,server
.bindaddr
);
1153 if (server
.ipfd
== ANET_ERR
) {
1154 redisLog(REDIS_WARNING
, "Opening port %d: %s",
1155 server
.port
, server
.neterr
);
1159 if (server
.unixsocket
!= NULL
) {
1160 unlink(server
.unixsocket
); /* don't care if this fails */
1161 server
.sofd
= anetUnixServer(server
.neterr
,server
.unixsocket
,server
.unixsocketperm
);
1162 if (server
.sofd
== ANET_ERR
) {
1163 redisLog(REDIS_WARNING
, "Opening socket: %s", server
.neterr
);
1167 if (server
.ipfd
< 0 && server
.sofd
< 0) {
1168 redisLog(REDIS_WARNING
, "Configured to not listen anywhere, exiting.");
1171 for (j
= 0; j
< server
.dbnum
; j
++) {
1172 server
.db
[j
].dict
= dictCreate(&dbDictType
,NULL
);
1173 server
.db
[j
].expires
= dictCreate(&keyptrDictType
,NULL
);
1174 server
.db
[j
].blocking_keys
= dictCreate(&keylistDictType
,NULL
);
1175 server
.db
[j
].watched_keys
= dictCreate(&keylistDictType
,NULL
);
1176 server
.db
[j
].id
= j
;
1178 server
.pubsub_channels
= dictCreate(&keylistDictType
,NULL
);
1179 server
.pubsub_patterns
= listCreate();
1180 listSetFreeMethod(server
.pubsub_patterns
,freePubsubPattern
);
1181 listSetMatchMethod(server
.pubsub_patterns
,listMatchPubsubPattern
);
1182 server
.cronloops
= 0;
1183 server
.rdb_child_pid
= -1;
1184 server
.aof_child_pid
= -1;
1185 server
.aof_rewrite_buf
= sdsempty();
1186 server
.aof_buf
= sdsempty();
1187 server
.lastsave
= time(NULL
);
1189 server
.stat_numcommands
= 0;
1190 server
.stat_numconnections
= 0;
1191 server
.stat_expiredkeys
= 0;
1192 server
.stat_evictedkeys
= 0;
1193 server
.stat_starttime
= time(NULL
);
1194 server
.stat_keyspace_misses
= 0;
1195 server
.stat_keyspace_hits
= 0;
1196 server
.stat_peak_memory
= 0;
1197 server
.stat_fork_time
= 0;
1198 server
.stat_rejected_conn
= 0;
1199 memset(server
.ops_sec_samples
,0,sizeof(server
.ops_sec_samples
));
1200 server
.ops_sec_idx
= 0;
1201 server
.ops_sec_last_sample_time
= mstime();
1202 server
.ops_sec_last_sample_ops
= 0;
1203 server
.unixtime
= time(NULL
);
1204 server
.lastbgsave_status
= REDIS_OK
;
1205 server
.stop_writes_on_bgsave_err
= 1;
1206 aeCreateTimeEvent(server
.el
, 1, serverCron
, NULL
, NULL
);
1207 if (server
.ipfd
> 0 && aeCreateFileEvent(server
.el
,server
.ipfd
,AE_READABLE
,
1208 acceptTcpHandler
,NULL
) == AE_ERR
) oom("creating file event");
1209 if (server
.sofd
> 0 && aeCreateFileEvent(server
.el
,server
.sofd
,AE_READABLE
,
1210 acceptUnixHandler
,NULL
) == AE_ERR
) oom("creating file event");
1212 if (server
.aof_state
== REDIS_AOF_ON
) {
1213 server
.aof_fd
= open(server
.aof_filename
,
1214 O_WRONLY
|O_APPEND
|O_CREAT
,0644);
1215 if (server
.aof_fd
== -1) {
1216 redisLog(REDIS_WARNING
, "Can't open the append-only file: %s",
1222 /* 32 bit instances are limited to 4GB of address space, so if there is
1223 * no explicit limit in the user provided configuration we set a limit
1224 * at 3.5GB using maxmemory with 'noeviction' policy'. This saves
1225 * useless crashes of the Redis instance. */
1226 if (server
.arch_bits
== 32 && server
.maxmemory
== 0) {
1227 redisLog(REDIS_WARNING
,"Warning: 32 bit instance detected but no memory limit set. Setting 3.5 GB maxmemory limit with 'noeviction' policy now.");
1228 server
.maxmemory
= 3584LL*(1024*1024); /* 3584 MB = 3.5 GB */
1229 server
.maxmemory_policy
= REDIS_MAXMEMORY_NO_EVICTION
;
1232 if (server
.cluster_enabled
) clusterInit();
1238 /* Populates the Redis Command Table starting from the hard coded list
1239 * we have on top of redis.c file. */
1240 void populateCommandTable(void) {
1242 int numcommands
= sizeof(redisCommandTable
)/sizeof(struct redisCommand
);
1244 for (j
= 0; j
< numcommands
; j
++) {
1245 struct redisCommand
*c
= redisCommandTable
+j
;
1246 char *f
= c
->sflags
;
1251 case 'w': c
->flags
|= REDIS_CMD_WRITE
; break;
1252 case 'r': c
->flags
|= REDIS_CMD_READONLY
; break;
1253 case 'm': c
->flags
|= REDIS_CMD_DENYOOM
; break;
1254 case 'a': c
->flags
|= REDIS_CMD_ADMIN
; break;
1255 case 'p': c
->flags
|= REDIS_CMD_PUBSUB
; break;
1256 case 'f': c
->flags
|= REDIS_CMD_FORCE_REPLICATION
; break;
1257 case 's': c
->flags
|= REDIS_CMD_NOSCRIPT
; break;
1258 case 'R': c
->flags
|= REDIS_CMD_RANDOM
; break;
1259 case 'S': c
->flags
|= REDIS_CMD_SORT_FOR_SCRIPT
; break;
1260 default: redisPanic("Unsupported command flag"); break;
1265 retval
= dictAdd(server
.commands
, sdsnew(c
->name
), c
);
1266 assert(retval
== DICT_OK
);
1270 void resetCommandTableStats(void) {
1271 int numcommands
= sizeof(redisCommandTable
)/sizeof(struct redisCommand
);
1274 for (j
= 0; j
< numcommands
; j
++) {
1275 struct redisCommand
*c
= redisCommandTable
+j
;
1277 c
->microseconds
= 0;
1282 /* ========================== Redis OP Array API ============================ */
1284 void redisOpArrayInit(redisOpArray
*oa
) {
1289 int redisOpArrayAppend(redisOpArray
*oa
, struct redisCommand
*cmd
, int dbid
,
1290 robj
**argv
, int argc
, int target
)
1294 oa
->ops
= zrealloc(oa
->ops
,sizeof(redisOp
)*(oa
->numops
+1));
1295 op
= oa
->ops
+oa
->numops
;
1300 op
->target
= target
;
1305 void redisOpArrayFree(redisOpArray
*oa
) {
1311 op
= oa
->ops
+oa
->numops
;
1312 for (j
= 0; j
< op
->argc
; j
++)
1313 decrRefCount(op
->argv
[j
]);
1319 /* ====================== Commands lookup and execution ===================== */
1321 struct redisCommand
*lookupCommand(sds name
) {
1322 return dictFetchValue(server
.commands
, name
);
1325 struct redisCommand
*lookupCommandByCString(char *s
) {
1326 struct redisCommand
*cmd
;
1327 sds name
= sdsnew(s
);
1329 cmd
= dictFetchValue(server
.commands
, name
);
1334 /* Propagate the specified command (in the context of the specified database id)
1335 * to AOF, Slaves and Monitors.
1337 * flags are an xor between:
1338 * + REDIS_PROPAGATE_NONE (no propagation of command at all)
1339 * + REDIS_PROPAGATE_AOF (propagate into the AOF file if is enabled)
1340 * + REDIS_PROPAGATE_REPL (propagate into the replication link)
1342 void propagate(struct redisCommand
*cmd
, int dbid
, robj
**argv
, int argc
,
1345 if (server
.aof_state
!= REDIS_AOF_OFF
&& flags
& REDIS_PROPAGATE_AOF
)
1346 feedAppendOnlyFile(cmd
,dbid
,argv
,argc
);
1347 if (flags
& REDIS_PROPAGATE_REPL
&& listLength(server
.slaves
))
1348 replicationFeedSlaves(server
.slaves
,dbid
,argv
,argc
);
1351 /* Used inside commands to schedule the propagation of additional commands
1352 * after the current command is propagated to AOF / Replication. */
1353 void alsoPropagate(struct redisCommand
*cmd
, int dbid
, robj
**argv
, int argc
,
1356 redisOpArrayAppend(&server
.also_propagate
,cmd
,dbid
,argv
,argc
,target
);
1359 /* Call() is the core of Redis execution of a command */
1360 void call(redisClient
*c
, int flags
) {
1361 long long dirty
, start
= ustime(), duration
;
1363 /* Sent the command to clients in MONITOR mode, only if the commands are
1364 * not geneated from reading an AOF. */
1365 if (listLength(server
.monitors
) && !server
.loading
)
1366 replicationFeedMonitors(c
,server
.monitors
,c
->db
->id
,c
->argv
,c
->argc
);
1368 /* Call the command. */
1369 redisOpArrayInit(&server
.also_propagate
);
1370 dirty
= server
.dirty
;
1372 dirty
= server
.dirty
-dirty
;
1373 duration
= ustime()-start
;
1375 /* When EVAL is called loading the AOF we don't want commands called
1376 * from Lua to go into the slowlog or to populate statistics. */
1377 if (server
.loading
&& c
->flags
& REDIS_LUA_CLIENT
)
1378 flags
&= ~(REDIS_CALL_SLOWLOG
| REDIS_CALL_STATS
);
1380 /* Log the command into the Slow log if needed, and populate the
1381 * per-command statistics that we show in INFO commandstats. */
1382 if (flags
& REDIS_CALL_SLOWLOG
)
1383 slowlogPushEntryIfNeeded(c
->argv
,c
->argc
,duration
);
1384 if (flags
& REDIS_CALL_STATS
) {
1385 c
->cmd
->microseconds
+= duration
;
1389 /* Propagate the command into the AOF and replication link */
1390 if (flags
& REDIS_CALL_PROPAGATE
) {
1391 int flags
= REDIS_PROPAGATE_NONE
;
1393 if (c
->cmd
->flags
& REDIS_CMD_FORCE_REPLICATION
)
1394 flags
|= REDIS_PROPAGATE_REPL
;
1396 flags
|= (REDIS_PROPAGATE_REPL
| REDIS_PROPAGATE_AOF
);
1397 if (flags
!= REDIS_PROPAGATE_NONE
)
1398 propagate(c
->cmd
,c
->db
->id
,c
->argv
,c
->argc
,flags
);
1400 /* Commands such as LPUSH or BRPOPLPUSH may propagate an additional
1402 if (server
.also_propagate
.numops
) {
1406 for (j
= 0; j
< server
.also_propagate
.numops
; j
++) {
1407 rop
= &server
.also_propagate
.ops
[j
];
1408 propagate(rop
->cmd
, rop
->dbid
, rop
->argv
, rop
->argc
, rop
->target
);
1410 redisOpArrayFree(&server
.also_propagate
);
1412 server
.stat_numcommands
++;
1415 /* If this function gets called we already read a whole
1416 * command, argments are in the client argv/argc fields.
1417 * processCommand() execute the command or prepare the
1418 * server for a bulk read from the client.
1420 * If 1 is returned the client is still alive and valid and
1421 * and other operations can be performed by the caller. Otherwise
1422 * if 0 is returned the client was destroied (i.e. after QUIT). */
1423 int processCommand(redisClient
*c
) {
1424 /* The QUIT command is handled separately. Normal command procs will
1425 * go through checking for replication and QUIT will cause trouble
1426 * when FORCE_REPLICATION is enabled and would be implemented in
1427 * a regular command proc. */
1428 if (!strcasecmp(c
->argv
[0]->ptr
,"quit")) {
1429 addReply(c
,shared
.ok
);
1430 c
->flags
|= REDIS_CLOSE_AFTER_REPLY
;
1434 /* Now lookup the command and check ASAP about trivial error conditions
1435 * such as wrong arity, bad command name and so forth. */
1436 c
->cmd
= c
->lastcmd
= lookupCommand(c
->argv
[0]->ptr
);
1438 addReplyErrorFormat(c
,"unknown command '%s'",
1439 (char*)c
->argv
[0]->ptr
);
1441 } else if ((c
->cmd
->arity
> 0 && c
->cmd
->arity
!= c
->argc
) ||
1442 (c
->argc
< -c
->cmd
->arity
)) {
1443 addReplyErrorFormat(c
,"wrong number of arguments for '%s' command",
1448 /* Check if the user is authenticated */
1449 if (server
.requirepass
&& !c
->authenticated
&& c
->cmd
->proc
!= authCommand
)
1451 addReplyError(c
,"operation not permitted");
1455 /* If cluster is enabled, redirect here */
1456 if (server
.cluster_enabled
&&
1457 !(c
->cmd
->getkeys_proc
== NULL
&& c
->cmd
->firstkey
== 0)) {
1460 if (server
.cluster
.state
!= REDIS_CLUSTER_OK
) {
1461 addReplyError(c
,"The cluster is down. Check with CLUSTER INFO for more information");
1465 clusterNode
*n
= getNodeByQuery(c
,c
->cmd
,c
->argv
,c
->argc
,&hashslot
,&ask
);
1467 addReplyError(c
,"Multi keys request invalid in cluster");
1469 } else if (n
!= server
.cluster
.myself
) {
1470 addReplySds(c
,sdscatprintf(sdsempty(),
1471 "-%s %d %s:%d\r\n", ask
? "ASK" : "MOVED",
1472 hashslot
,n
->ip
,n
->port
));
1478 /* Handle the maxmemory directive.
1480 * First we try to free some memory if possible (if there are volatile
1481 * keys in the dataset). If there are not the only thing we can do
1482 * is returning an error. */
1483 if (server
.maxmemory
) {
1484 int retval
= freeMemoryIfNeeded();
1485 if ((c
->cmd
->flags
& REDIS_CMD_DENYOOM
) && retval
== REDIS_ERR
) {
1487 "command not allowed when used memory > 'maxmemory'");
1492 /* Don't accept write commands if there are problems persisting on disk. */
1493 if (server
.stop_writes_on_bgsave_err
&&
1494 server
.saveparamslen
> 0
1495 && server
.lastbgsave_status
== REDIS_ERR
&&
1496 c
->cmd
->flags
& REDIS_CMD_WRITE
)
1498 addReply(c
, shared
.bgsaveerr
);
1502 /* Only allow SUBSCRIBE and UNSUBSCRIBE in the context of Pub/Sub */
1503 if ((dictSize(c
->pubsub_channels
) > 0 || listLength(c
->pubsub_patterns
) > 0)
1505 c
->cmd
->proc
!= subscribeCommand
&&
1506 c
->cmd
->proc
!= unsubscribeCommand
&&
1507 c
->cmd
->proc
!= psubscribeCommand
&&
1508 c
->cmd
->proc
!= punsubscribeCommand
) {
1509 addReplyError(c
,"only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context");
1513 /* Only allow INFO and SLAVEOF when slave-serve-stale-data is no and
1514 * we are a slave with a broken link with master. */
1515 if (server
.masterhost
&& server
.repl_state
!= REDIS_REPL_CONNECTED
&&
1516 server
.repl_serve_stale_data
== 0 &&
1517 c
->cmd
->proc
!= infoCommand
&& c
->cmd
->proc
!= slaveofCommand
)
1520 "link with MASTER is down and slave-serve-stale-data is set to no");
1524 /* Loading DB? Return an error if the command is not INFO */
1525 if (server
.loading
&& c
->cmd
->proc
!= infoCommand
) {
1526 addReply(c
, shared
.loadingerr
);
1530 /* Lua script too slow? Only allow SHUTDOWN NOSAVE and SCRIPT KILL. */
1531 if (server
.lua_timedout
&&
1532 !(c
->cmd
->proc
!= shutdownCommand
&&
1534 tolower(((char*)c
->argv
[1]->ptr
)[0]) == 'n') &&
1535 !(c
->cmd
->proc
== scriptCommand
&&
1537 tolower(((char*)c
->argv
[1]->ptr
)[0]) == 'k'))
1539 addReply(c
, shared
.slowscripterr
);
1543 /* Exec the command */
1544 if (c
->flags
& REDIS_MULTI
&&
1545 c
->cmd
->proc
!= execCommand
&& c
->cmd
->proc
!= discardCommand
&&
1546 c
->cmd
->proc
!= multiCommand
&& c
->cmd
->proc
!= watchCommand
)
1548 queueMultiCommand(c
);
1549 addReply(c
,shared
.queued
);
1551 call(c
,REDIS_CALL_FULL
);
1556 /*================================== Shutdown =============================== */
1558 int prepareForShutdown(int flags
) {
1559 int save
= flags
& REDIS_SHUTDOWN_SAVE
;
1560 int nosave
= flags
& REDIS_SHUTDOWN_NOSAVE
;
1562 redisLog(REDIS_WARNING
,"User requested shutdown...");
1563 /* Kill the saving child if there is a background saving in progress.
1564 We want to avoid race conditions, for instance our saving child may
1565 overwrite the synchronous saving did by SHUTDOWN. */
1566 if (server
.rdb_child_pid
!= -1) {
1567 redisLog(REDIS_WARNING
,"There is a child saving an .rdb. Killing it!");
1568 kill(server
.rdb_child_pid
,SIGKILL
);
1569 rdbRemoveTempFile(server
.rdb_child_pid
);
1571 if (server
.aof_state
!= REDIS_AOF_OFF
) {
1572 /* Kill the AOF saving child as the AOF we already have may be longer
1573 * but contains the full dataset anyway. */
1574 if (server
.aof_child_pid
!= -1) {
1575 redisLog(REDIS_WARNING
,
1576 "There is a child rewriting the AOF. Killing it!");
1577 kill(server
.aof_child_pid
,SIGKILL
);
1579 /* Append only file: fsync() the AOF and exit */
1580 redisLog(REDIS_NOTICE
,"Calling fsync() on the AOF file.");
1581 aof_fsync(server
.aof_fd
);
1583 if ((server
.saveparamslen
> 0 && !nosave
) || save
) {
1584 redisLog(REDIS_NOTICE
,"Saving the final RDB snapshot before exiting.");
1585 /* Snapshotting. Perform a SYNC SAVE and exit */
1586 if (rdbSave(server
.rdb_filename
) != REDIS_OK
) {
1587 /* Ooops.. error saving! The best we can do is to continue
1588 * operating. Note that if there was a background saving process,
1589 * in the next cron() Redis will be notified that the background
1590 * saving aborted, handling special stuff like slaves pending for
1591 * synchronization... */
1592 redisLog(REDIS_WARNING
,"Error trying to save the DB, can't exit.");
1596 if (server
.daemonize
) {
1597 redisLog(REDIS_NOTICE
,"Removing the pid file.");
1598 unlink(server
.pidfile
);
1600 /* Close the listening sockets. Apparently this allows faster restarts. */
1601 if (server
.ipfd
!= -1) close(server
.ipfd
);
1602 if (server
.sofd
!= -1) close(server
.sofd
);
1603 if (server
.unixsocket
) {
1604 redisLog(REDIS_NOTICE
,"Removing the unix socket file.");
1605 unlink(server
.unixsocket
); /* don't care if this fails */
1608 redisLog(REDIS_WARNING
,"Redis is now ready to exit, bye bye...");
1612 /*================================== Commands =============================== */
1614 void authCommand(redisClient
*c
) {
1615 if (!server
.requirepass
) {
1616 addReplyError(c
,"Client sent AUTH, but no password is set");
1617 } else if (!strcmp(c
->argv
[1]->ptr
, server
.requirepass
)) {
1618 c
->authenticated
= 1;
1619 addReply(c
,shared
.ok
);
1621 c
->authenticated
= 0;
1622 addReplyError(c
,"invalid password");
1626 void pingCommand(redisClient
*c
) {
1627 addReply(c
,shared
.pong
);
1630 void echoCommand(redisClient
*c
) {
1631 addReplyBulk(c
,c
->argv
[1]);
1634 void timeCommand(redisClient
*c
) {
1637 /* gettimeofday() can only fail if &tv is a bad addresss so we
1638 * don't check for errors. */
1639 gettimeofday(&tv
,NULL
);
1640 addReplyMultiBulkLen(c
,2);
1641 addReplyBulkLongLong(c
,tv
.tv_sec
);
1642 addReplyBulkLongLong(c
,tv
.tv_usec
);
1645 /* Convert an amount of bytes into a human readable string in the form
1646 * of 100B, 2G, 100M, 4K, and so forth. */
1647 void bytesToHuman(char *s
, unsigned long long n
) {
1652 sprintf(s
,"%lluB",n
);
1654 } else if (n
< (1024*1024)) {
1655 d
= (double)n
/(1024);
1656 sprintf(s
,"%.2fK",d
);
1657 } else if (n
< (1024LL*1024*1024)) {
1658 d
= (double)n
/(1024*1024);
1659 sprintf(s
,"%.2fM",d
);
1660 } else if (n
< (1024LL*1024*1024*1024)) {
1661 d
= (double)n
/(1024LL*1024*1024);
1662 sprintf(s
,"%.2fG",d
);
1666 /* Create the string returned by the INFO command. This is decoupled
1667 * by the INFO command itself as we need to report the same information
1668 * on memory corruption problems. */
1669 sds
genRedisInfoString(char *section
) {
1670 sds info
= sdsempty();
1671 time_t uptime
= time(NULL
)-server
.stat_starttime
;
1673 struct rusage self_ru
, c_ru
;
1674 unsigned long lol
, bib
;
1675 int allsections
= 0, defsections
= 0;
1679 allsections
= strcasecmp(section
,"all") == 0;
1680 defsections
= strcasecmp(section
,"default") == 0;
1683 getrusage(RUSAGE_SELF
, &self_ru
);
1684 getrusage(RUSAGE_CHILDREN
, &c_ru
);
1685 getClientsMaxBuffers(&lol
,&bib
);
1688 if (allsections
|| defsections
|| !strcasecmp(section
,"server")) {
1689 if (sections
++) info
= sdscat(info
,"\r\n");
1690 info
= sdscatprintf(info
,
1692 "redis_version:%s\r\n"
1693 "redis_git_sha1:%s\r\n"
1694 "redis_git_dirty:%d\r\n"
1696 "multiplexing_api:%s\r\n"
1697 "gcc_version:%d.%d.%d\r\n"
1698 "process_id:%ld\r\n"
1701 "uptime_in_seconds:%ld\r\n"
1702 "uptime_in_days:%ld\r\n"
1703 "lru_clock:%ld\r\n",
1706 strtol(redisGitDirty(),NULL
,10) > 0,
1710 __GNUC__
,__GNUC_MINOR__
,__GNUC_PATCHLEVEL__
,
1719 (unsigned long) server
.lruclock
);
1723 if (allsections
|| defsections
|| !strcasecmp(section
,"clients")) {
1724 if (sections
++) info
= sdscat(info
,"\r\n");
1725 info
= sdscatprintf(info
,
1727 "connected_clients:%lu\r\n"
1728 "client_longest_output_list:%lu\r\n"
1729 "client_biggest_input_buf:%lu\r\n"
1730 "blocked_clients:%d\r\n",
1731 listLength(server
.clients
)-listLength(server
.slaves
),
1733 server
.bpop_blocked_clients
);
1737 if (allsections
|| defsections
|| !strcasecmp(section
,"memory")) {
1741 bytesToHuman(hmem
,zmalloc_used_memory());
1742 bytesToHuman(peak_hmem
,server
.stat_peak_memory
);
1743 if (sections
++) info
= sdscat(info
,"\r\n");
1744 info
= sdscatprintf(info
,
1746 "used_memory:%zu\r\n"
1747 "used_memory_human:%s\r\n"
1748 "used_memory_rss:%zu\r\n"
1749 "used_memory_peak:%zu\r\n"
1750 "used_memory_peak_human:%s\r\n"
1751 "used_memory_lua:%lld\r\n"
1752 "mem_fragmentation_ratio:%.2f\r\n"
1753 "mem_allocator:%s\r\n",
1754 zmalloc_used_memory(),
1757 server
.stat_peak_memory
,
1759 ((long long)lua_gc(server
.lua
,LUA_GCCOUNT
,0))*1024LL,
1760 zmalloc_get_fragmentation_ratio(),
1766 if (allsections
|| defsections
|| !strcasecmp(section
,"persistence")) {
1767 if (sections
++) info
= sdscat(info
,"\r\n");
1768 info
= sdscatprintf(info
,
1771 "aof_enabled:%d\r\n"
1772 "changes_since_last_save:%lld\r\n"
1773 "bgsave_in_progress:%d\r\n"
1774 "last_save_time:%ld\r\n"
1775 "last_bgsave_status:%s\r\n"
1776 "bgrewriteaof_in_progress:%d\r\n",
1778 server
.aof_state
!= REDIS_AOF_OFF
,
1780 server
.rdb_child_pid
!= -1,
1782 server
.lastbgsave_status
== REDIS_OK
? "ok" : "err",
1783 server
.aof_child_pid
!= -1);
1785 if (server
.aof_state
!= REDIS_AOF_OFF
) {
1786 info
= sdscatprintf(info
,
1787 "aof_current_size:%lld\r\n"
1788 "aof_base_size:%lld\r\n"
1789 "aof_pending_rewrite:%d\r\n"
1790 "aof_buffer_length:%zu\r\n"
1791 "aof_pending_bio_fsync:%llu\r\n",
1792 (long long) server
.aof_current_size
,
1793 (long long) server
.aof_rewrite_base_size
,
1794 server
.aof_rewrite_scheduled
,
1795 sdslen(server
.aof_buf
),
1796 bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC
));
1799 if (server
.loading
) {
1801 time_t eta
, elapsed
;
1802 off_t remaining_bytes
= server
.loading_total_bytes
-
1803 server
.loading_loaded_bytes
;
1805 perc
= ((double)server
.loading_loaded_bytes
/
1806 server
.loading_total_bytes
) * 100;
1808 elapsed
= time(NULL
)-server
.loading_start_time
;
1810 eta
= 1; /* A fake 1 second figure if we don't have
1813 eta
= (elapsed
*remaining_bytes
)/server
.loading_loaded_bytes
;
1816 info
= sdscatprintf(info
,
1817 "loading_start_time:%ld\r\n"
1818 "loading_total_bytes:%llu\r\n"
1819 "loading_loaded_bytes:%llu\r\n"
1820 "loading_loaded_perc:%.2f\r\n"
1821 "loading_eta_seconds:%ld\r\n"
1822 ,(unsigned long) server
.loading_start_time
,
1823 (unsigned long long) server
.loading_total_bytes
,
1824 (unsigned long long) server
.loading_loaded_bytes
,
1832 if (allsections
|| defsections
|| !strcasecmp(section
,"stats")) {
1833 if (sections
++) info
= sdscat(info
,"\r\n");
1834 info
= sdscatprintf(info
,
1836 "total_connections_received:%lld\r\n"
1837 "total_commands_processed:%lld\r\n"
1838 "instantaneous_ops_per_sec:%lld\r\n"
1839 "rejected_connections:%lld\r\n"
1840 "expired_keys:%lld\r\n"
1841 "evicted_keys:%lld\r\n"
1842 "keyspace_hits:%lld\r\n"
1843 "keyspace_misses:%lld\r\n"
1844 "pubsub_channels:%ld\r\n"
1845 "pubsub_patterns:%lu\r\n"
1846 "latest_fork_usec:%lld\r\n",
1847 server
.stat_numconnections
,
1848 server
.stat_numcommands
,
1849 getOperationsPerSecond(),
1850 server
.stat_rejected_conn
,
1851 server
.stat_expiredkeys
,
1852 server
.stat_evictedkeys
,
1853 server
.stat_keyspace_hits
,
1854 server
.stat_keyspace_misses
,
1855 dictSize(server
.pubsub_channels
),
1856 listLength(server
.pubsub_patterns
),
1857 server
.stat_fork_time
);
1861 if (allsections
|| defsections
|| !strcasecmp(section
,"replication")) {
1862 if (sections
++) info
= sdscat(info
,"\r\n");
1863 info
= sdscatprintf(info
,
1866 server
.masterhost
== NULL
? "master" : "slave");
1867 if (server
.masterhost
) {
1868 info
= sdscatprintf(info
,
1869 "master_host:%s\r\n"
1870 "master_port:%d\r\n"
1871 "master_link_status:%s\r\n"
1872 "master_last_io_seconds_ago:%d\r\n"
1873 "master_sync_in_progress:%d\r\n"
1876 (server
.repl_state
== REDIS_REPL_CONNECTED
) ?
1879 ((int)(time(NULL
)-server
.master
->lastinteraction
)) : -1,
1880 server
.repl_state
== REDIS_REPL_TRANSFER
1883 if (server
.repl_state
== REDIS_REPL_TRANSFER
) {
1884 info
= sdscatprintf(info
,
1885 "master_sync_left_bytes:%ld\r\n"
1886 "master_sync_last_io_seconds_ago:%d\r\n"
1887 ,(long)server
.repl_transfer_left
,
1888 (int)(time(NULL
)-server
.repl_transfer_lastio
)
1892 if (server
.repl_state
!= REDIS_REPL_CONNECTED
) {
1893 info
= sdscatprintf(info
,
1894 "master_link_down_since_seconds:%ld\r\n",
1895 (long)time(NULL
)-server
.repl_down_since
);
1898 info
= sdscatprintf(info
,
1899 "connected_slaves:%lu\r\n",
1900 listLength(server
.slaves
));
1901 if (listLength(server
.slaves
)) {
1906 listRewind(server
.slaves
,&li
);
1907 while((ln
= listNext(&li
))) {
1908 redisClient
*slave
= listNodeValue(ln
);
1913 if (anetPeerToString(slave
->fd
,ip
,&port
) == -1) continue;
1914 switch(slave
->replstate
) {
1915 case REDIS_REPL_WAIT_BGSAVE_START
:
1916 case REDIS_REPL_WAIT_BGSAVE_END
:
1917 state
= "wait_bgsave";
1919 case REDIS_REPL_SEND_BULK
:
1920 state
= "send_bulk";
1922 case REDIS_REPL_ONLINE
:
1926 if (state
== NULL
) continue;
1927 info
= sdscatprintf(info
,"slave%d:%s,%d,%s\r\n",
1928 slaveid
,ip
,port
,state
);
1935 if (allsections
|| defsections
|| !strcasecmp(section
,"cpu")) {
1936 if (sections
++) info
= sdscat(info
,"\r\n");
1937 info
= sdscatprintf(info
,
1939 "used_cpu_sys:%.2f\r\n"
1940 "used_cpu_user:%.2f\r\n"
1941 "used_cpu_sys_children:%.2f\r\n"
1942 "used_cpu_user_children:%.2f\r\n",
1943 (float)self_ru
.ru_stime
.tv_sec
+(float)self_ru
.ru_stime
.tv_usec
/1000000,
1944 (float)self_ru
.ru_utime
.tv_sec
+(float)self_ru
.ru_utime
.tv_usec
/1000000,
1945 (float)c_ru
.ru_stime
.tv_sec
+(float)c_ru
.ru_stime
.tv_usec
/1000000,
1946 (float)c_ru
.ru_utime
.tv_sec
+(float)c_ru
.ru_utime
.tv_usec
/1000000);
1950 if (allsections
|| !strcasecmp(section
,"commandstats")) {
1951 if (sections
++) info
= sdscat(info
,"\r\n");
1952 info
= sdscatprintf(info
, "# Commandstats\r\n");
1953 numcommands
= sizeof(redisCommandTable
)/sizeof(struct redisCommand
);
1954 for (j
= 0; j
< numcommands
; j
++) {
1955 struct redisCommand
*c
= redisCommandTable
+j
;
1957 if (!c
->calls
) continue;
1958 info
= sdscatprintf(info
,
1959 "cmdstat_%s:calls=%lld,usec=%lld,usec_per_call=%.2f\r\n",
1960 c
->name
, c
->calls
, c
->microseconds
,
1961 (c
->calls
== 0) ? 0 : ((float)c
->microseconds
/c
->calls
));
1966 if (allsections
|| defsections
|| !strcasecmp(section
,"cluster")) {
1967 if (sections
++) info
= sdscat(info
,"\r\n");
1968 info
= sdscatprintf(info
,
1970 "cluster_enabled:%d\r\n",
1971 server
.cluster_enabled
);
1975 if (allsections
|| defsections
|| !strcasecmp(section
,"keyspace")) {
1976 if (sections
++) info
= sdscat(info
,"\r\n");
1977 info
= sdscatprintf(info
, "# Keyspace\r\n");
1978 for (j
= 0; j
< server
.dbnum
; j
++) {
1979 long long keys
, vkeys
;
1981 keys
= dictSize(server
.db
[j
].dict
);
1982 vkeys
= dictSize(server
.db
[j
].expires
);
1983 if (keys
|| vkeys
) {
1984 info
= sdscatprintf(info
, "db%d:keys=%lld,expires=%lld\r\n",
1992 void infoCommand(redisClient
*c
) {
1993 char *section
= c
->argc
== 2 ? c
->argv
[1]->ptr
: "default";
1996 addReply(c
,shared
.syntaxerr
);
1999 sds info
= genRedisInfoString(section
);
2000 addReplySds(c
,sdscatprintf(sdsempty(),"$%lu\r\n",
2001 (unsigned long)sdslen(info
)));
2002 addReplySds(c
,info
);
2003 addReply(c
,shared
.crlf
);
2006 void monitorCommand(redisClient
*c
) {
2007 /* ignore MONITOR if aleady slave or in monitor mode */
2008 if (c
->flags
& REDIS_SLAVE
) return;
2010 c
->flags
|= (REDIS_SLAVE
|REDIS_MONITOR
);
2012 listAddNodeTail(server
.monitors
,c
);
2013 addReply(c
,shared
.ok
);
2016 /* ============================ Maxmemory directive ======================== */
2018 /* This function gets called when 'maxmemory' is set on the config file to limit
2019 * the max memory used by the server, before processing a command.
2021 * The goal of the function is to free enough memory to keep Redis under the
2022 * configured memory limit.
2024 * The function starts calculating how many bytes should be freed to keep
2025 * Redis under the limit, and enters a loop selecting the best keys to
2026 * evict accordingly to the configured policy.
2028 * If all the bytes needed to return back under the limit were freed the
2029 * function returns REDIS_OK, otherwise REDIS_ERR is returned, and the caller
2030 * should block the execution of commands that will result in more memory
2031 * used by the server.
2033 int freeMemoryIfNeeded(void) {
2034 size_t mem_used
, mem_tofree
, mem_freed
;
2035 int slaves
= listLength(server
.slaves
);
2037 /* Remove the size of slaves output buffers and AOF buffer from the
2038 * count of used memory. */
2039 mem_used
= zmalloc_used_memory();
2044 listRewind(server
.slaves
,&li
);
2045 while((ln
= listNext(&li
))) {
2046 redisClient
*slave
= listNodeValue(ln
);
2047 unsigned long obuf_bytes
= getClientOutputBufferMemoryUsage(slave
);
2048 if (obuf_bytes
> mem_used
)
2051 mem_used
-= obuf_bytes
;
2054 if (server
.aof_state
!= REDIS_AOF_OFF
) {
2055 mem_used
-= sdslen(server
.aof_buf
);
2056 mem_used
-= sdslen(server
.aof_rewrite_buf
);
2059 /* Check if we are over the memory limit. */
2060 if (mem_used
<= server
.maxmemory
) return REDIS_OK
;
2062 if (server
.maxmemory_policy
== REDIS_MAXMEMORY_NO_EVICTION
)
2063 return REDIS_ERR
; /* We need to free memory, but policy forbids. */
2065 /* Compute how much memory we need to free. */
2066 mem_tofree
= mem_used
- server
.maxmemory
;
2068 while (mem_freed
< mem_tofree
) {
2069 int j
, k
, keys_freed
= 0;
2071 for (j
= 0; j
< server
.dbnum
; j
++) {
2072 long bestval
= 0; /* just to prevent warning */
2074 struct dictEntry
*de
;
2075 redisDb
*db
= server
.db
+j
;
2078 if (server
.maxmemory_policy
== REDIS_MAXMEMORY_ALLKEYS_LRU
||
2079 server
.maxmemory_policy
== REDIS_MAXMEMORY_ALLKEYS_RANDOM
)
2081 dict
= server
.db
[j
].dict
;
2083 dict
= server
.db
[j
].expires
;
2085 if (dictSize(dict
) == 0) continue;
2087 /* volatile-random and allkeys-random policy */
2088 if (server
.maxmemory_policy
== REDIS_MAXMEMORY_ALLKEYS_RANDOM
||
2089 server
.maxmemory_policy
== REDIS_MAXMEMORY_VOLATILE_RANDOM
)
2091 de
= dictGetRandomKey(dict
);
2092 bestkey
= dictGetKey(de
);
2095 /* volatile-lru and allkeys-lru policy */
2096 else if (server
.maxmemory_policy
== REDIS_MAXMEMORY_ALLKEYS_LRU
||
2097 server
.maxmemory_policy
== REDIS_MAXMEMORY_VOLATILE_LRU
)
2099 for (k
= 0; k
< server
.maxmemory_samples
; k
++) {
2104 de
= dictGetRandomKey(dict
);
2105 thiskey
= dictGetKey(de
);
2106 /* When policy is volatile-lru we need an additonal lookup
2107 * to locate the real key, as dict is set to db->expires. */
2108 if (server
.maxmemory_policy
== REDIS_MAXMEMORY_VOLATILE_LRU
)
2109 de
= dictFind(db
->dict
, thiskey
);
2111 thisval
= estimateObjectIdleTime(o
);
2113 /* Higher idle time is better candidate for deletion */
2114 if (bestkey
== NULL
|| thisval
> bestval
) {
2122 else if (server
.maxmemory_policy
== REDIS_MAXMEMORY_VOLATILE_TTL
) {
2123 for (k
= 0; k
< server
.maxmemory_samples
; k
++) {
2127 de
= dictGetRandomKey(dict
);
2128 thiskey
= dictGetKey(de
);
2129 thisval
= (long) dictGetVal(de
);
2131 /* Expire sooner (minor expire unix timestamp) is better
2132 * candidate for deletion */
2133 if (bestkey
== NULL
|| thisval
< bestval
) {
2140 /* Finally remove the selected key. */
2144 robj
*keyobj
= createStringObject(bestkey
,sdslen(bestkey
));
2145 propagateExpire(db
,keyobj
);
2146 /* We compute the amount of memory freed by dbDelete() alone.
2147 * It is possible that actually the memory needed to propagate
2148 * the DEL in AOF and replication link is greater than the one
2149 * we are freeing removing the key, but we can't account for
2150 * that otherwise we would never exit the loop.
2152 * AOF and Output buffer memory will be freed eventually so
2153 * we only care about memory used by the key space. */
2154 delta
= (long long) zmalloc_used_memory();
2155 dbDelete(db
,keyobj
);
2156 delta
-= (long long) zmalloc_used_memory();
2158 server
.stat_evictedkeys
++;
2159 decrRefCount(keyobj
);
2162 /* When the memory to free starts to be big enough, we may
2163 * start spending so much time here that is impossible to
2164 * deliver data to the slaves fast enough, so we force the
2165 * transmission here inside the loop. */
2166 if (slaves
) flushSlavesOutputBuffers();
2169 if (!keys_freed
) return REDIS_ERR
; /* nothing to free... */
2174 /* =================================== Main! ================================ */
2177 int linuxOvercommitMemoryValue(void) {
2178 FILE *fp
= fopen("/proc/sys/vm/overcommit_memory","r");
2182 if (fgets(buf
,64,fp
) == NULL
) {
2191 void linuxOvercommitMemoryWarning(void) {
2192 if (linuxOvercommitMemoryValue() == 0) {
2193 redisLog(REDIS_WARNING
,"WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.");
2196 #endif /* __linux__ */
2198 void createPidFile(void) {
2199 /* Try to write the pid file in a best-effort way. */
2200 FILE *fp
= fopen(server
.pidfile
,"w");
2202 fprintf(fp
,"%d\n",(int)getpid());
2207 void daemonize(void) {
2210 if (fork() != 0) exit(0); /* parent exits */
2211 setsid(); /* create a new session */
2213 /* Every output goes to /dev/null. If Redis is daemonized but
2214 * the 'logfile' is set to 'stdout' in the configuration file
2215 * it will not log at all. */
2216 if ((fd
= open("/dev/null", O_RDWR
, 0)) != -1) {
2217 dup2(fd
, STDIN_FILENO
);
2218 dup2(fd
, STDOUT_FILENO
);
2219 dup2(fd
, STDERR_FILENO
);
2220 if (fd
> STDERR_FILENO
) close(fd
);
2225 printf("Redis server version %s (%s:%d)\n", REDIS_VERSION
,
2226 redisGitSHA1(), atoi(redisGitDirty()) > 0);
2231 fprintf(stderr
,"Usage: ./redis-server [/path/to/redis.conf] [options]\n");
2232 fprintf(stderr
," ./redis-server - (read config from stdin)\n");
2233 fprintf(stderr
," ./redis-server -v or --version\n");
2234 fprintf(stderr
," ./redis-server -h or --help\n");
2235 fprintf(stderr
," ./redis-server --test-memory <megabytes>\n\n");
2236 fprintf(stderr
,"Examples:\n");
2237 fprintf(stderr
," ./redis-server (run the server with default conf)\n");
2238 fprintf(stderr
," ./redis-server /etc/redis/6379.conf\n");
2239 fprintf(stderr
," ./redis-server --port 7777\n");
2240 fprintf(stderr
," ./redis-server --port 7777 --slaveof 127.0.0.1 8888\n");
2241 fprintf(stderr
," ./redis-server /etc/myredis.conf --loglevel verbose\n");
2245 void redisAsciiArt(void) {
2246 #include "asciilogo.h"
2247 char *buf
= zmalloc(1024*16);
2249 snprintf(buf
,1024*16,ascii_logo
,
2252 strtol(redisGitDirty(),NULL
,10) > 0,
2253 (sizeof(long) == 8) ? "64" : "32",
2254 server
.cluster_enabled
? "cluster" : "stand alone",
2258 redisLogRaw(REDIS_NOTICE
|REDIS_LOG_RAW
,buf
);
2262 static void sigtermHandler(int sig
) {
2265 redisLog(REDIS_WARNING
,"Received SIGTERM, scheduling shutdown...");
2266 server
.shutdown_asap
= 1;
2269 void setupSignalHandlers(void) {
2270 struct sigaction act
;
2272 /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction is used.
2273 * Otherwise, sa_handler is used. */
2274 sigemptyset(&act
.sa_mask
);
2275 act
.sa_flags
= SA_NODEFER
| SA_ONSTACK
| SA_RESETHAND
;
2276 act
.sa_handler
= sigtermHandler
;
2277 sigaction(SIGTERM
, &act
, NULL
);
2279 #ifdef HAVE_BACKTRACE
2280 sigemptyset(&act
.sa_mask
);
2281 act
.sa_flags
= SA_NODEFER
| SA_ONSTACK
| SA_RESETHAND
| SA_SIGINFO
;
2282 act
.sa_sigaction
= sigsegvHandler
;
2283 sigaction(SIGSEGV
, &act
, NULL
);
2284 sigaction(SIGBUS
, &act
, NULL
);
2285 sigaction(SIGFPE
, &act
, NULL
);
2286 sigaction(SIGILL
, &act
, NULL
);
2291 void memtest(size_t megabytes
, int passes
);
2293 int main(int argc
, char **argv
) {
2297 /* We need to initialize our libraries, and the server configuration. */
2298 zmalloc_enable_thread_safeness();
2299 srand(time(NULL
)^getpid());
2300 gettimeofday(&tv
,NULL
);
2301 dictSetHashFunctionSeed(tv
.tv_sec
^tv
.tv_usec
^getpid());
2305 int j
= 1; /* First option to parse in argv[] */
2306 sds options
= sdsempty();
2307 char *configfile
= NULL
;
2309 /* Handle special options --help and --version */
2310 if (strcmp(argv
[1], "-v") == 0 ||
2311 strcmp(argv
[1], "--version") == 0) version();
2312 if (strcmp(argv
[1], "--help") == 0 ||
2313 strcmp(argv
[1], "-h") == 0) usage();
2314 if (strcmp(argv
[1], "--test-memory") == 0) {
2316 memtest(atoi(argv
[2]),300);
2319 fprintf(stderr
,"Please specify the amount of memory to test in megabytes.\n");
2320 fprintf(stderr
,"Example: ./redis-server --test-memory 4096\n\n");
2325 /* First argument is the config file name? */
2326 if (argv
[j
][0] != '-' || argv
[j
][1] != '-')
2327 configfile
= argv
[j
++];
2328 /* All the other options are parsed and conceptually appended to the
2329 * configuration file. For instance --port 6380 will generate the
2330 * string "port 6380\n" to be parsed after the actual file name
2331 * is parsed, if any. */
2333 if (argv
[j
][0] == '-' && argv
[j
][1] == '-') {
2335 if (sdslen(options
)) options
= sdscat(options
,"\n");
2336 options
= sdscat(options
,argv
[j
]+2);
2337 options
= sdscat(options
," ");
2339 /* Option argument */
2340 options
= sdscatrepr(options
,argv
[j
],strlen(argv
[j
]));
2341 options
= sdscat(options
," ");
2345 resetServerSaveParams();
2346 loadServerConfig(configfile
,options
);
2349 redisLog(REDIS_WARNING
,"Warning: no config file specified, using the default config. In order to specify a config file use 'redis-server /path/to/redis.conf'");
2351 if (server
.daemonize
) daemonize();
2353 if (server
.daemonize
) createPidFile();
2355 redisLog(REDIS_WARNING
,"Server started, Redis version " REDIS_VERSION
);
2357 linuxOvercommitMemoryWarning();
2360 if (server
.aof_state
== REDIS_AOF_ON
) {
2361 if (loadAppendOnlyFile(server
.aof_filename
) == REDIS_OK
)
2362 redisLog(REDIS_NOTICE
,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start
)/1000000);
2364 if (rdbLoad(server
.rdb_filename
) == REDIS_OK
) {
2365 redisLog(REDIS_NOTICE
,"DB loaded from disk: %.3f seconds",
2366 (float)(ustime()-start
)/1000000);
2367 } else if (errno
!= ENOENT
) {
2368 redisLog(REDIS_WARNING
,"Fatal error loading the DB. Exiting.");
2372 if (server
.ipfd
> 0)
2373 redisLog(REDIS_NOTICE
,"The server is now ready to accept connections on port %d", server
.port
);
2374 if (server
.sofd
> 0)
2375 redisLog(REDIS_NOTICE
,"The server is now ready to accept connections at %s", server
.unixsocket
);
2376 aeSetBeforeSleepProc(server
.el
,beforeSleep
);
2378 aeDeleteEventLoop(server
.el
);