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.
35 #endif /* HAVE_BACKTRACE */
44 #include <arpa/inet.h>
48 #include <sys/resource.h>
54 #include <sys/resource.h>
56 /* Our shared "common" objects */
58 struct sharedObjectsStruct shared
;
60 /* Global vars that are actally used as constants. The following double
61 * values are used for double on-disk serialization, and are initialized
62 * at runtime to avoid strange compiler optimizations. */
64 double R_Zero
, R_PosInf
, R_NegInf
, R_Nan
;
66 /*================================= Globals ================================= */
69 struct redisServer server
; /* server global state */
70 struct redisCommand
*commandTable
;
71 struct redisCommand redisCommandTable
[] = {
72 {"get",getCommand
,2,0,NULL
,1,1,1,0,0},
73 {"set",setCommand
,3,REDIS_CMD_DENYOOM
,noPreloadGetKeys
,1,1,1,0,0},
74 {"setnx",setnxCommand
,3,REDIS_CMD_DENYOOM
,noPreloadGetKeys
,1,1,1,0,0},
75 {"setex",setexCommand
,4,REDIS_CMD_DENYOOM
,noPreloadGetKeys
,2,2,1,0,0},
76 {"append",appendCommand
,3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
77 {"strlen",strlenCommand
,2,0,NULL
,1,1,1,0,0},
78 {"del",delCommand
,-2,0,noPreloadGetKeys
,1,-1,1,0,0},
79 {"exists",existsCommand
,2,0,NULL
,1,1,1,0,0},
80 {"setbit",setbitCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
81 {"getbit",getbitCommand
,3,0,NULL
,1,1,1,0,0},
82 {"setrange",setrangeCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
83 {"getrange",getrangeCommand
,4,0,NULL
,1,1,1,0,0},
84 {"substr",getrangeCommand
,4,0,NULL
,1,1,1,0,0},
85 {"incr",incrCommand
,2,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
86 {"decr",decrCommand
,2,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
87 {"mget",mgetCommand
,-2,0,NULL
,1,-1,1,0,0},
88 {"rpush",rpushCommand
,-3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
89 {"lpush",lpushCommand
,-3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
90 {"rpushx",rpushxCommand
,3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
91 {"lpushx",lpushxCommand
,3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
92 {"linsert",linsertCommand
,5,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
93 {"rpop",rpopCommand
,2,0,NULL
,1,1,1,0,0},
94 {"lpop",lpopCommand
,2,0,NULL
,1,1,1,0,0},
95 {"brpop",brpopCommand
,-3,0,NULL
,1,1,1,0,0},
96 {"brpoplpush",brpoplpushCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,2,1,0,0},
97 {"blpop",blpopCommand
,-3,0,NULL
,1,-2,1,0,0},
98 {"llen",llenCommand
,2,0,NULL
,1,1,1,0,0},
99 {"lindex",lindexCommand
,3,0,NULL
,1,1,1,0,0},
100 {"lset",lsetCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
101 {"lrange",lrangeCommand
,4,0,NULL
,1,1,1,0,0},
102 {"ltrim",ltrimCommand
,4,0,NULL
,1,1,1,0,0},
103 {"lrem",lremCommand
,4,0,NULL
,1,1,1,0,0},
104 {"rpoplpush",rpoplpushCommand
,3,REDIS_CMD_DENYOOM
,NULL
,1,2,1,0,0},
105 {"sadd",saddCommand
,-3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
106 {"srem",sremCommand
,-3,0,NULL
,1,1,1,0,0},
107 {"smove",smoveCommand
,4,0,NULL
,1,2,1,0,0},
108 {"sismember",sismemberCommand
,3,0,NULL
,1,1,1,0,0},
109 {"scard",scardCommand
,2,0,NULL
,1,1,1,0,0},
110 {"spop",spopCommand
,2,0,NULL
,1,1,1,0,0},
111 {"srandmember",srandmemberCommand
,2,0,NULL
,1,1,1,0,0},
112 {"sinter",sinterCommand
,-2,REDIS_CMD_DENYOOM
,NULL
,1,-1,1,0,0},
113 {"sinterstore",sinterstoreCommand
,-3,REDIS_CMD_DENYOOM
,NULL
,2,-1,1,0,0},
114 {"sunion",sunionCommand
,-2,REDIS_CMD_DENYOOM
,NULL
,1,-1,1,0,0},
115 {"sunionstore",sunionstoreCommand
,-3,REDIS_CMD_DENYOOM
,NULL
,2,-1,1,0,0},
116 {"sdiff",sdiffCommand
,-2,REDIS_CMD_DENYOOM
,NULL
,1,-1,1,0,0},
117 {"sdiffstore",sdiffstoreCommand
,-3,REDIS_CMD_DENYOOM
,NULL
,2,-1,1,0,0},
118 {"smembers",sinterCommand
,2,0,NULL
,1,1,1,0,0},
119 {"zadd",zaddCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
120 {"zincrby",zincrbyCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
121 {"zrem",zremCommand
,3,0,NULL
,1,1,1,0,0},
122 {"zremrangebyscore",zremrangebyscoreCommand
,4,0,NULL
,1,1,1,0,0},
123 {"zremrangebyrank",zremrangebyrankCommand
,4,0,NULL
,1,1,1,0,0},
124 {"zunionstore",zunionstoreCommand
,-4,REDIS_CMD_DENYOOM
,zunionInterGetKeys
,0,0,0,0,0},
125 {"zinterstore",zinterstoreCommand
,-4,REDIS_CMD_DENYOOM
,zunionInterGetKeys
,0,0,0,0,0},
126 {"zrange",zrangeCommand
,-4,0,NULL
,1,1,1,0,0},
127 {"zrangebyscore",zrangebyscoreCommand
,-4,0,NULL
,1,1,1,0,0},
128 {"zrevrangebyscore",zrevrangebyscoreCommand
,-4,0,NULL
,1,1,1,0,0},
129 {"zcount",zcountCommand
,4,0,NULL
,1,1,1,0,0},
130 {"zrevrange",zrevrangeCommand
,-4,0,NULL
,1,1,1,0,0},
131 {"zcard",zcardCommand
,2,0,NULL
,1,1,1,0,0},
132 {"zscore",zscoreCommand
,3,0,NULL
,1,1,1,0,0},
133 {"zrank",zrankCommand
,3,0,NULL
,1,1,1,0,0},
134 {"zrevrank",zrevrankCommand
,3,0,NULL
,1,1,1,0,0},
135 {"hset",hsetCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
136 {"hsetnx",hsetnxCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
137 {"hget",hgetCommand
,3,0,NULL
,1,1,1,0,0},
138 {"hmset",hmsetCommand
,-4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
139 {"hmget",hmgetCommand
,-3,0,NULL
,1,1,1,0,0},
140 {"hincrby",hincrbyCommand
,4,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
141 {"hdel",hdelCommand
,-3,0,NULL
,1,1,1,0,0},
142 {"hlen",hlenCommand
,2,0,NULL
,1,1,1,0,0},
143 {"hkeys",hkeysCommand
,2,0,NULL
,1,1,1,0,0},
144 {"hvals",hvalsCommand
,2,0,NULL
,1,1,1,0,0},
145 {"hgetall",hgetallCommand
,2,0,NULL
,1,1,1,0,0},
146 {"hexists",hexistsCommand
,3,0,NULL
,1,1,1,0,0},
147 {"incrby",incrbyCommand
,3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
148 {"decrby",decrbyCommand
,3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
149 {"getset",getsetCommand
,3,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
150 {"mset",msetCommand
,-3,REDIS_CMD_DENYOOM
,NULL
,1,-1,2,0,0},
151 {"msetnx",msetnxCommand
,-3,REDIS_CMD_DENYOOM
,NULL
,1,-1,2,0,0},
152 {"randomkey",randomkeyCommand
,1,0,NULL
,0,0,0,0,0},
153 {"select",selectCommand
,2,0,NULL
,0,0,0,0,0},
154 {"move",moveCommand
,3,0,NULL
,1,1,1,0,0},
155 {"rename",renameCommand
,3,0,renameGetKeys
,1,2,1,0,0},
156 {"renamenx",renamenxCommand
,3,0,renameGetKeys
,1,2,1,0,0},
157 {"expire",expireCommand
,3,0,NULL
,1,1,1,0,0},
158 {"expireat",expireatCommand
,3,0,NULL
,1,1,1,0,0},
159 {"keys",keysCommand
,2,0,NULL
,0,0,0,0,0},
160 {"dbsize",dbsizeCommand
,1,0,NULL
,0,0,0,0,0},
161 {"auth",authCommand
,2,0,NULL
,0,0,0,0,0},
162 {"ping",pingCommand
,1,0,NULL
,0,0,0,0,0},
163 {"echo",echoCommand
,2,0,NULL
,0,0,0,0,0},
164 {"save",saveCommand
,1,0,NULL
,0,0,0,0,0},
165 {"bgsave",bgsaveCommand
,1,0,NULL
,0,0,0,0,0},
166 {"bgrewriteaof",bgrewriteaofCommand
,1,0,NULL
,0,0,0,0,0},
167 {"shutdown",shutdownCommand
,1,0,NULL
,0,0,0,0,0},
168 {"lastsave",lastsaveCommand
,1,0,NULL
,0,0,0,0,0},
169 {"type",typeCommand
,2,0,NULL
,1,1,1,0,0},
170 {"multi",multiCommand
,1,0,NULL
,0,0,0,0,0},
171 {"exec",execCommand
,1,REDIS_CMD_DENYOOM
,NULL
,0,0,0,0,0},
172 {"discard",discardCommand
,1,0,NULL
,0,0,0,0,0},
173 {"sync",syncCommand
,1,0,NULL
,0,0,0,0,0},
174 {"flushdb",flushdbCommand
,1,0,NULL
,0,0,0,0,0},
175 {"flushall",flushallCommand
,1,0,NULL
,0,0,0,0,0},
176 {"sort",sortCommand
,-2,REDIS_CMD_DENYOOM
,NULL
,1,1,1,0,0},
177 {"info",infoCommand
,-1,0,NULL
,0,0,0,0,0},
178 {"monitor",monitorCommand
,1,0,NULL
,0,0,0,0,0},
179 {"ttl",ttlCommand
,2,0,NULL
,1,1,1,0,0},
180 {"persist",persistCommand
,2,0,NULL
,1,1,1,0,0},
181 {"slaveof",slaveofCommand
,3,0,NULL
,0,0,0,0,0},
182 {"debug",debugCommand
,-2,0,NULL
,0,0,0,0,0},
183 {"config",configCommand
,-2,0,NULL
,0,0,0,0,0},
184 {"subscribe",subscribeCommand
,-2,0,NULL
,0,0,0,0,0},
185 {"unsubscribe",unsubscribeCommand
,-1,0,NULL
,0,0,0,0,0},
186 {"psubscribe",psubscribeCommand
,-2,0,NULL
,0,0,0,0,0},
187 {"punsubscribe",punsubscribeCommand
,-1,0,NULL
,0,0,0,0,0},
188 {"publish",publishCommand
,3,REDIS_CMD_FORCE_REPLICATION
,NULL
,0,0,0,0,0},
189 {"watch",watchCommand
,-2,0,noPreloadGetKeys
,1,-1,1,0,0},
190 {"unwatch",unwatchCommand
,1,0,NULL
,0,0,0,0,0},
191 {"cluster",clusterCommand
,-2,0,NULL
,0,0,0,0,0},
192 {"restore",restoreCommand
,4,0,NULL
,0,0,0,0,0},
193 {"migrate",migrateCommand
,6,0,NULL
,0,0,0,0,0},
194 {"dump",dumpCommand
,2,0,NULL
,0,0,0,0,0},
195 {"object",objectCommand
,-2,0,NULL
,0,0,0,0,0},
196 {"client",clientCommand
,-2,0,NULL
,0,0,0,0,0}
199 /*============================ Utility functions ============================ */
201 /* Low level logging. To use only for very big messages, otherwise
202 * redisLog() is to prefer. */
203 void redisLogRaw(int level
, const char *msg
) {
204 const int syslogLevelMap
[] = { LOG_DEBUG
, LOG_INFO
, LOG_NOTICE
, LOG_WARNING
};
205 const char *c
= ".-*#";
206 time_t now
= time(NULL
);
209 int rawmode
= (level
& REDIS_LOG_RAW
);
211 level
&= 0xff; /* clear flags */
212 if (level
< server
.verbosity
) return;
214 fp
= (server
.logfile
== NULL
) ? stdout
: fopen(server
.logfile
,"a");
218 fprintf(fp
,"%s",msg
);
220 strftime(buf
,sizeof(buf
),"%d %b %H:%M:%S",localtime(&now
));
221 fprintf(fp
,"[%d] %s %c %s\n",(int)getpid(),buf
,c
[level
],msg
);
225 if (server
.logfile
) fclose(fp
);
227 if (server
.syslog_enabled
) syslog(syslogLevelMap
[level
], "%s", msg
);
230 /* Like redisLogRaw() but with printf-alike support. This is the funciton that
231 * is used across the code. The raw version is only used in order to dump
232 * the INFO output on crash. */
233 void redisLog(int level
, const char *fmt
, ...) {
235 char msg
[REDIS_MAX_LOGMSG_LEN
];
237 if ((level
&0xff) < server
.verbosity
) return;
240 vsnprintf(msg
, sizeof(msg
), fmt
, ap
);
243 redisLogRaw(level
,msg
);
246 /* Redis generally does not try to recover from out of memory conditions
247 * when allocating objects or strings, it is not clear if it will be possible
248 * to report this condition to the client since the networking layer itself
249 * is based on heap allocation for send buffers, so we simply abort.
250 * At least the code will be simpler to read... */
251 void oom(const char *msg
) {
252 redisLog(REDIS_WARNING
, "%s: Out of memory\n",msg
);
257 /* Return the UNIX time in microseconds */
258 long long ustime(void) {
262 gettimeofday(&tv
, NULL
);
263 ust
= ((long long)tv
.tv_sec
)*1000000;
268 /*====================== Hash table type implementation ==================== */
270 /* This is an hash table type that uses the SDS dynamic strings libary as
271 * keys and radis objects as values (objects can hold SDS strings,
274 void dictVanillaFree(void *privdata
, void *val
)
276 DICT_NOTUSED(privdata
);
280 void dictListDestructor(void *privdata
, void *val
)
282 DICT_NOTUSED(privdata
);
283 listRelease((list
*)val
);
286 int dictSdsKeyCompare(void *privdata
, const void *key1
,
290 DICT_NOTUSED(privdata
);
292 l1
= sdslen((sds
)key1
);
293 l2
= sdslen((sds
)key2
);
294 if (l1
!= l2
) return 0;
295 return memcmp(key1
, key2
, l1
) == 0;
298 /* A case insensitive version used for the command lookup table. */
299 int dictSdsKeyCaseCompare(void *privdata
, const void *key1
,
302 DICT_NOTUSED(privdata
);
304 return strcasecmp(key1
, key2
) == 0;
307 void dictRedisObjectDestructor(void *privdata
, void *val
)
309 DICT_NOTUSED(privdata
);
311 if (val
== NULL
) return; /* Values of swapped out keys as set to NULL */
315 void dictSdsDestructor(void *privdata
, void *val
)
317 DICT_NOTUSED(privdata
);
322 int dictObjKeyCompare(void *privdata
, const void *key1
,
325 const robj
*o1
= key1
, *o2
= key2
;
326 return dictSdsKeyCompare(privdata
,o1
->ptr
,o2
->ptr
);
329 unsigned int dictObjHash(const void *key
) {
331 return dictGenHashFunction(o
->ptr
, sdslen((sds
)o
->ptr
));
334 unsigned int dictSdsHash(const void *key
) {
335 return dictGenHashFunction((unsigned char*)key
, sdslen((char*)key
));
338 unsigned int dictSdsCaseHash(const void *key
) {
339 return dictGenCaseHashFunction((unsigned char*)key
, sdslen((char*)key
));
342 int dictEncObjKeyCompare(void *privdata
, const void *key1
,
345 robj
*o1
= (robj
*) key1
, *o2
= (robj
*) key2
;
348 if (o1
->encoding
== REDIS_ENCODING_INT
&&
349 o2
->encoding
== REDIS_ENCODING_INT
)
350 return o1
->ptr
== o2
->ptr
;
352 o1
= getDecodedObject(o1
);
353 o2
= getDecodedObject(o2
);
354 cmp
= dictSdsKeyCompare(privdata
,o1
->ptr
,o2
->ptr
);
360 unsigned int dictEncObjHash(const void *key
) {
361 robj
*o
= (robj
*) key
;
363 if (o
->encoding
== REDIS_ENCODING_RAW
) {
364 return dictGenHashFunction(o
->ptr
, sdslen((sds
)o
->ptr
));
366 if (o
->encoding
== REDIS_ENCODING_INT
) {
370 len
= ll2string(buf
,32,(long)o
->ptr
);
371 return dictGenHashFunction((unsigned char*)buf
, len
);
375 o
= getDecodedObject(o
);
376 hash
= dictGenHashFunction(o
->ptr
, sdslen((sds
)o
->ptr
));
383 /* Sets type and diskstore negative caching hash table */
384 dictType setDictType
= {
385 dictEncObjHash
, /* hash function */
388 dictEncObjKeyCompare
, /* key compare */
389 dictRedisObjectDestructor
, /* key destructor */
390 NULL
/* val destructor */
393 /* Sorted sets hash (note: a skiplist is used in addition to the hash table) */
394 dictType zsetDictType
= {
395 dictEncObjHash
, /* hash function */
398 dictEncObjKeyCompare
, /* key compare */
399 dictRedisObjectDestructor
, /* key destructor */
400 NULL
/* val destructor */
403 /* Db->dict, keys are sds strings, vals are Redis objects. */
404 dictType dbDictType
= {
405 dictSdsHash
, /* hash function */
408 dictSdsKeyCompare
, /* key compare */
409 dictSdsDestructor
, /* key destructor */
410 dictRedisObjectDestructor
/* val destructor */
414 dictType keyptrDictType
= {
415 dictSdsHash
, /* hash function */
418 dictSdsKeyCompare
, /* key compare */
419 NULL
, /* key destructor */
420 NULL
/* val destructor */
423 /* Command table. sds string -> command struct pointer. */
424 dictType commandTableDictType
= {
425 dictSdsCaseHash
, /* hash function */
428 dictSdsKeyCaseCompare
, /* key compare */
429 dictSdsDestructor
, /* key destructor */
430 NULL
/* val destructor */
433 /* Hash type hash table (note that small hashes are represented with zimpaps) */
434 dictType hashDictType
= {
435 dictEncObjHash
, /* hash function */
438 dictEncObjKeyCompare
, /* key compare */
439 dictRedisObjectDestructor
, /* key destructor */
440 dictRedisObjectDestructor
/* val destructor */
443 /* Keylist hash table type has unencoded redis objects as keys and
444 * lists as values. It's used for blocking operations (BLPOP) and to
445 * map swapped keys to a list of clients waiting for this keys to be loaded. */
446 dictType keylistDictType
= {
447 dictObjHash
, /* hash function */
450 dictObjKeyCompare
, /* key compare */
451 dictRedisObjectDestructor
, /* key destructor */
452 dictListDestructor
/* val destructor */
455 /* Cluster nodes hash table, mapping nodes addresses 1.2.3.4:6379 to
456 * clusterNode structures. */
457 dictType clusterNodesDictType
= {
458 dictSdsHash
, /* hash function */
461 dictSdsKeyCompare
, /* key compare */
462 dictSdsDestructor
, /* key destructor */
463 NULL
/* val destructor */
466 int htNeedsResize(dict
*dict
) {
467 long long size
, used
;
469 size
= dictSlots(dict
);
470 used
= dictSize(dict
);
471 return (size
&& used
&& size
> DICT_HT_INITIAL_SIZE
&&
472 (used
*100/size
< REDIS_HT_MINFILL
));
475 /* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
476 * we resize the hash table to save memory */
477 void tryResizeHashTables(void) {
480 for (j
= 0; j
< server
.dbnum
; j
++) {
481 if (htNeedsResize(server
.db
[j
].dict
))
482 dictResize(server
.db
[j
].dict
);
483 if (htNeedsResize(server
.db
[j
].expires
))
484 dictResize(server
.db
[j
].expires
);
488 /* Our hash table implementation performs rehashing incrementally while
489 * we write/read from the hash table. Still if the server is idle, the hash
490 * table will use two tables for a long time. So we try to use 1 millisecond
491 * of CPU time at every serverCron() loop in order to rehash some key. */
492 void incrementallyRehash(void) {
495 for (j
= 0; j
< server
.dbnum
; j
++) {
496 if (dictIsRehashing(server
.db
[j
].dict
)) {
497 dictRehashMilliseconds(server
.db
[j
].dict
,1);
498 break; /* already used our millisecond for this loop... */
503 /* This function is called once a background process of some kind terminates,
504 * as we want to avoid resizing the hash tables when there is a child in order
505 * to play well with copy-on-write (otherwise when a resize happens lots of
506 * memory pages are copied). The goal of this function is to update the ability
507 * for dict.c to resize the hash tables accordingly to the fact we have o not
509 void updateDictResizePolicy(void) {
510 if (server
.bgsavechildpid
== -1 && server
.bgrewritechildpid
== -1)
516 /* ======================= Cron: called every 100 ms ======================== */
518 /* Try to expire a few timed out keys. The algorithm used is adaptive and
519 * will use few CPU cycles if there are few expiring keys, otherwise
520 * it will get more aggressive to avoid that too much memory is used by
521 * keys that can be removed from the keyspace. */
522 void activeExpireCycle(void) {
525 for (j
= 0; j
< server
.dbnum
; j
++) {
527 redisDb
*db
= server
.db
+j
;
529 /* Continue to expire if at the end of the cycle more than 25%
530 * of the keys were expired. */
532 long num
= dictSize(db
->expires
);
533 time_t now
= time(NULL
);
536 if (num
> REDIS_EXPIRELOOKUPS_PER_CRON
)
537 num
= REDIS_EXPIRELOOKUPS_PER_CRON
;
542 if ((de
= dictGetRandomKey(db
->expires
)) == NULL
) break;
543 t
= (time_t) dictGetEntryVal(de
);
545 sds key
= dictGetEntryKey(de
);
546 robj
*keyobj
= createStringObject(key
,sdslen(key
));
548 propagateExpire(db
,keyobj
);
550 decrRefCount(keyobj
);
552 server
.stat_expiredkeys
++;
555 } while (expired
> REDIS_EXPIRELOOKUPS_PER_CRON
/4);
559 void updateLRUClock(void) {
560 server
.lruclock
= (time(NULL
)/REDIS_LRU_CLOCK_RESOLUTION
) &
564 int serverCron(struct aeEventLoop
*eventLoop
, long long id
, void *clientData
) {
565 int j
, loops
= server
.cronloops
;
566 REDIS_NOTUSED(eventLoop
);
568 REDIS_NOTUSED(clientData
);
570 /* We take a cached value of the unix time in the global state because
571 * with virtual memory and aging there is to store the current time
572 * in objects at every object access, and accuracy is not needed.
573 * To access a global var is faster than calling time(NULL) */
574 server
.unixtime
= time(NULL
);
575 /* We have just 22 bits per object for LRU information.
576 * So we use an (eventually wrapping) LRU clock with 10 seconds resolution.
577 * 2^22 bits with 10 seconds resoluton is more or less 1.5 years.
579 * Note that even if this will wrap after 1.5 years it's not a problem,
580 * everything will still work but just some object will appear younger
581 * to Redis. But for this to happen a given object should never be touched
584 * Note that you can change the resolution altering the
585 * REDIS_LRU_CLOCK_RESOLUTION define.
589 /* Record the max memory used since the server was started. */
590 if (zmalloc_used_memory() > server
.stat_peak_memory
)
591 server
.stat_peak_memory
= zmalloc_used_memory();
593 /* We received a SIGTERM, shutting down here in a safe way, as it is
594 * not ok doing so inside the signal handler. */
595 if (server
.shutdown_asap
) {
596 if (prepareForShutdown() == REDIS_OK
) exit(0);
597 redisLog(REDIS_WARNING
,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
600 /* Show some info about non-empty databases */
601 for (j
= 0; j
< server
.dbnum
; j
++) {
602 long long size
, used
, vkeys
;
604 size
= dictSlots(server
.db
[j
].dict
);
605 used
= dictSize(server
.db
[j
].dict
);
606 vkeys
= dictSize(server
.db
[j
].expires
);
607 if (!(loops
% 50) && (used
|| vkeys
)) {
608 redisLog(REDIS_VERBOSE
,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j
,used
,vkeys
,size
);
609 /* dictPrintStats(server.dict); */
613 /* We don't want to resize the hash tables while a bacground saving
614 * is in progress: the saving child is created using fork() that is
615 * implemented with a copy-on-write semantic in most modern systems, so
616 * if we resize the HT while there is the saving child at work actually
617 * a lot of memory movements in the parent will cause a lot of pages
619 if (server
.bgsavechildpid
== -1 && server
.bgrewritechildpid
== -1) {
620 if (!(loops
% 10)) tryResizeHashTables();
621 if (server
.activerehashing
) incrementallyRehash();
624 /* Show information about connected clients */
626 redisLog(REDIS_VERBOSE
,"%d clients connected (%d slaves), %zu bytes in use",
627 listLength(server
.clients
)-listLength(server
.slaves
),
628 listLength(server
.slaves
),
629 zmalloc_used_memory());
632 /* Close connections of timedout clients */
633 if ((server
.maxidletime
&& !(loops
% 100)) || server
.bpop_blocked_clients
)
634 closeTimedoutClients();
636 /* Check if a background saving or AOF rewrite in progress terminated. */
637 if (server
.bgsavechildpid
!= -1 || server
.bgrewritechildpid
!= -1) {
641 if ((pid
= wait3(&statloc
,WNOHANG
,NULL
)) != 0) {
642 int exitcode
= WEXITSTATUS(statloc
);
645 if (WIFSIGNALED(statloc
)) bysignal
= WTERMSIG(statloc
);
647 if (pid
== server
.bgsavechildpid
) {
648 backgroundSaveDoneHandler(exitcode
,bysignal
);
650 backgroundRewriteDoneHandler(exitcode
,bysignal
);
652 updateDictResizePolicy();
654 } else if (server
.bgsavethread
!= (pthread_t
) -1) {
655 if (server
.bgsavethread
!= (pthread_t
) -1) {
658 pthread_mutex_lock(&server
.bgsavethread_mutex
);
659 state
= server
.bgsavethread_state
;
660 pthread_mutex_unlock(&server
.bgsavethread_mutex
);
662 if (state
== REDIS_BGSAVE_THREAD_DONE_OK
||
663 state
== REDIS_BGSAVE_THREAD_DONE_ERR
)
665 backgroundSaveDoneHandler(
666 (state
== REDIS_BGSAVE_THREAD_DONE_OK
) ? 0 : 1, 0);
669 } else if (!server
.ds_enabled
) {
670 /* If there is not a background saving in progress check if
671 * we have to save now */
672 time_t now
= time(NULL
);
673 for (j
= 0; j
< server
.saveparamslen
; j
++) {
674 struct saveparam
*sp
= server
.saveparams
+j
;
676 if (server
.dirty
>= sp
->changes
&&
677 now
-server
.lastsave
> sp
->seconds
) {
678 redisLog(REDIS_NOTICE
,"%d changes in %d seconds. Saving...",
679 sp
->changes
, sp
->seconds
);
680 rdbSaveBackground(server
.dbfilename
);
686 /* Expire a few keys per cycle, only if this is a master.
687 * On slaves we wait for DEL operations synthesized by the master
688 * in order to guarantee a strict consistency. */
689 if (server
.masterhost
== NULL
) activeExpireCycle();
691 /* Remove a few cached objects from memory if we are over the
692 * configured memory limit */
693 if (server
.ds_enabled
) cacheCron();
695 /* Replication cron function -- used to reconnect to master and
696 * to detect transfer failures. */
697 if (!(loops
% 10)) replicationCron();
699 /* Run other sub-systems specific cron jobs */
700 if (server
.cluster_enabled
&& !(loops
% 10)) clusterCron();
706 /* This function gets called every time Redis is entering the
707 * main loop of the event driven library, that is, before to sleep
708 * for ready file descriptors. */
709 void beforeSleep(struct aeEventLoop
*eventLoop
) {
710 REDIS_NOTUSED(eventLoop
);
714 /* Awake clients that got all the on disk keys they requested */
715 if (server
.ds_enabled
&& listLength(server
.io_ready_clients
)) {
718 listRewind(server
.io_ready_clients
,&li
);
719 while((ln
= listNext(&li
))) {
721 struct redisCommand
*cmd
;
723 /* Resume the client. */
724 listDelNode(server
.io_ready_clients
,ln
);
725 c
->flags
&= (~REDIS_IO_WAIT
);
726 server
.cache_blocked_clients
--;
727 aeCreateFileEvent(server
.el
, c
->fd
, AE_READABLE
,
728 readQueryFromClient
, c
);
729 cmd
= lookupCommand(c
->argv
[0]->ptr
);
730 redisAssert(cmd
!= NULL
);
733 /* There may be more data to process in the input buffer. */
734 if (c
->querybuf
&& sdslen(c
->querybuf
) > 0)
735 processInputBuffer(c
);
739 /* Try to process pending commands for clients that were just unblocked. */
740 while (listLength(server
.unblocked_clients
)) {
741 ln
= listFirst(server
.unblocked_clients
);
742 redisAssert(ln
!= NULL
);
744 listDelNode(server
.unblocked_clients
,ln
);
745 c
->flags
&= ~REDIS_UNBLOCKED
;
747 /* Process remaining data in the input buffer. */
748 if (c
->querybuf
&& sdslen(c
->querybuf
) > 0)
749 processInputBuffer(c
);
752 /* Write the AOF buffer on disk */
753 flushAppendOnlyFile();
756 /* =========================== Server initialization ======================== */
758 void createSharedObjects(void) {
761 shared
.crlf
= createObject(REDIS_STRING
,sdsnew("\r\n"));
762 shared
.ok
= createObject(REDIS_STRING
,sdsnew("+OK\r\n"));
763 shared
.err
= createObject(REDIS_STRING
,sdsnew("-ERR\r\n"));
764 shared
.emptybulk
= createObject(REDIS_STRING
,sdsnew("$0\r\n\r\n"));
765 shared
.czero
= createObject(REDIS_STRING
,sdsnew(":0\r\n"));
766 shared
.cone
= createObject(REDIS_STRING
,sdsnew(":1\r\n"));
767 shared
.cnegone
= createObject(REDIS_STRING
,sdsnew(":-1\r\n"));
768 shared
.nullbulk
= createObject(REDIS_STRING
,sdsnew("$-1\r\n"));
769 shared
.nullmultibulk
= createObject(REDIS_STRING
,sdsnew("*-1\r\n"));
770 shared
.emptymultibulk
= createObject(REDIS_STRING
,sdsnew("*0\r\n"));
771 shared
.pong
= createObject(REDIS_STRING
,sdsnew("+PONG\r\n"));
772 shared
.queued
= createObject(REDIS_STRING
,sdsnew("+QUEUED\r\n"));
773 shared
.wrongtypeerr
= createObject(REDIS_STRING
,sdsnew(
774 "-ERR Operation against a key holding the wrong kind of value\r\n"));
775 shared
.nokeyerr
= createObject(REDIS_STRING
,sdsnew(
776 "-ERR no such key\r\n"));
777 shared
.syntaxerr
= createObject(REDIS_STRING
,sdsnew(
778 "-ERR syntax error\r\n"));
779 shared
.sameobjecterr
= createObject(REDIS_STRING
,sdsnew(
780 "-ERR source and destination objects are the same\r\n"));
781 shared
.outofrangeerr
= createObject(REDIS_STRING
,sdsnew(
782 "-ERR index out of range\r\n"));
783 shared
.loadingerr
= createObject(REDIS_STRING
,sdsnew(
784 "-LOADING Redis is loading the dataset in memory\r\n"));
785 shared
.space
= createObject(REDIS_STRING
,sdsnew(" "));
786 shared
.colon
= createObject(REDIS_STRING
,sdsnew(":"));
787 shared
.plus
= createObject(REDIS_STRING
,sdsnew("+"));
788 shared
.select0
= createStringObject("select 0\r\n",10);
789 shared
.select1
= createStringObject("select 1\r\n",10);
790 shared
.select2
= createStringObject("select 2\r\n",10);
791 shared
.select3
= createStringObject("select 3\r\n",10);
792 shared
.select4
= createStringObject("select 4\r\n",10);
793 shared
.select5
= createStringObject("select 5\r\n",10);
794 shared
.select6
= createStringObject("select 6\r\n",10);
795 shared
.select7
= createStringObject("select 7\r\n",10);
796 shared
.select8
= createStringObject("select 8\r\n",10);
797 shared
.select9
= createStringObject("select 9\r\n",10);
798 shared
.messagebulk
= createStringObject("$7\r\nmessage\r\n",13);
799 shared
.pmessagebulk
= createStringObject("$8\r\npmessage\r\n",14);
800 shared
.subscribebulk
= createStringObject("$9\r\nsubscribe\r\n",15);
801 shared
.unsubscribebulk
= createStringObject("$11\r\nunsubscribe\r\n",18);
802 shared
.psubscribebulk
= createStringObject("$10\r\npsubscribe\r\n",17);
803 shared
.punsubscribebulk
= createStringObject("$12\r\npunsubscribe\r\n",19);
804 shared
.mbulk3
= createStringObject("*3\r\n",4);
805 shared
.mbulk4
= createStringObject("*4\r\n",4);
806 for (j
= 0; j
< REDIS_SHARED_INTEGERS
; j
++) {
807 shared
.integers
[j
] = createObject(REDIS_STRING
,(void*)(long)j
);
808 shared
.integers
[j
]->encoding
= REDIS_ENCODING_INT
;
812 void initServerConfig() {
813 server
.port
= REDIS_SERVERPORT
;
814 server
.bindaddr
= NULL
;
815 server
.unixsocket
= NULL
;
818 server
.dbnum
= REDIS_DEFAULT_DBNUM
;
819 server
.verbosity
= REDIS_VERBOSE
;
820 server
.maxidletime
= REDIS_MAXIDLETIME
;
821 server
.saveparams
= NULL
;
823 server
.logfile
= NULL
; /* NULL = log on standard output */
824 server
.syslog_enabled
= 0;
825 server
.syslog_ident
= zstrdup("redis");
826 server
.syslog_facility
= LOG_LOCAL0
;
827 server
.daemonize
= 0;
828 server
.appendonly
= 0;
829 server
.appendfsync
= APPENDFSYNC_EVERYSEC
;
830 server
.no_appendfsync_on_rewrite
= 0;
831 server
.lastfsync
= time(NULL
);
832 server
.appendfd
= -1;
833 server
.appendseldb
= -1; /* Make sure the first time will not match */
834 server
.pidfile
= zstrdup("/var/run/redis.pid");
835 server
.dbfilename
= zstrdup("dump.rdb");
836 server
.appendfilename
= zstrdup("appendonly.aof");
837 server
.requirepass
= NULL
;
838 server
.rdbcompression
= 1;
839 server
.activerehashing
= 1;
840 server
.maxclients
= 0;
841 server
.bpop_blocked_clients
= 0;
842 server
.maxmemory
= 0;
843 server
.maxmemory_policy
= REDIS_MAXMEMORY_VOLATILE_LRU
;
844 server
.maxmemory_samples
= 3;
845 server
.ds_enabled
= 0;
846 server
.ds_path
= sdsnew("/tmp/redis.ds");
847 server
.cache_max_memory
= 64LL*1024*1024; /* 64 MB of RAM */
848 server
.cache_blocked_clients
= 0;
849 server
.hash_max_zipmap_entries
= REDIS_HASH_MAX_ZIPMAP_ENTRIES
;
850 server
.hash_max_zipmap_value
= REDIS_HASH_MAX_ZIPMAP_VALUE
;
851 server
.list_max_ziplist_entries
= REDIS_LIST_MAX_ZIPLIST_ENTRIES
;
852 server
.list_max_ziplist_value
= REDIS_LIST_MAX_ZIPLIST_VALUE
;
853 server
.set_max_intset_entries
= REDIS_SET_MAX_INTSET_ENTRIES
;
854 server
.zset_max_ziplist_entries
= REDIS_ZSET_MAX_ZIPLIST_ENTRIES
;
855 server
.zset_max_ziplist_value
= REDIS_ZSET_MAX_ZIPLIST_VALUE
;
856 server
.shutdown_asap
= 0;
857 server
.cache_flush_delay
= 0;
858 server
.cluster_enabled
= 0;
859 server
.cluster
.configfile
= zstrdup("nodes.conf");
862 resetServerSaveParams();
864 appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
865 appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
866 appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
867 /* Replication related */
869 server
.masterauth
= NULL
;
870 server
.masterhost
= NULL
;
871 server
.masterport
= 6379;
872 server
.master
= NULL
;
873 server
.replstate
= REDIS_REPL_NONE
;
874 server
.repl_syncio_timeout
= REDIS_REPL_SYNCIO_TIMEOUT
;
875 server
.repl_serve_stale_data
= 1;
877 /* Double constants initialization */
879 R_PosInf
= 1.0/R_Zero
;
880 R_NegInf
= -1.0/R_Zero
;
881 R_Nan
= R_Zero
/R_Zero
;
883 /* Command table -- we intiialize it here as it is part of the
884 * initial configuration, since command names may be changed via
885 * redis.conf using the rename-command directive. */
886 server
.commands
= dictCreate(&commandTableDictType
,NULL
);
887 populateCommandTable();
888 server
.delCommand
= lookupCommandByCString("del");
889 server
.multiCommand
= lookupCommandByCString("multi");
895 signal(SIGHUP
, SIG_IGN
);
896 signal(SIGPIPE
, SIG_IGN
);
897 setupSignalHandlers();
899 if (server
.syslog_enabled
) {
900 openlog(server
.syslog_ident
, LOG_PID
| LOG_NDELAY
| LOG_NOWAIT
,
901 server
.syslog_facility
);
904 server
.mainthread
= pthread_self();
905 server
.clients
= listCreate();
906 server
.slaves
= listCreate();
907 server
.monitors
= listCreate();
908 server
.unblocked_clients
= listCreate();
909 server
.cache_io_queue
= listCreate();
911 createSharedObjects();
912 server
.el
= aeCreateEventLoop();
913 server
.db
= zmalloc(sizeof(redisDb
)*server
.dbnum
);
915 if (server
.port
!= 0) {
916 server
.ipfd
= anetTcpServer(server
.neterr
,server
.port
,server
.bindaddr
);
917 if (server
.ipfd
== ANET_ERR
) {
918 redisLog(REDIS_WARNING
, "Opening port: %s", server
.neterr
);
922 if (server
.unixsocket
!= NULL
) {
923 unlink(server
.unixsocket
); /* don't care if this fails */
924 server
.sofd
= anetUnixServer(server
.neterr
,server
.unixsocket
);
925 if (server
.sofd
== ANET_ERR
) {
926 redisLog(REDIS_WARNING
, "Opening socket: %s", server
.neterr
);
930 if (server
.ipfd
< 0 && server
.sofd
< 0) {
931 redisLog(REDIS_WARNING
, "Configured to not listen anywhere, exiting.");
934 for (j
= 0; j
< server
.dbnum
; j
++) {
935 server
.db
[j
].dict
= dictCreate(&dbDictType
,NULL
);
936 server
.db
[j
].expires
= dictCreate(&keyptrDictType
,NULL
);
937 server
.db
[j
].blocking_keys
= dictCreate(&keylistDictType
,NULL
);
938 server
.db
[j
].watched_keys
= dictCreate(&keylistDictType
,NULL
);
939 if (server
.ds_enabled
) {
940 server
.db
[j
].io_keys
= dictCreate(&keylistDictType
,NULL
);
941 server
.db
[j
].io_negcache
= dictCreate(&setDictType
,NULL
);
942 server
.db
[j
].io_queued
= dictCreate(&setDictType
,NULL
);
946 server
.pubsub_channels
= dictCreate(&keylistDictType
,NULL
);
947 server
.pubsub_patterns
= listCreate();
948 listSetFreeMethod(server
.pubsub_patterns
,freePubsubPattern
);
949 listSetMatchMethod(server
.pubsub_patterns
,listMatchPubsubPattern
);
950 server
.cronloops
= 0;
951 server
.bgsavechildpid
= -1;
952 server
.bgrewritechildpid
= -1;
953 server
.bgsavethread_state
= REDIS_BGSAVE_THREAD_UNACTIVE
;
954 server
.bgsavethread
= (pthread_t
) -1;
955 server
.bgrewritebuf
= sdsempty();
956 server
.aofbuf
= sdsempty();
957 server
.lastsave
= time(NULL
);
959 server
.stat_numcommands
= 0;
960 server
.stat_numconnections
= 0;
961 server
.stat_expiredkeys
= 0;
962 server
.stat_evictedkeys
= 0;
963 server
.stat_starttime
= time(NULL
);
964 server
.stat_keyspace_misses
= 0;
965 server
.stat_keyspace_hits
= 0;
966 server
.stat_peak_memory
= 0;
967 server
.unixtime
= time(NULL
);
968 aeCreateTimeEvent(server
.el
, 1, serverCron
, NULL
, NULL
);
969 if (server
.ipfd
> 0 && aeCreateFileEvent(server
.el
,server
.ipfd
,AE_READABLE
,
970 acceptTcpHandler
,NULL
) == AE_ERR
) oom("creating file event");
971 if (server
.sofd
> 0 && aeCreateFileEvent(server
.el
,server
.sofd
,AE_READABLE
,
972 acceptUnixHandler
,NULL
) == AE_ERR
) oom("creating file event");
974 if (server
.appendonly
) {
975 server
.appendfd
= open(server
.appendfilename
,O_WRONLY
|O_APPEND
|O_CREAT
,0644);
976 if (server
.appendfd
== -1) {
977 redisLog(REDIS_WARNING
, "Can't open the append-only file: %s",
983 if (server
.ds_enabled
) dsInit();
984 if (server
.cluster_enabled
) clusterInit();
985 srand(time(NULL
)^getpid());
988 /* Populates the Redis Command Table starting from the hard coded list
989 * we have on top of redis.c file. */
990 void populateCommandTable(void) {
992 int numcommands
= sizeof(redisCommandTable
)/sizeof(struct redisCommand
);
994 for (j
= 0; j
< numcommands
; j
++) {
995 struct redisCommand
*c
= redisCommandTable
+j
;
998 retval
= dictAdd(server
.commands
, sdsnew(c
->name
), c
);
999 assert(retval
== DICT_OK
);
1003 void resetCommandTableStats(void) {
1004 int numcommands
= sizeof(redisCommandTable
)/sizeof(struct redisCommand
);
1007 for (j
= 0; j
< numcommands
; j
++) {
1008 struct redisCommand
*c
= redisCommandTable
+j
;
1010 c
->microseconds
= 0;
1015 /* ====================== Commands lookup and execution ===================== */
1017 struct redisCommand
*lookupCommand(sds name
) {
1018 return dictFetchValue(server
.commands
, name
);
1021 struct redisCommand
*lookupCommandByCString(char *s
) {
1022 struct redisCommand
*cmd
;
1023 sds name
= sdsnew(s
);
1025 cmd
= dictFetchValue(server
.commands
, name
);
1030 /* Call() is the core of Redis execution of a command */
1031 void call(redisClient
*c
, struct redisCommand
*cmd
) {
1032 long long dirty
, start
= ustime();
1034 dirty
= server
.dirty
;
1036 dirty
= server
.dirty
-dirty
;
1037 cmd
->microseconds
+= ustime()-start
;
1040 if (server
.appendonly
&& dirty
)
1041 feedAppendOnlyFile(cmd
,c
->db
->id
,c
->argv
,c
->argc
);
1042 if ((dirty
|| cmd
->flags
& REDIS_CMD_FORCE_REPLICATION
) &&
1043 listLength(server
.slaves
))
1044 replicationFeedSlaves(server
.slaves
,c
->db
->id
,c
->argv
,c
->argc
);
1045 if (listLength(server
.monitors
))
1046 replicationFeedMonitors(server
.monitors
,c
->db
->id
,c
->argv
,c
->argc
);
1047 server
.stat_numcommands
++;
1050 /* If this function gets called we already read a whole
1051 * command, argments are in the client argv/argc fields.
1052 * processCommand() execute the command or prepare the
1053 * server for a bulk read from the client.
1055 * If 1 is returned the client is still alive and valid and
1056 * and other operations can be performed by the caller. Otherwise
1057 * if 0 is returned the client was destroied (i.e. after QUIT). */
1058 int processCommand(redisClient
*c
) {
1059 struct redisCommand
*cmd
;
1061 /* The QUIT command is handled separately. Normal command procs will
1062 * go through checking for replication and QUIT will cause trouble
1063 * when FORCE_REPLICATION is enabled and would be implemented in
1064 * a regular command proc. */
1065 if (!strcasecmp(c
->argv
[0]->ptr
,"quit")) {
1066 addReply(c
,shared
.ok
);
1067 c
->flags
|= REDIS_CLOSE_AFTER_REPLY
;
1071 /* Now lookup the command and check ASAP about trivial error conditions
1072 * such wrong arity, bad command name and so forth. */
1073 cmd
= lookupCommand(c
->argv
[0]->ptr
);
1075 addReplyErrorFormat(c
,"unknown command '%s'",
1076 (char*)c
->argv
[0]->ptr
);
1078 } else if ((cmd
->arity
> 0 && cmd
->arity
!= c
->argc
) ||
1079 (c
->argc
< -cmd
->arity
)) {
1080 addReplyErrorFormat(c
,"wrong number of arguments for '%s' command",
1085 /* Check if the user is authenticated */
1086 if (server
.requirepass
&& !c
->authenticated
&& cmd
->proc
!= authCommand
) {
1087 addReplyError(c
,"operation not permitted");
1091 /* If cluster is enabled, redirect here */
1092 if (server
.cluster_enabled
&&
1093 !(cmd
->getkeys_proc
== NULL
&& cmd
->firstkey
== 0)) {
1096 if (server
.cluster
.state
!= REDIS_CLUSTER_OK
) {
1097 addReplyError(c
,"The cluster is down. Check with CLUSTER INFO for more information");
1101 clusterNode
*n
= getNodeByQuery(c
,cmd
,c
->argv
,c
->argc
,&hashslot
,&ask
);
1103 addReplyError(c
,"Multi keys request invalid in cluster");
1105 } else if (n
!= server
.cluster
.myself
) {
1106 addReplySds(c
,sdscatprintf(sdsempty(),
1107 "-%s %d %s:%d\r\n", ask
? "ASK" : "MOVED",
1108 hashslot
,n
->ip
,n
->port
));
1114 /* Handle the maxmemory directive.
1116 * First we try to free some memory if possible (if there are volatile
1117 * keys in the dataset). If there are not the only thing we can do
1118 * is returning an error. */
1119 if (server
.maxmemory
) freeMemoryIfNeeded();
1120 if (server
.maxmemory
&& (cmd
->flags
& REDIS_CMD_DENYOOM
) &&
1121 zmalloc_used_memory() > server
.maxmemory
)
1123 addReplyError(c
,"command not allowed when used memory > 'maxmemory'");
1127 /* Only allow SUBSCRIBE and UNSUBSCRIBE in the context of Pub/Sub */
1128 if ((dictSize(c
->pubsub_channels
) > 0 || listLength(c
->pubsub_patterns
) > 0)
1130 cmd
->proc
!= subscribeCommand
&& cmd
->proc
!= unsubscribeCommand
&&
1131 cmd
->proc
!= psubscribeCommand
&& cmd
->proc
!= punsubscribeCommand
) {
1132 addReplyError(c
,"only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context");
1136 /* Only allow INFO and SLAVEOF when slave-serve-stale-data is no and
1137 * we are a slave with a broken link with master. */
1138 if (server
.masterhost
&& server
.replstate
!= REDIS_REPL_CONNECTED
&&
1139 server
.repl_serve_stale_data
== 0 &&
1140 cmd
->proc
!= infoCommand
&& cmd
->proc
!= slaveofCommand
)
1143 "link with MASTER is down and slave-serve-stale-data is set to no");
1147 /* Loading DB? Return an error if the command is not INFO */
1148 if (server
.loading
&& cmd
->proc
!= infoCommand
) {
1149 addReply(c
, shared
.loadingerr
);
1153 /* Exec the command */
1154 if (c
->flags
& REDIS_MULTI
&&
1155 cmd
->proc
!= execCommand
&& cmd
->proc
!= discardCommand
&&
1156 cmd
->proc
!= multiCommand
&& cmd
->proc
!= watchCommand
)
1158 queueMultiCommand(c
,cmd
);
1159 addReply(c
,shared
.queued
);
1161 if (server
.ds_enabled
&& blockClientOnSwappedKeys(c
,cmd
))
1168 /*================================== Shutdown =============================== */
1170 int prepareForShutdown() {
1171 redisLog(REDIS_WARNING
,"User requested shutdown, saving DB...");
1172 /* Kill the saving child if there is a background saving in progress.
1173 We want to avoid race conditions, for instance our saving child may
1174 overwrite the synchronous saving did by SHUTDOWN. */
1175 if (server
.bgsavechildpid
!= -1) {
1176 redisLog(REDIS_WARNING
,"There is a live saving child. Killing it!");
1177 kill(server
.bgsavechildpid
,SIGKILL
);
1178 rdbRemoveTempFile(server
.bgsavechildpid
);
1180 if (server
.ds_enabled
) {
1181 /* FIXME: flush all objects on disk */
1182 } else if (server
.appendonly
) {
1183 /* Append only file: fsync() the AOF and exit */
1184 aof_fsync(server
.appendfd
);
1185 } else if (server
.saveparamslen
> 0) {
1186 /* Snapshotting. Perform a SYNC SAVE and exit */
1187 if (rdbSave(server
.dbfilename
) != REDIS_OK
) {
1188 /* Ooops.. error saving! The best we can do is to continue
1189 * operating. Note that if there was a background saving process,
1190 * in the next cron() Redis will be notified that the background
1191 * saving aborted, handling special stuff like slaves pending for
1192 * synchronization... */
1193 redisLog(REDIS_WARNING
,"Error trying to save the DB, can't exit");
1197 redisLog(REDIS_WARNING
,"Not saving DB.");
1199 if (server
.daemonize
) unlink(server
.pidfile
);
1200 redisLog(REDIS_WARNING
,"Server exit now, bye bye...");
1204 /*================================== Commands =============================== */
1206 void authCommand(redisClient
*c
) {
1207 if (!server
.requirepass
|| !strcmp(c
->argv
[1]->ptr
, server
.requirepass
)) {
1208 c
->authenticated
= 1;
1209 addReply(c
,shared
.ok
);
1211 c
->authenticated
= 0;
1212 addReplyError(c
,"invalid password");
1216 void pingCommand(redisClient
*c
) {
1217 addReply(c
,shared
.pong
);
1220 void echoCommand(redisClient
*c
) {
1221 addReplyBulk(c
,c
->argv
[1]);
1224 /* Convert an amount of bytes into a human readable string in the form
1225 * of 100B, 2G, 100M, 4K, and so forth. */
1226 void bytesToHuman(char *s
, unsigned long long n
) {
1231 sprintf(s
,"%lluB",n
);
1233 } else if (n
< (1024*1024)) {
1234 d
= (double)n
/(1024);
1235 sprintf(s
,"%.2fK",d
);
1236 } else if (n
< (1024LL*1024*1024)) {
1237 d
= (double)n
/(1024*1024);
1238 sprintf(s
,"%.2fM",d
);
1239 } else if (n
< (1024LL*1024*1024*1024)) {
1240 d
= (double)n
/(1024LL*1024*1024);
1241 sprintf(s
,"%.2fG",d
);
1245 /* Create the string returned by the INFO command. This is decoupled
1246 * by the INFO command itself as we need to report the same information
1247 * on memory corruption problems. */
1248 sds
genRedisInfoString(char *section
) {
1249 sds info
= sdsempty();
1250 time_t uptime
= time(NULL
)-server
.stat_starttime
;
1252 struct rusage self_ru
, c_ru
;
1253 unsigned long lol
, bib
;
1254 int allsections
= 0, defsections
= 0;
1258 allsections
= strcasecmp(section
,"all") == 0;
1259 defsections
= strcasecmp(section
,"default") == 0;
1262 getrusage(RUSAGE_SELF
, &self_ru
);
1263 getrusage(RUSAGE_CHILDREN
, &c_ru
);
1264 getClientsMaxBuffers(&lol
,&bib
);
1267 if (allsections
|| defsections
|| !strcasecmp(section
,"server")) {
1268 if (sections
++) info
= sdscat(info
,"\r\n");
1269 info
= sdscatprintf(info
,
1271 "redis_version:%s\r\n"
1272 "redis_git_sha1:%s\r\n"
1273 "redis_git_dirty:%d\r\n"
1275 "multiplexing_api:%s\r\n"
1276 "process_id:%ld\r\n"
1278 "uptime_in_seconds:%ld\r\n"
1279 "uptime_in_days:%ld\r\n"
1280 "lru_clock:%ld\r\n",
1283 strtol(redisGitDirty(),NULL
,10) > 0,
1284 (sizeof(long) == 8) ? "64" : "32",
1290 (unsigned long) server
.lruclock
);
1294 if (allsections
|| defsections
|| !strcasecmp(section
,"clients")) {
1295 if (sections
++) info
= sdscat(info
,"\r\n");
1296 info
= sdscatprintf(info
,
1298 "connected_clients:%d\r\n"
1299 "client_longest_output_list:%lu\r\n"
1300 "client_biggest_input_buf:%lu\r\n"
1301 "blocked_clients:%d\r\n",
1302 listLength(server
.clients
)-listLength(server
.slaves
),
1304 server
.bpop_blocked_clients
);
1308 if (allsections
|| defsections
|| !strcasecmp(section
,"memory")) {
1312 bytesToHuman(hmem
,zmalloc_used_memory());
1313 bytesToHuman(peak_hmem
,server
.stat_peak_memory
);
1314 if (sections
++) info
= sdscat(info
,"\r\n");
1315 info
= sdscatprintf(info
,
1317 "used_memory:%zu\r\n"
1318 "used_memory_human:%s\r\n"
1319 "used_memory_rss:%zu\r\n"
1320 "used_memory_peak:%zu\r\n"
1321 "used_memory_peak_human:%s\r\n"
1322 "mem_fragmentation_ratio:%.2f\r\n"
1323 "mem_allocator:%s\r\n",
1324 zmalloc_used_memory(),
1327 server
.stat_peak_memory
,
1329 zmalloc_get_fragmentation_ratio(),
1334 /* Allocation statistics */
1335 if (allsections
|| !strcasecmp(section
,"allocstats")) {
1336 if (sections
++) info
= sdscat(info
,"\r\n");
1337 info
= sdscat(info
, "# Allocstats\r\nallocation_stats:");
1338 for (j
= 0; j
<= ZMALLOC_MAX_ALLOC_STAT
; j
++) {
1339 size_t count
= zmalloc_allocations_for_size(j
);
1341 if (info
[sdslen(info
)-1] != ':') info
= sdscatlen(info
,",",1);
1342 info
= sdscatprintf(info
,"%s%d=%zu",
1343 (j
== ZMALLOC_MAX_ALLOC_STAT
) ? ">=" : "",
1347 info
= sdscat(info
,"\r\n");
1351 if (allsections
|| defsections
|| !strcasecmp(section
,"persistence")) {
1352 if (sections
++) info
= sdscat(info
,"\r\n");
1353 info
= sdscatprintf(info
,
1356 "aof_enabled:%d\r\n"
1357 "changes_since_last_save:%lld\r\n"
1358 "bgsave_in_progress:%d\r\n"
1359 "last_save_time:%ld\r\n"
1360 "bgrewriteaof_in_progress:%d\r\n",
1364 server
.bgsavechildpid
!= -1 ||
1365 server
.bgsavethread
!= (pthread_t
) -1,
1367 server
.bgrewritechildpid
!= -1);
1369 if (server
.loading
) {
1371 time_t eta
, elapsed
;
1372 off_t remaining_bytes
= server
.loading_total_bytes
-
1373 server
.loading_loaded_bytes
;
1375 perc
= ((double)server
.loading_loaded_bytes
/
1376 server
.loading_total_bytes
) * 100;
1378 elapsed
= time(NULL
)-server
.loading_start_time
;
1380 eta
= 1; /* A fake 1 second figure if we don't have
1383 eta
= (elapsed
*remaining_bytes
)/server
.loading_loaded_bytes
;
1386 info
= sdscatprintf(info
,
1387 "loading_start_time:%ld\r\n"
1388 "loading_total_bytes:%llu\r\n"
1389 "loading_loaded_bytes:%llu\r\n"
1390 "loading_loaded_perc:%.2f\r\n"
1391 "loading_eta_seconds:%ld\r\n"
1392 ,(unsigned long) server
.loading_start_time
,
1393 (unsigned long long) server
.loading_total_bytes
,
1394 (unsigned long long) server
.loading_loaded_bytes
,
1402 if (allsections
|| defsections
|| !strcasecmp(section
,"diskstore")) {
1403 if (sections
++) info
= sdscat(info
,"\r\n");
1404 info
= sdscatprintf(info
,
1406 "ds_enabled:%d\r\n",
1407 server
.ds_enabled
!= 0);
1408 if (server
.ds_enabled
) {
1410 info
= sdscatprintf(info
,
1411 "cache_max_memory:%llu\r\n"
1412 "cache_blocked_clients:%lu\r\n"
1413 "cache_io_queue_len:%lu\r\n"
1414 "cache_io_jobs_new:%lu\r\n"
1415 "cache_io_jobs_processing:%lu\r\n"
1416 "cache_io_jobs_processed:%lu\r\n"
1417 "cache_io_ready_clients:%lu\r\n"
1418 ,(unsigned long long) server
.cache_max_memory
,
1419 (unsigned long) server
.cache_blocked_clients
,
1420 (unsigned long) listLength(server
.cache_io_queue
),
1421 (unsigned long) listLength(server
.io_newjobs
),
1422 (unsigned long) listLength(server
.io_processing
),
1423 (unsigned long) listLength(server
.io_processed
),
1424 (unsigned long) listLength(server
.io_ready_clients
)
1431 if (allsections
|| defsections
|| !strcasecmp(section
,"stats")) {
1432 if (sections
++) info
= sdscat(info
,"\r\n");
1433 info
= sdscatprintf(info
,
1435 "total_connections_received:%lld\r\n"
1436 "total_commands_processed:%lld\r\n"
1437 "expired_keys:%lld\r\n"
1438 "evicted_keys:%lld\r\n"
1439 "keyspace_hits:%lld\r\n"
1440 "keyspace_misses:%lld\r\n"
1441 "pubsub_channels:%ld\r\n"
1442 "pubsub_patterns:%u\r\n",
1443 server
.stat_numconnections
,
1444 server
.stat_numcommands
,
1445 server
.stat_expiredkeys
,
1446 server
.stat_evictedkeys
,
1447 server
.stat_keyspace_hits
,
1448 server
.stat_keyspace_misses
,
1449 dictSize(server
.pubsub_channels
),
1450 listLength(server
.pubsub_patterns
));
1454 if (allsections
|| defsections
|| !strcasecmp(section
,"replication")) {
1455 if (sections
++) info
= sdscat(info
,"\r\n");
1456 info
= sdscatprintf(info
,
1459 server
.masterhost
== NULL
? "master" : "slave");
1460 if (server
.masterhost
) {
1461 info
= sdscatprintf(info
,
1462 "master_host:%s\r\n"
1463 "master_port:%d\r\n"
1464 "master_link_status:%s\r\n"
1465 "master_last_io_seconds_ago:%d\r\n"
1466 "master_sync_in_progress:%d\r\n"
1469 (server
.replstate
== REDIS_REPL_CONNECTED
) ?
1472 ((int)(time(NULL
)-server
.master
->lastinteraction
)) : -1,
1473 server
.replstate
== REDIS_REPL_TRANSFER
1476 if (server
.replstate
== REDIS_REPL_TRANSFER
) {
1477 info
= sdscatprintf(info
,
1478 "master_sync_left_bytes:%ld\r\n"
1479 "master_sync_last_io_seconds_ago:%d\r\n"
1480 ,(long)server
.repl_transfer_left
,
1481 (int)(time(NULL
)-server
.repl_transfer_lastio
)
1485 info
= sdscatprintf(info
,
1486 "connected_slaves:%d\r\n",
1487 listLength(server
.slaves
));
1491 if (allsections
|| defsections
|| !strcasecmp(section
,"cpu")) {
1492 if (sections
++) info
= sdscat(info
,"\r\n");
1493 info
= sdscatprintf(info
,
1495 "used_cpu_sys:%.2f\r\n"
1496 "used_cpu_user:%.2f\r\n"
1497 "used_cpu_sys_childrens:%.2f\r\n"
1498 "used_cpu_user_childrens:%.2f\r\n",
1499 (float)self_ru
.ru_utime
.tv_sec
+(float)self_ru
.ru_utime
.tv_usec
/1000000,
1500 (float)self_ru
.ru_stime
.tv_sec
+(float)self_ru
.ru_stime
.tv_usec
/1000000,
1501 (float)c_ru
.ru_utime
.tv_sec
+(float)c_ru
.ru_utime
.tv_usec
/1000000,
1502 (float)c_ru
.ru_stime
.tv_sec
+(float)c_ru
.ru_stime
.tv_usec
/1000000);
1506 if (allsections
|| !strcasecmp(section
,"commandstats")) {
1507 if (sections
++) info
= sdscat(info
,"\r\n");
1508 info
= sdscatprintf(info
, "# Commandstats\r\n");
1509 numcommands
= sizeof(redisCommandTable
)/sizeof(struct redisCommand
);
1510 for (j
= 0; j
< numcommands
; j
++) {
1511 struct redisCommand
*c
= redisCommandTable
+j
;
1513 if (!c
->calls
) continue;
1514 info
= sdscatprintf(info
,
1515 "cmdstat_%s:calls=%lld,usec=%lld,usec_per_call=%.2f\r\n",
1516 c
->name
, c
->calls
, c
->microseconds
,
1517 (c
->calls
== 0) ? 0 : ((float)c
->microseconds
/c
->calls
));
1522 if (allsections
|| defsections
|| !strcasecmp(section
,"cluster")) {
1523 if (sections
++) info
= sdscat(info
,"\r\n");
1524 info
= sdscatprintf(info
,
1526 "cluster_enabled:%d\r\n",
1527 server
.cluster_enabled
);
1531 if (allsections
|| defsections
|| !strcasecmp(section
,"keyspace")) {
1532 if (sections
++) info
= sdscat(info
,"\r\n");
1533 info
= sdscatprintf(info
, "# Keyspace\r\n");
1534 for (j
= 0; j
< server
.dbnum
; j
++) {
1535 long long keys
, vkeys
;
1537 keys
= dictSize(server
.db
[j
].dict
);
1538 vkeys
= dictSize(server
.db
[j
].expires
);
1539 if (keys
|| vkeys
) {
1540 info
= sdscatprintf(info
, "db%d:keys=%lld,expires=%lld\r\n",
1548 void infoCommand(redisClient
*c
) {
1549 char *section
= c
->argc
== 2 ? c
->argv
[1]->ptr
: "default";
1552 addReply(c
,shared
.syntaxerr
);
1555 sds info
= genRedisInfoString(section
);
1556 addReplySds(c
,sdscatprintf(sdsempty(),"$%lu\r\n",
1557 (unsigned long)sdslen(info
)));
1558 addReplySds(c
,info
);
1559 addReply(c
,shared
.crlf
);
1562 void monitorCommand(redisClient
*c
) {
1563 /* ignore MONITOR if aleady slave or in monitor mode */
1564 if (c
->flags
& REDIS_SLAVE
) return;
1566 c
->flags
|= (REDIS_SLAVE
|REDIS_MONITOR
);
1568 listAddNodeTail(server
.monitors
,c
);
1569 addReply(c
,shared
.ok
);
1572 /* ============================ Maxmemory directive ======================== */
1574 /* This function gets called when 'maxmemory' is set on the config file to limit
1575 * the max memory used by the server, and we are out of memory.
1576 * This function will try to, in order:
1578 * - Free objects from the free list
1579 * - Try to remove keys with an EXPIRE set
1581 * It is not possible to free enough memory to reach used-memory < maxmemory
1582 * the server will start refusing commands that will enlarge even more the
1585 void freeMemoryIfNeeded(void) {
1586 /* Remove keys accordingly to the active policy as long as we are
1587 * over the memory limit. */
1588 if (server
.maxmemory_policy
== REDIS_MAXMEMORY_NO_EVICTION
) return;
1590 while (server
.maxmemory
&& zmalloc_used_memory() > server
.maxmemory
) {
1591 int j
, k
, freed
= 0;
1593 for (j
= 0; j
< server
.dbnum
; j
++) {
1594 long bestval
= 0; /* just to prevent warning */
1596 struct dictEntry
*de
;
1597 redisDb
*db
= server
.db
+j
;
1600 if (server
.maxmemory_policy
== REDIS_MAXMEMORY_ALLKEYS_LRU
||
1601 server
.maxmemory_policy
== REDIS_MAXMEMORY_ALLKEYS_RANDOM
)
1603 dict
= server
.db
[j
].dict
;
1605 dict
= server
.db
[j
].expires
;
1607 if (dictSize(dict
) == 0) continue;
1609 /* volatile-random and allkeys-random policy */
1610 if (server
.maxmemory_policy
== REDIS_MAXMEMORY_ALLKEYS_RANDOM
||
1611 server
.maxmemory_policy
== REDIS_MAXMEMORY_VOLATILE_RANDOM
)
1613 de
= dictGetRandomKey(dict
);
1614 bestkey
= dictGetEntryKey(de
);
1617 /* volatile-lru and allkeys-lru policy */
1618 else if (server
.maxmemory_policy
== REDIS_MAXMEMORY_ALLKEYS_LRU
||
1619 server
.maxmemory_policy
== REDIS_MAXMEMORY_VOLATILE_LRU
)
1621 for (k
= 0; k
< server
.maxmemory_samples
; k
++) {
1626 de
= dictGetRandomKey(dict
);
1627 thiskey
= dictGetEntryKey(de
);
1628 /* When policy is volatile-lru we need an additonal lookup
1629 * to locate the real key, as dict is set to db->expires. */
1630 if (server
.maxmemory_policy
== REDIS_MAXMEMORY_VOLATILE_LRU
)
1631 de
= dictFind(db
->dict
, thiskey
);
1632 o
= dictGetEntryVal(de
);
1633 thisval
= estimateObjectIdleTime(o
);
1635 /* Higher idle time is better candidate for deletion */
1636 if (bestkey
== NULL
|| thisval
> bestval
) {
1644 else if (server
.maxmemory_policy
== REDIS_MAXMEMORY_VOLATILE_TTL
) {
1645 for (k
= 0; k
< server
.maxmemory_samples
; k
++) {
1649 de
= dictGetRandomKey(dict
);
1650 thiskey
= dictGetEntryKey(de
);
1651 thisval
= (long) dictGetEntryVal(de
);
1653 /* Expire sooner (minor expire unix timestamp) is better
1654 * candidate for deletion */
1655 if (bestkey
== NULL
|| thisval
< bestval
) {
1662 /* Finally remove the selected key. */
1664 robj
*keyobj
= createStringObject(bestkey
,sdslen(bestkey
));
1665 propagateExpire(db
,keyobj
);
1666 dbDelete(db
,keyobj
);
1667 server
.stat_evictedkeys
++;
1668 decrRefCount(keyobj
);
1672 if (!freed
) return; /* nothing to free... */
1676 /* =================================== Main! ================================ */
1679 int linuxOvercommitMemoryValue(void) {
1680 FILE *fp
= fopen("/proc/sys/vm/overcommit_memory","r");
1684 if (fgets(buf
,64,fp
) == NULL
) {
1693 void linuxOvercommitMemoryWarning(void) {
1694 if (linuxOvercommitMemoryValue() == 0) {
1695 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.");
1698 #endif /* __linux__ */
1700 void createPidFile(void) {
1701 /* Try to write the pid file in a best-effort way. */
1702 FILE *fp
= fopen(server
.pidfile
,"w");
1704 fprintf(fp
,"%d\n",(int)getpid());
1709 void daemonize(void) {
1712 if (fork() != 0) exit(0); /* parent exits */
1713 setsid(); /* create a new session */
1715 /* Every output goes to /dev/null. If Redis is daemonized but
1716 * the 'logfile' is set to 'stdout' in the configuration file
1717 * it will not log at all. */
1718 if ((fd
= open("/dev/null", O_RDWR
, 0)) != -1) {
1719 dup2(fd
, STDIN_FILENO
);
1720 dup2(fd
, STDOUT_FILENO
);
1721 dup2(fd
, STDERR_FILENO
);
1722 if (fd
> STDERR_FILENO
) close(fd
);
1727 printf("Redis server version %s (%s:%d)\n", REDIS_VERSION
,
1728 redisGitSHA1(), atoi(redisGitDirty()) > 0);
1733 fprintf(stderr
,"Usage: ./redis-server [/path/to/redis.conf]\n");
1734 fprintf(stderr
," ./redis-server - (read config from stdin)\n");
1738 void redisAsciiArt(void) {
1739 #include "asciilogo.h"
1740 char *buf
= zmalloc(1024*16);
1742 snprintf(buf
,1024*16,ascii_logo
,
1745 strtol(redisGitDirty(),NULL
,10) > 0,
1746 (sizeof(long) == 8) ? "64" : "32",
1747 server
.cluster_enabled
? "cluster" : "stand alone",
1751 redisLogRaw(REDIS_NOTICE
|REDIS_LOG_RAW
,buf
);
1755 int main(int argc
, char **argv
) {
1760 if (strcmp(argv
[1], "-v") == 0 ||
1761 strcmp(argv
[1], "--version") == 0) version();
1762 if (strcmp(argv
[1], "--help") == 0) usage();
1763 resetServerSaveParams();
1764 loadServerConfig(argv
[1]);
1765 } else if ((argc
> 2)) {
1768 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'");
1770 if (server
.daemonize
) daemonize();
1772 if (server
.daemonize
) createPidFile();
1774 redisLog(REDIS_NOTICE
,"Server started, Redis version " REDIS_VERSION
);
1776 linuxOvercommitMemoryWarning();
1779 if (server
.ds_enabled
) {
1780 redisLog(REDIS_NOTICE
,"DB not loaded (running with disk back end)");
1781 } else if (server
.appendonly
) {
1782 if (loadAppendOnlyFile(server
.appendfilename
) == REDIS_OK
)
1783 redisLog(REDIS_NOTICE
,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start
)/1000000);
1785 if (rdbLoad(server
.dbfilename
) == REDIS_OK
)
1786 redisLog(REDIS_NOTICE
,"DB loaded from disk: %.3f seconds",(float)(ustime()-start
)/1000000);
1788 if (server
.ipfd
> 0)
1789 redisLog(REDIS_NOTICE
,"The server is now ready to accept connections on port %d", server
.port
);
1790 if (server
.sofd
> 0)
1791 redisLog(REDIS_NOTICE
,"The server is now ready to accept connections at %s", server
.unixsocket
);
1792 aeSetBeforeSleepProc(server
.el
,beforeSleep
);
1794 aeDeleteEventLoop(server
.el
);
1798 #ifdef HAVE_BACKTRACE
1799 static void *getMcontextEip(ucontext_t
*uc
) {
1800 #if defined(__FreeBSD__)
1801 return (void*) uc
->uc_mcontext
.mc_eip
;
1802 #elif defined(__dietlibc__)
1803 return (void*) uc
->uc_mcontext
.eip
;
1804 #elif defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
1806 return (void*) uc
->uc_mcontext
->__ss
.__rip
;
1808 return (void*) uc
->uc_mcontext
->__ss
.__eip
;
1810 #elif defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)
1811 #if defined(_STRUCT_X86_THREAD_STATE64) && !defined(__i386__)
1812 return (void*) uc
->uc_mcontext
->__ss
.__rip
;
1814 return (void*) uc
->uc_mcontext
->__ss
.__eip
;
1816 #elif defined(__i386__)
1817 return (void*) uc
->uc_mcontext
.gregs
[14]; /* Linux 32 */
1818 #elif defined(__X86_64__) || defined(__x86_64__)
1819 return (void*) uc
->uc_mcontext
.gregs
[16]; /* Linux 64 */
1820 #elif defined(__ia64__) /* Linux IA64 */
1821 return (void*) uc
->uc_mcontext
.sc_ip
;
1827 static void sigsegvHandler(int sig
, siginfo_t
*info
, void *secret
) {
1829 char **messages
= NULL
;
1830 int i
, trace_size
= 0;
1831 ucontext_t
*uc
= (ucontext_t
*) secret
;
1833 struct sigaction act
;
1834 REDIS_NOTUSED(info
);
1836 redisLog(REDIS_WARNING
,
1837 "======= Ooops! Redis %s got signal: -%d- =======", REDIS_VERSION
, sig
);
1838 infostring
= genRedisInfoString("all");
1839 redisLogRaw(REDIS_WARNING
, infostring
);
1840 /* It's not safe to sdsfree() the returned string under memory
1841 * corruption conditions. Let it leak as we are going to abort */
1843 trace_size
= backtrace(trace
, 100);
1844 /* overwrite sigaction with caller's address */
1845 if (getMcontextEip(uc
) != NULL
) {
1846 trace
[1] = getMcontextEip(uc
);
1848 messages
= backtrace_symbols(trace
, trace_size
);
1850 for (i
=1; i
<trace_size
; ++i
)
1851 redisLog(REDIS_WARNING
,"%s", messages
[i
]);
1853 /* free(messages); Don't call free() with possibly corrupted memory. */
1854 if (server
.daemonize
) unlink(server
.pidfile
);
1856 /* Make sure we exit with the right signal at the end. So for instance
1857 * the core will be dumped if enabled. */
1858 sigemptyset (&act
.sa_mask
);
1859 /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction
1860 * is used. Otherwise, sa_handler is used */
1861 act
.sa_flags
= SA_NODEFER
| SA_ONSTACK
| SA_RESETHAND
;
1862 act
.sa_handler
= SIG_DFL
;
1863 sigaction (sig
, &act
, NULL
);
1866 #endif /* HAVE_BACKTRACE */
1868 static void sigtermHandler(int sig
) {
1871 redisLog(REDIS_WARNING
,"Received SIGTERM, scheduling shutdown...");
1872 server
.shutdown_asap
= 1;
1875 void setupSignalHandlers(void) {
1876 struct sigaction act
;
1878 /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction is used.
1879 * Otherwise, sa_handler is used. */
1880 sigemptyset(&act
.sa_mask
);
1881 act
.sa_flags
= SA_NODEFER
| SA_ONSTACK
| SA_RESETHAND
;
1882 act
.sa_handler
= sigtermHandler
;
1883 sigaction(SIGTERM
, &act
, NULL
);
1885 #ifdef HAVE_BACKTRACE
1886 sigemptyset(&act
.sa_mask
);
1887 act
.sa_flags
= SA_NODEFER
| SA_ONSTACK
| SA_RESETHAND
| SA_SIGINFO
;
1888 act
.sa_sigaction
= sigsegvHandler
;
1889 sigaction(SIGSEGV
, &act
, NULL
);
1890 sigaction(SIGBUS
, &act
, NULL
);
1891 sigaction(SIGFPE
, &act
, NULL
);
1892 sigaction(SIGILL
, &act
, NULL
);