]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com> | |
3 | * All rights reserved. | |
4 | * | |
5 | * Redistribution and use in source and binary forms, with or without | |
6 | * modification, are permitted provided that the following conditions are met: | |
7 | * | |
8 | * * Redistributions of source code must retain the above copyright notice, | |
9 | * this list of conditions and the following disclaimer. | |
10 | * * Redistributions in binary form must reproduce the above copyright | |
11 | * notice, this list of conditions and the following disclaimer in the | |
12 | * documentation and/or other materials provided with the distribution. | |
13 | * * Neither the name of Redis nor the names of its contributors may be used | |
14 | * to endorse or promote products derived from this software without | |
15 | * specific prior written permission. | |
16 | * | |
17 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
18 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
19 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
20 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | |
21 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
22 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
23 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
24 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
25 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
26 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
27 | * POSSIBILITY OF SUCH DAMAGE. | |
28 | */ | |
29 | ||
30 | #include "redis.h" | |
31 | ||
32 | #ifdef HAVE_BACKTRACE | |
33 | #include <execinfo.h> | |
34 | #include <ucontext.h> | |
35 | #endif /* HAVE_BACKTRACE */ | |
36 | ||
37 | #include <time.h> | |
38 | #include <signal.h> | |
39 | #include <sys/wait.h> | |
40 | #include <errno.h> | |
41 | #include <assert.h> | |
42 | #include <ctype.h> | |
43 | #include <stdarg.h> | |
44 | #include <arpa/inet.h> | |
45 | #include <sys/stat.h> | |
46 | #include <fcntl.h> | |
47 | #include <sys/time.h> | |
48 | #include <sys/resource.h> | |
49 | #include <sys/uio.h> | |
50 | #include <limits.h> | |
51 | #include <float.h> | |
52 | #include <math.h> | |
53 | #include <pthread.h> | |
54 | #include <sys/resource.h> | |
55 | ||
56 | /* Our shared "common" objects */ | |
57 | ||
58 | struct sharedObjectsStruct shared; | |
59 | ||
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. */ | |
63 | ||
64 | double R_Zero, R_PosInf, R_NegInf, R_Nan; | |
65 | ||
66 | /*================================= Globals ================================= */ | |
67 | ||
68 | /* Global vars */ | |
69 | struct redisServer server; /* server global state */ | |
70 | struct redisCommand *commandTable; | |
71 | struct redisCommand readonlyCommandTable[] = { | |
72 | {"get",getCommand,2,0,NULL,1,1,1}, | |
73 | {"set",setCommand,3,REDIS_CMD_DENYOOM,NULL,0,0,0}, | |
74 | {"setnx",setnxCommand,3,REDIS_CMD_DENYOOM,NULL,0,0,0}, | |
75 | {"setex",setexCommand,4,REDIS_CMD_DENYOOM,NULL,0,0,0}, | |
76 | {"append",appendCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
77 | {"substr",substrCommand,4,0,NULL,1,1,1}, | |
78 | {"strlen",strlenCommand,2,0,NULL,1,1,1}, | |
79 | {"del",delCommand,-2,0,NULL,0,0,0}, | |
80 | {"exists",existsCommand,2,0,NULL,1,1,1}, | |
81 | {"incr",incrCommand,2,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
82 | {"decr",decrCommand,2,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
83 | {"mget",mgetCommand,-2,0,NULL,1,-1,1}, | |
84 | {"rpush",rpushCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
85 | {"lpush",lpushCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
86 | {"rpushx",rpushxCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
87 | {"lpushx",lpushxCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
88 | {"linsert",linsertCommand,5,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
89 | {"rpop",rpopCommand,2,0,NULL,1,1,1}, | |
90 | {"lpop",lpopCommand,2,0,NULL,1,1,1}, | |
91 | {"brpop",brpopCommand,-3,0,NULL,1,1,1}, | |
92 | {"blpop",blpopCommand,-3,0,NULL,1,1,1}, | |
93 | {"llen",llenCommand,2,0,NULL,1,1,1}, | |
94 | {"lindex",lindexCommand,3,0,NULL,1,1,1}, | |
95 | {"lset",lsetCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
96 | {"lrange",lrangeCommand,4,0,NULL,1,1,1}, | |
97 | {"ltrim",ltrimCommand,4,0,NULL,1,1,1}, | |
98 | {"lrem",lremCommand,4,0,NULL,1,1,1}, | |
99 | {"rpoplpush",rpoplpushcommand,3,REDIS_CMD_DENYOOM,NULL,1,2,1}, | |
100 | {"sadd",saddCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
101 | {"srem",sremCommand,3,0,NULL,1,1,1}, | |
102 | {"smove",smoveCommand,4,0,NULL,1,2,1}, | |
103 | {"sismember",sismemberCommand,3,0,NULL,1,1,1}, | |
104 | {"scard",scardCommand,2,0,NULL,1,1,1}, | |
105 | {"spop",spopCommand,2,0,NULL,1,1,1}, | |
106 | {"srandmember",srandmemberCommand,2,0,NULL,1,1,1}, | |
107 | {"sinter",sinterCommand,-2,REDIS_CMD_DENYOOM,NULL,1,-1,1}, | |
108 | {"sinterstore",sinterstoreCommand,-3,REDIS_CMD_DENYOOM,NULL,2,-1,1}, | |
109 | {"sunion",sunionCommand,-2,REDIS_CMD_DENYOOM,NULL,1,-1,1}, | |
110 | {"sunionstore",sunionstoreCommand,-3,REDIS_CMD_DENYOOM,NULL,2,-1,1}, | |
111 | {"sdiff",sdiffCommand,-2,REDIS_CMD_DENYOOM,NULL,1,-1,1}, | |
112 | {"sdiffstore",sdiffstoreCommand,-3,REDIS_CMD_DENYOOM,NULL,2,-1,1}, | |
113 | {"smembers",sinterCommand,2,0,NULL,1,1,1}, | |
114 | {"zadd",zaddCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
115 | {"zincrby",zincrbyCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
116 | {"zrem",zremCommand,3,0,NULL,1,1,1}, | |
117 | {"zremrangebyscore",zremrangebyscoreCommand,4,0,NULL,1,1,1}, | |
118 | {"zremrangebyrank",zremrangebyrankCommand,4,0,NULL,1,1,1}, | |
119 | {"zunionstore",zunionstoreCommand,-4,REDIS_CMD_DENYOOM,zunionInterBlockClientOnSwappedKeys,0,0,0}, | |
120 | {"zinterstore",zinterstoreCommand,-4,REDIS_CMD_DENYOOM,zunionInterBlockClientOnSwappedKeys,0,0,0}, | |
121 | {"zrange",zrangeCommand,-4,0,NULL,1,1,1}, | |
122 | {"zrangebyscore",zrangebyscoreCommand,-4,0,NULL,1,1,1}, | |
123 | {"zrevrangebyscore",zrevrangebyscoreCommand,-4,0,NULL,1,1,1}, | |
124 | {"zcount",zcountCommand,4,0,NULL,1,1,1}, | |
125 | {"zrevrange",zrevrangeCommand,-4,0,NULL,1,1,1}, | |
126 | {"zcard",zcardCommand,2,0,NULL,1,1,1}, | |
127 | {"zscore",zscoreCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
128 | {"zrank",zrankCommand,3,0,NULL,1,1,1}, | |
129 | {"zrevrank",zrevrankCommand,3,0,NULL,1,1,1}, | |
130 | {"hset",hsetCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
131 | {"hsetnx",hsetnxCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
132 | {"hget",hgetCommand,3,0,NULL,1,1,1}, | |
133 | {"hmset",hmsetCommand,-4,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
134 | {"hmget",hmgetCommand,-3,0,NULL,1,1,1}, | |
135 | {"hincrby",hincrbyCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
136 | {"hdel",hdelCommand,3,0,NULL,1,1,1}, | |
137 | {"hlen",hlenCommand,2,0,NULL,1,1,1}, | |
138 | {"hkeys",hkeysCommand,2,0,NULL,1,1,1}, | |
139 | {"hvals",hvalsCommand,2,0,NULL,1,1,1}, | |
140 | {"hgetall",hgetallCommand,2,0,NULL,1,1,1}, | |
141 | {"hexists",hexistsCommand,3,0,NULL,1,1,1}, | |
142 | {"incrby",incrbyCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
143 | {"decrby",decrbyCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
144 | {"getset",getsetCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
145 | {"mset",msetCommand,-3,REDIS_CMD_DENYOOM,NULL,1,-1,2}, | |
146 | {"msetnx",msetnxCommand,-3,REDIS_CMD_DENYOOM,NULL,1,-1,2}, | |
147 | {"randomkey",randomkeyCommand,1,0,NULL,0,0,0}, | |
148 | {"select",selectCommand,2,0,NULL,0,0,0}, | |
149 | {"move",moveCommand,3,0,NULL,1,1,1}, | |
150 | {"rename",renameCommand,3,0,NULL,1,1,1}, | |
151 | {"renamenx",renamenxCommand,3,0,NULL,1,1,1}, | |
152 | {"expire",expireCommand,3,0,NULL,0,0,0}, | |
153 | {"expireat",expireatCommand,3,0,NULL,0,0,0}, | |
154 | {"keys",keysCommand,2,0,NULL,0,0,0}, | |
155 | {"dbsize",dbsizeCommand,1,0,NULL,0,0,0}, | |
156 | {"auth",authCommand,2,0,NULL,0,0,0}, | |
157 | {"ping",pingCommand,1,0,NULL,0,0,0}, | |
158 | {"echo",echoCommand,2,0,NULL,0,0,0}, | |
159 | {"save",saveCommand,1,0,NULL,0,0,0}, | |
160 | {"bgsave",bgsaveCommand,1,0,NULL,0,0,0}, | |
161 | {"bgrewriteaof",bgrewriteaofCommand,1,0,NULL,0,0,0}, | |
162 | {"shutdown",shutdownCommand,1,0,NULL,0,0,0}, | |
163 | {"lastsave",lastsaveCommand,1,0,NULL,0,0,0}, | |
164 | {"type",typeCommand,2,0,NULL,1,1,1}, | |
165 | {"multi",multiCommand,1,0,NULL,0,0,0}, | |
166 | {"exec",execCommand,1,REDIS_CMD_DENYOOM,execBlockClientOnSwappedKeys,0,0,0}, | |
167 | {"discard",discardCommand,1,0,NULL,0,0,0}, | |
168 | {"sync",syncCommand,1,0,NULL,0,0,0}, | |
169 | {"flushdb",flushdbCommand,1,0,NULL,0,0,0}, | |
170 | {"flushall",flushallCommand,1,0,NULL,0,0,0}, | |
171 | {"sort",sortCommand,-2,REDIS_CMD_DENYOOM,NULL,1,1,1}, | |
172 | {"info",infoCommand,1,0,NULL,0,0,0}, | |
173 | {"monitor",monitorCommand,1,0,NULL,0,0,0}, | |
174 | {"ttl",ttlCommand,2,0,NULL,1,1,1}, | |
175 | {"persist",persistCommand,2,0,NULL,1,1,1}, | |
176 | {"slaveof",slaveofCommand,3,0,NULL,0,0,0}, | |
177 | {"debug",debugCommand,-2,0,NULL,0,0,0}, | |
178 | {"config",configCommand,-2,0,NULL,0,0,0}, | |
179 | {"subscribe",subscribeCommand,-2,0,NULL,0,0,0}, | |
180 | {"unsubscribe",unsubscribeCommand,-1,0,NULL,0,0,0}, | |
181 | {"psubscribe",psubscribeCommand,-2,0,NULL,0,0,0}, | |
182 | {"punsubscribe",punsubscribeCommand,-1,0,NULL,0,0,0}, | |
183 | {"publish",publishCommand,3,REDIS_CMD_FORCE_REPLICATION,NULL,0,0,0}, | |
184 | {"watch",watchCommand,-2,0,NULL,0,0,0}, | |
185 | {"unwatch",unwatchCommand,1,0,NULL,0,0,0} | |
186 | }; | |
187 | ||
188 | /*============================ Utility functions ============================ */ | |
189 | ||
190 | void redisLog(int level, const char *fmt, ...) { | |
191 | va_list ap; | |
192 | FILE *fp; | |
193 | char *c = ".-*#"; | |
194 | char buf[64]; | |
195 | time_t now; | |
196 | ||
197 | if (level < server.verbosity) return; | |
198 | ||
199 | fp = (server.logfile == NULL) ? stdout : fopen(server.logfile,"a"); | |
200 | if (!fp) return; | |
201 | ||
202 | va_start(ap, fmt); | |
203 | now = time(NULL); | |
204 | strftime(buf,64,"%d %b %H:%M:%S",localtime(&now)); | |
205 | fprintf(fp,"[%d] %s %c ",(int)getpid(),buf,c[level]); | |
206 | vfprintf(fp, fmt, ap); | |
207 | fprintf(fp,"\n"); | |
208 | fflush(fp); | |
209 | va_end(ap); | |
210 | ||
211 | if (server.logfile) fclose(fp); | |
212 | } | |
213 | ||
214 | /* Redis generally does not try to recover from out of memory conditions | |
215 | * when allocating objects or strings, it is not clear if it will be possible | |
216 | * to report this condition to the client since the networking layer itself | |
217 | * is based on heap allocation for send buffers, so we simply abort. | |
218 | * At least the code will be simpler to read... */ | |
219 | void oom(const char *msg) { | |
220 | redisLog(REDIS_WARNING, "%s: Out of memory\n",msg); | |
221 | sleep(1); | |
222 | abort(); | |
223 | } | |
224 | ||
225 | /*====================== Hash table type implementation ==================== */ | |
226 | ||
227 | /* This is an hash table type that uses the SDS dynamic strings libary as | |
228 | * keys and radis objects as values (objects can hold SDS strings, | |
229 | * lists, sets). */ | |
230 | ||
231 | void dictVanillaFree(void *privdata, void *val) | |
232 | { | |
233 | DICT_NOTUSED(privdata); | |
234 | zfree(val); | |
235 | } | |
236 | ||
237 | void dictListDestructor(void *privdata, void *val) | |
238 | { | |
239 | DICT_NOTUSED(privdata); | |
240 | listRelease((list*)val); | |
241 | } | |
242 | ||
243 | int dictSdsKeyCompare(void *privdata, const void *key1, | |
244 | const void *key2) | |
245 | { | |
246 | int l1,l2; | |
247 | DICT_NOTUSED(privdata); | |
248 | ||
249 | l1 = sdslen((sds)key1); | |
250 | l2 = sdslen((sds)key2); | |
251 | if (l1 != l2) return 0; | |
252 | return memcmp(key1, key2, l1) == 0; | |
253 | } | |
254 | ||
255 | /* A case insensitive version used for the command lookup table. */ | |
256 | int dictSdsKeyCaseCompare(void *privdata, const void *key1, | |
257 | const void *key2) | |
258 | { | |
259 | DICT_NOTUSED(privdata); | |
260 | ||
261 | return strcasecmp(key1, key2) == 0; | |
262 | } | |
263 | ||
264 | void dictRedisObjectDestructor(void *privdata, void *val) | |
265 | { | |
266 | DICT_NOTUSED(privdata); | |
267 | ||
268 | if (val == NULL) return; /* Values of swapped out keys as set to NULL */ | |
269 | decrRefCount(val); | |
270 | } | |
271 | ||
272 | void dictSdsDestructor(void *privdata, void *val) | |
273 | { | |
274 | DICT_NOTUSED(privdata); | |
275 | ||
276 | sdsfree(val); | |
277 | } | |
278 | ||
279 | int dictObjKeyCompare(void *privdata, const void *key1, | |
280 | const void *key2) | |
281 | { | |
282 | const robj *o1 = key1, *o2 = key2; | |
283 | return dictSdsKeyCompare(privdata,o1->ptr,o2->ptr); | |
284 | } | |
285 | ||
286 | unsigned int dictObjHash(const void *key) { | |
287 | const robj *o = key; | |
288 | return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr)); | |
289 | } | |
290 | ||
291 | unsigned int dictSdsHash(const void *key) { | |
292 | return dictGenHashFunction((unsigned char*)key, sdslen((char*)key)); | |
293 | } | |
294 | ||
295 | unsigned int dictSdsCaseHash(const void *key) { | |
296 | return dictGenCaseHashFunction((unsigned char*)key, sdslen((char*)key)); | |
297 | } | |
298 | ||
299 | int dictEncObjKeyCompare(void *privdata, const void *key1, | |
300 | const void *key2) | |
301 | { | |
302 | robj *o1 = (robj*) key1, *o2 = (robj*) key2; | |
303 | int cmp; | |
304 | ||
305 | if (o1->encoding == REDIS_ENCODING_INT && | |
306 | o2->encoding == REDIS_ENCODING_INT) | |
307 | return o1->ptr == o2->ptr; | |
308 | ||
309 | o1 = getDecodedObject(o1); | |
310 | o2 = getDecodedObject(o2); | |
311 | cmp = dictSdsKeyCompare(privdata,o1->ptr,o2->ptr); | |
312 | decrRefCount(o1); | |
313 | decrRefCount(o2); | |
314 | return cmp; | |
315 | } | |
316 | ||
317 | unsigned int dictEncObjHash(const void *key) { | |
318 | robj *o = (robj*) key; | |
319 | ||
320 | if (o->encoding == REDIS_ENCODING_RAW) { | |
321 | return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr)); | |
322 | } else { | |
323 | if (o->encoding == REDIS_ENCODING_INT) { | |
324 | char buf[32]; | |
325 | int len; | |
326 | ||
327 | len = ll2string(buf,32,(long)o->ptr); | |
328 | return dictGenHashFunction((unsigned char*)buf, len); | |
329 | } else { | |
330 | unsigned int hash; | |
331 | ||
332 | o = getDecodedObject(o); | |
333 | hash = dictGenHashFunction(o->ptr, sdslen((sds)o->ptr)); | |
334 | decrRefCount(o); | |
335 | return hash; | |
336 | } | |
337 | } | |
338 | } | |
339 | ||
340 | /* Sets type */ | |
341 | dictType setDictType = { | |
342 | dictEncObjHash, /* hash function */ | |
343 | NULL, /* key dup */ | |
344 | NULL, /* val dup */ | |
345 | dictEncObjKeyCompare, /* key compare */ | |
346 | dictRedisObjectDestructor, /* key destructor */ | |
347 | NULL /* val destructor */ | |
348 | }; | |
349 | ||
350 | /* Sorted sets hash (note: a skiplist is used in addition to the hash table) */ | |
351 | dictType zsetDictType = { | |
352 | dictEncObjHash, /* hash function */ | |
353 | NULL, /* key dup */ | |
354 | NULL, /* val dup */ | |
355 | dictEncObjKeyCompare, /* key compare */ | |
356 | dictRedisObjectDestructor, /* key destructor */ | |
357 | NULL /* val destructor */ | |
358 | }; | |
359 | ||
360 | /* Db->dict, keys are sds strings, vals are Redis objects. */ | |
361 | dictType dbDictType = { | |
362 | dictSdsHash, /* hash function */ | |
363 | NULL, /* key dup */ | |
364 | NULL, /* val dup */ | |
365 | dictSdsKeyCompare, /* key compare */ | |
366 | dictSdsDestructor, /* key destructor */ | |
367 | dictRedisObjectDestructor /* val destructor */ | |
368 | }; | |
369 | ||
370 | /* Db->expires */ | |
371 | dictType keyptrDictType = { | |
372 | dictSdsHash, /* hash function */ | |
373 | NULL, /* key dup */ | |
374 | NULL, /* val dup */ | |
375 | dictSdsKeyCompare, /* key compare */ | |
376 | NULL, /* key destructor */ | |
377 | NULL /* val destructor */ | |
378 | }; | |
379 | ||
380 | /* Command table. sds string -> command struct pointer. */ | |
381 | dictType commandTableDictType = { | |
382 | dictSdsCaseHash, /* hash function */ | |
383 | NULL, /* key dup */ | |
384 | NULL, /* val dup */ | |
385 | dictSdsKeyCaseCompare, /* key compare */ | |
386 | dictSdsDestructor, /* key destructor */ | |
387 | NULL /* val destructor */ | |
388 | }; | |
389 | ||
390 | /* Hash type hash table (note that small hashes are represented with zimpaps) */ | |
391 | dictType hashDictType = { | |
392 | dictEncObjHash, /* hash function */ | |
393 | NULL, /* key dup */ | |
394 | NULL, /* val dup */ | |
395 | dictEncObjKeyCompare, /* key compare */ | |
396 | dictRedisObjectDestructor, /* key destructor */ | |
397 | dictRedisObjectDestructor /* val destructor */ | |
398 | }; | |
399 | ||
400 | /* Keylist hash table type has unencoded redis objects as keys and | |
401 | * lists as values. It's used for blocking operations (BLPOP) and to | |
402 | * map swapped keys to a list of clients waiting for this keys to be loaded. */ | |
403 | dictType keylistDictType = { | |
404 | dictObjHash, /* hash function */ | |
405 | NULL, /* key dup */ | |
406 | NULL, /* val dup */ | |
407 | dictObjKeyCompare, /* key compare */ | |
408 | dictRedisObjectDestructor, /* key destructor */ | |
409 | dictListDestructor /* val destructor */ | |
410 | }; | |
411 | ||
412 | int htNeedsResize(dict *dict) { | |
413 | long long size, used; | |
414 | ||
415 | size = dictSlots(dict); | |
416 | used = dictSize(dict); | |
417 | return (size && used && size > DICT_HT_INITIAL_SIZE && | |
418 | (used*100/size < REDIS_HT_MINFILL)); | |
419 | } | |
420 | ||
421 | /* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL | |
422 | * we resize the hash table to save memory */ | |
423 | void tryResizeHashTables(void) { | |
424 | int j; | |
425 | ||
426 | for (j = 0; j < server.dbnum; j++) { | |
427 | if (htNeedsResize(server.db[j].dict)) | |
428 | dictResize(server.db[j].dict); | |
429 | if (htNeedsResize(server.db[j].expires)) | |
430 | dictResize(server.db[j].expires); | |
431 | } | |
432 | } | |
433 | ||
434 | /* Our hash table implementation performs rehashing incrementally while | |
435 | * we write/read from the hash table. Still if the server is idle, the hash | |
436 | * table will use two tables for a long time. So we try to use 1 millisecond | |
437 | * of CPU time at every serverCron() loop in order to rehash some key. */ | |
438 | void incrementallyRehash(void) { | |
439 | int j; | |
440 | ||
441 | for (j = 0; j < server.dbnum; j++) { | |
442 | if (dictIsRehashing(server.db[j].dict)) { | |
443 | dictRehashMilliseconds(server.db[j].dict,1); | |
444 | break; /* already used our millisecond for this loop... */ | |
445 | } | |
446 | } | |
447 | } | |
448 | ||
449 | /* This function is called once a background process of some kind terminates, | |
450 | * as we want to avoid resizing the hash tables when there is a child in order | |
451 | * to play well with copy-on-write (otherwise when a resize happens lots of | |
452 | * memory pages are copied). The goal of this function is to update the ability | |
453 | * for dict.c to resize the hash tables accordingly to the fact we have o not | |
454 | * running childs. */ | |
455 | void updateDictResizePolicy(void) { | |
456 | if (server.bgsavechildpid == -1 && server.bgrewritechildpid == -1) | |
457 | dictEnableResize(); | |
458 | else | |
459 | dictDisableResize(); | |
460 | } | |
461 | ||
462 | /* ======================= Cron: called every 100 ms ======================== */ | |
463 | ||
464 | /* Try to expire a few timed out keys. The algorithm used is adaptive and | |
465 | * will use few CPU cycles if there are few expiring keys, otherwise | |
466 | * it will get more aggressive to avoid that too much memory is used by | |
467 | * keys that can be removed from the keyspace. */ | |
468 | void activeExpireCycle(void) { | |
469 | int j; | |
470 | ||
471 | for (j = 0; j < server.dbnum; j++) { | |
472 | int expired; | |
473 | redisDb *db = server.db+j; | |
474 | ||
475 | /* Continue to expire if at the end of the cycle more than 25% | |
476 | * of the keys were expired. */ | |
477 | do { | |
478 | long num = dictSize(db->expires); | |
479 | time_t now = time(NULL); | |
480 | ||
481 | expired = 0; | |
482 | if (num > REDIS_EXPIRELOOKUPS_PER_CRON) | |
483 | num = REDIS_EXPIRELOOKUPS_PER_CRON; | |
484 | while (num--) { | |
485 | dictEntry *de; | |
486 | time_t t; | |
487 | ||
488 | if ((de = dictGetRandomKey(db->expires)) == NULL) break; | |
489 | t = (time_t) dictGetEntryVal(de); | |
490 | if (now > t) { | |
491 | sds key = dictGetEntryKey(de); | |
492 | robj *keyobj = createStringObject(key,sdslen(key)); | |
493 | ||
494 | propagateExpire(db,keyobj); | |
495 | dbDelete(db,keyobj); | |
496 | decrRefCount(keyobj); | |
497 | expired++; | |
498 | server.stat_expiredkeys++; | |
499 | } | |
500 | } | |
501 | } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4); | |
502 | } | |
503 | } | |
504 | ||
505 | void updateLRUClock(void) { | |
506 | server.lruclock = (time(NULL)/REDIS_LRU_CLOCK_RESOLUTION) & | |
507 | REDIS_LRU_CLOCK_MAX; | |
508 | } | |
509 | ||
510 | int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { | |
511 | int j, loops = server.cronloops++; | |
512 | REDIS_NOTUSED(eventLoop); | |
513 | REDIS_NOTUSED(id); | |
514 | REDIS_NOTUSED(clientData); | |
515 | ||
516 | /* We take a cached value of the unix time in the global state because | |
517 | * with virtual memory and aging there is to store the current time | |
518 | * in objects at every object access, and accuracy is not needed. | |
519 | * To access a global var is faster than calling time(NULL) */ | |
520 | server.unixtime = time(NULL); | |
521 | /* We have just 22 bits per object for LRU information. | |
522 | * So we use an (eventually wrapping) LRU clock with 10 seconds resolution. | |
523 | * 2^22 bits with 10 seconds resoluton is more or less 1.5 years. | |
524 | * | |
525 | * Note that even if this will wrap after 1.5 years it's not a problem, | |
526 | * everything will still work but just some object will appear younger | |
527 | * to Redis. But for this to happen a given object should never be touched | |
528 | * for 1.5 years. | |
529 | * | |
530 | * Note that you can change the resolution altering the | |
531 | * REDIS_LRU_CLOCK_RESOLUTION define. | |
532 | */ | |
533 | updateLRUClock(); | |
534 | ||
535 | /* We received a SIGTERM, shutting down here in a safe way, as it is | |
536 | * not ok doing so inside the signal handler. */ | |
537 | if (server.shutdown_asap) { | |
538 | if (prepareForShutdown() == REDIS_OK) exit(0); | |
539 | redisLog(REDIS_WARNING,"SIGTERM received but errors trying to shut down the server, check the logs for more information"); | |
540 | } | |
541 | ||
542 | /* Show some info about non-empty databases */ | |
543 | for (j = 0; j < server.dbnum; j++) { | |
544 | long long size, used, vkeys; | |
545 | ||
546 | size = dictSlots(server.db[j].dict); | |
547 | used = dictSize(server.db[j].dict); | |
548 | vkeys = dictSize(server.db[j].expires); | |
549 | if (!(loops % 50) && (used || vkeys)) { | |
550 | redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size); | |
551 | /* dictPrintStats(server.dict); */ | |
552 | } | |
553 | } | |
554 | ||
555 | /* We don't want to resize the hash tables while a bacground saving | |
556 | * is in progress: the saving child is created using fork() that is | |
557 | * implemented with a copy-on-write semantic in most modern systems, so | |
558 | * if we resize the HT while there is the saving child at work actually | |
559 | * a lot of memory movements in the parent will cause a lot of pages | |
560 | * copied. */ | |
561 | if (server.bgsavechildpid == -1 && server.bgrewritechildpid == -1) { | |
562 | if (!(loops % 10)) tryResizeHashTables(); | |
563 | if (server.activerehashing) incrementallyRehash(); | |
564 | } | |
565 | ||
566 | /* Show information about connected clients */ | |
567 | if (!(loops % 50)) { | |
568 | redisLog(REDIS_VERBOSE,"%d clients connected (%d slaves), %zu bytes in use", | |
569 | listLength(server.clients)-listLength(server.slaves), | |
570 | listLength(server.slaves), | |
571 | zmalloc_used_memory()); | |
572 | } | |
573 | ||
574 | /* Close connections of timedout clients */ | |
575 | if ((server.maxidletime && !(loops % 100)) || server.blpop_blocked_clients) | |
576 | closeTimedoutClients(); | |
577 | ||
578 | /* Check if a background saving or AOF rewrite in progress terminated */ | |
579 | if (server.bgsavechildpid != -1 || server.bgrewritechildpid != -1) { | |
580 | int statloc; | |
581 | pid_t pid; | |
582 | ||
583 | if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) { | |
584 | if (pid == server.bgsavechildpid) { | |
585 | backgroundSaveDoneHandler(statloc); | |
586 | } else { | |
587 | backgroundRewriteDoneHandler(statloc); | |
588 | } | |
589 | updateDictResizePolicy(); | |
590 | } | |
591 | } else { | |
592 | /* If there is not a background saving in progress check if | |
593 | * we have to save now */ | |
594 | time_t now = time(NULL); | |
595 | for (j = 0; j < server.saveparamslen; j++) { | |
596 | struct saveparam *sp = server.saveparams+j; | |
597 | ||
598 | if (server.dirty >= sp->changes && | |
599 | now-server.lastsave > sp->seconds) { | |
600 | redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...", | |
601 | sp->changes, sp->seconds); | |
602 | rdbSaveBackground(server.dbfilename); | |
603 | break; | |
604 | } | |
605 | } | |
606 | } | |
607 | ||
608 | /* Expire a few keys per cycle, only if this is a master. | |
609 | * On slaves we wait for DEL operations synthesized by the master | |
610 | * in order to guarantee a strict consistency. */ | |
611 | if (server.masterhost == NULL) activeExpireCycle(); | |
612 | ||
613 | /* Swap a few keys on disk if we are over the memory limit and VM | |
614 | * is enbled. Try to free objects from the free list first. */ | |
615 | if (vmCanSwapOut()) { | |
616 | while (server.vm_enabled && zmalloc_used_memory() > | |
617 | server.vm_max_memory) | |
618 | { | |
619 | int retval = (server.vm_max_threads == 0) ? | |
620 | vmSwapOneObjectBlocking() : | |
621 | vmSwapOneObjectThreaded(); | |
622 | if (retval == REDIS_ERR && !(loops % 300) && | |
623 | zmalloc_used_memory() > | |
624 | (server.vm_max_memory+server.vm_max_memory/10)) | |
625 | { | |
626 | redisLog(REDIS_WARNING,"WARNING: vm-max-memory limit exceeded by more than 10%% but unable to swap more objects out!"); | |
627 | } | |
628 | /* Note that when using threade I/O we free just one object, | |
629 | * because anyway when the I/O thread in charge to swap this | |
630 | * object out will finish, the handler of completed jobs | |
631 | * will try to swap more objects if we are still out of memory. */ | |
632 | if (retval == REDIS_ERR || server.vm_max_threads > 0) break; | |
633 | } | |
634 | } | |
635 | ||
636 | /* Replication cron function -- used to reconnect to master and | |
637 | * to detect transfer failures. */ | |
638 | if (!(loops % 10)) replicationCron(); | |
639 | ||
640 | return 100; | |
641 | } | |
642 | ||
643 | /* This function gets called every time Redis is entering the | |
644 | * main loop of the event driven library, that is, before to sleep | |
645 | * for ready file descriptors. */ | |
646 | void beforeSleep(struct aeEventLoop *eventLoop) { | |
647 | REDIS_NOTUSED(eventLoop); | |
648 | ||
649 | /* Awake clients that got all the swapped keys they requested */ | |
650 | if (server.vm_enabled && listLength(server.io_ready_clients)) { | |
651 | listIter li; | |
652 | listNode *ln; | |
653 | ||
654 | listRewind(server.io_ready_clients,&li); | |
655 | while((ln = listNext(&li))) { | |
656 | redisClient *c = ln->value; | |
657 | struct redisCommand *cmd; | |
658 | ||
659 | /* Resume the client. */ | |
660 | listDelNode(server.io_ready_clients,ln); | |
661 | c->flags &= (~REDIS_IO_WAIT); | |
662 | server.vm_blocked_clients--; | |
663 | aeCreateFileEvent(server.el, c->fd, AE_READABLE, | |
664 | readQueryFromClient, c); | |
665 | cmd = lookupCommand(c->argv[0]->ptr); | |
666 | redisAssert(cmd != NULL); | |
667 | call(c,cmd); | |
668 | resetClient(c); | |
669 | /* There may be more data to process in the input buffer. */ | |
670 | if (c->querybuf && sdslen(c->querybuf) > 0) | |
671 | processInputBuffer(c); | |
672 | } | |
673 | } | |
674 | /* Write the AOF buffer on disk */ | |
675 | flushAppendOnlyFile(); | |
676 | } | |
677 | ||
678 | /* =========================== Server initialization ======================== */ | |
679 | ||
680 | void createSharedObjects(void) { | |
681 | int j; | |
682 | ||
683 | shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n")); | |
684 | shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n")); | |
685 | shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n")); | |
686 | shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n")); | |
687 | shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n")); | |
688 | shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n")); | |
689 | shared.cnegone = createObject(REDIS_STRING,sdsnew(":-1\r\n")); | |
690 | shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n")); | |
691 | shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n")); | |
692 | shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n")); | |
693 | shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n")); | |
694 | shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n")); | |
695 | shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew( | |
696 | "-ERR Operation against a key holding the wrong kind of value\r\n")); | |
697 | shared.nokeyerr = createObject(REDIS_STRING,sdsnew( | |
698 | "-ERR no such key\r\n")); | |
699 | shared.syntaxerr = createObject(REDIS_STRING,sdsnew( | |
700 | "-ERR syntax error\r\n")); | |
701 | shared.sameobjecterr = createObject(REDIS_STRING,sdsnew( | |
702 | "-ERR source and destination objects are the same\r\n")); | |
703 | shared.outofrangeerr = createObject(REDIS_STRING,sdsnew( | |
704 | "-ERR index out of range\r\n")); | |
705 | shared.space = createObject(REDIS_STRING,sdsnew(" ")); | |
706 | shared.colon = createObject(REDIS_STRING,sdsnew(":")); | |
707 | shared.plus = createObject(REDIS_STRING,sdsnew("+")); | |
708 | shared.select0 = createStringObject("select 0\r\n",10); | |
709 | shared.select1 = createStringObject("select 1\r\n",10); | |
710 | shared.select2 = createStringObject("select 2\r\n",10); | |
711 | shared.select3 = createStringObject("select 3\r\n",10); | |
712 | shared.select4 = createStringObject("select 4\r\n",10); | |
713 | shared.select5 = createStringObject("select 5\r\n",10); | |
714 | shared.select6 = createStringObject("select 6\r\n",10); | |
715 | shared.select7 = createStringObject("select 7\r\n",10); | |
716 | shared.select8 = createStringObject("select 8\r\n",10); | |
717 | shared.select9 = createStringObject("select 9\r\n",10); | |
718 | shared.messagebulk = createStringObject("$7\r\nmessage\r\n",13); | |
719 | shared.pmessagebulk = createStringObject("$8\r\npmessage\r\n",14); | |
720 | shared.subscribebulk = createStringObject("$9\r\nsubscribe\r\n",15); | |
721 | shared.unsubscribebulk = createStringObject("$11\r\nunsubscribe\r\n",18); | |
722 | shared.psubscribebulk = createStringObject("$10\r\npsubscribe\r\n",17); | |
723 | shared.punsubscribebulk = createStringObject("$12\r\npunsubscribe\r\n",19); | |
724 | shared.mbulk3 = createStringObject("*3\r\n",4); | |
725 | shared.mbulk4 = createStringObject("*4\r\n",4); | |
726 | for (j = 0; j < REDIS_SHARED_INTEGERS; j++) { | |
727 | shared.integers[j] = createObject(REDIS_STRING,(void*)(long)j); | |
728 | shared.integers[j]->encoding = REDIS_ENCODING_INT; | |
729 | } | |
730 | } | |
731 | ||
732 | void initServerConfig() { | |
733 | server.port = REDIS_SERVERPORT; | |
734 | server.bindaddr = NULL; | |
735 | server.unixsocket = NULL; | |
736 | server.ipfd = -1; | |
737 | server.sofd = -1; | |
738 | server.dbnum = REDIS_DEFAULT_DBNUM; | |
739 | server.verbosity = REDIS_VERBOSE; | |
740 | server.maxidletime = REDIS_MAXIDLETIME; | |
741 | server.saveparams = NULL; | |
742 | server.logfile = NULL; /* NULL = log on standard output */ | |
743 | server.glueoutputbuf = 1; | |
744 | server.daemonize = 0; | |
745 | server.appendonly = 0; | |
746 | server.appendfsync = APPENDFSYNC_EVERYSEC; | |
747 | server.no_appendfsync_on_rewrite = 0; | |
748 | server.lastfsync = time(NULL); | |
749 | server.appendfd = -1; | |
750 | server.appendseldb = -1; /* Make sure the first time will not match */ | |
751 | server.pidfile = zstrdup("/var/run/redis.pid"); | |
752 | server.dbfilename = zstrdup("dump.rdb"); | |
753 | server.appendfilename = zstrdup("appendonly.aof"); | |
754 | server.requirepass = NULL; | |
755 | server.rdbcompression = 1; | |
756 | server.activerehashing = 1; | |
757 | server.maxclients = 0; | |
758 | server.blpop_blocked_clients = 0; | |
759 | server.maxmemory = 0; | |
760 | server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU; | |
761 | server.maxmemory_samples = 3; | |
762 | server.vm_enabled = 0; | |
763 | server.vm_swap_file = zstrdup("/tmp/redis-%p.vm"); | |
764 | server.vm_page_size = 256; /* 256 bytes per page */ | |
765 | server.vm_pages = 1024*1024*100; /* 104 millions of pages */ | |
766 | server.vm_max_memory = 1024LL*1024*1024*1; /* 1 GB of RAM */ | |
767 | server.vm_max_threads = 4; | |
768 | server.vm_blocked_clients = 0; | |
769 | server.hash_max_zipmap_entries = REDIS_HASH_MAX_ZIPMAP_ENTRIES; | |
770 | server.hash_max_zipmap_value = REDIS_HASH_MAX_ZIPMAP_VALUE; | |
771 | server.list_max_ziplist_entries = REDIS_LIST_MAX_ZIPLIST_ENTRIES; | |
772 | server.list_max_ziplist_value = REDIS_LIST_MAX_ZIPLIST_VALUE; | |
773 | server.set_max_intset_entries = REDIS_SET_MAX_INTSET_ENTRIES; | |
774 | server.shutdown_asap = 0; | |
775 | ||
776 | updateLRUClock(); | |
777 | resetServerSaveParams(); | |
778 | ||
779 | appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */ | |
780 | appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */ | |
781 | appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */ | |
782 | /* Replication related */ | |
783 | server.isslave = 0; | |
784 | server.masterauth = NULL; | |
785 | server.masterhost = NULL; | |
786 | server.masterport = 6379; | |
787 | server.master = NULL; | |
788 | server.replstate = REDIS_REPL_NONE; | |
789 | server.repl_serve_stale_data = 1; | |
790 | ||
791 | /* Double constants initialization */ | |
792 | R_Zero = 0.0; | |
793 | R_PosInf = 1.0/R_Zero; | |
794 | R_NegInf = -1.0/R_Zero; | |
795 | R_Nan = R_Zero/R_Zero; | |
796 | ||
797 | /* Command table -- we intiialize it here as it is part of the | |
798 | * initial configuration, since command names may be changed via | |
799 | * redis.conf using the rename-command directive. */ | |
800 | server.commands = dictCreate(&commandTableDictType,NULL); | |
801 | populateCommandTable(); | |
802 | server.delCommand = lookupCommandByCString("del"); | |
803 | server.multiCommand = lookupCommandByCString("multi"); | |
804 | } | |
805 | ||
806 | void initServer() { | |
807 | int j; | |
808 | ||
809 | signal(SIGHUP, SIG_IGN); | |
810 | signal(SIGPIPE, SIG_IGN); | |
811 | setupSigSegvAction(); | |
812 | ||
813 | server.mainthread = pthread_self(); | |
814 | server.devnull = fopen("/dev/null","w"); | |
815 | if (server.devnull == NULL) { | |
816 | redisLog(REDIS_WARNING, "Can't open /dev/null: %s", server.neterr); | |
817 | exit(1); | |
818 | } | |
819 | server.clients = listCreate(); | |
820 | server.slaves = listCreate(); | |
821 | server.monitors = listCreate(); | |
822 | createSharedObjects(); | |
823 | server.el = aeCreateEventLoop(); | |
824 | server.db = zmalloc(sizeof(redisDb)*server.dbnum); | |
825 | server.ipfd = anetTcpServer(server.neterr,server.port,server.bindaddr); | |
826 | if (server.ipfd == ANET_ERR) { | |
827 | redisLog(REDIS_WARNING, "Opening port: %s", server.neterr); | |
828 | exit(1); | |
829 | } | |
830 | if (server.unixsocket != NULL) { | |
831 | unlink(server.unixsocket); /* don't care if this fails */ | |
832 | server.sofd = anetUnixServer(server.neterr,server.unixsocket); | |
833 | if (server.sofd == ANET_ERR) { | |
834 | redisLog(REDIS_WARNING, "Opening socket: %s", server.neterr); | |
835 | exit(1); | |
836 | } | |
837 | } | |
838 | if (server.ipfd < 0 && server.sofd < 0) { | |
839 | redisLog(REDIS_WARNING, "Configured to not listen anywhere, exiting."); | |
840 | exit(1); | |
841 | } | |
842 | for (j = 0; j < server.dbnum; j++) { | |
843 | server.db[j].dict = dictCreate(&dbDictType,NULL); | |
844 | server.db[j].expires = dictCreate(&keyptrDictType,NULL); | |
845 | server.db[j].blocking_keys = dictCreate(&keylistDictType,NULL); | |
846 | server.db[j].watched_keys = dictCreate(&keylistDictType,NULL); | |
847 | if (server.vm_enabled) | |
848 | server.db[j].io_keys = dictCreate(&keylistDictType,NULL); | |
849 | server.db[j].id = j; | |
850 | } | |
851 | server.pubsub_channels = dictCreate(&keylistDictType,NULL); | |
852 | server.pubsub_patterns = listCreate(); | |
853 | listSetFreeMethod(server.pubsub_patterns,freePubsubPattern); | |
854 | listSetMatchMethod(server.pubsub_patterns,listMatchPubsubPattern); | |
855 | server.cronloops = 0; | |
856 | server.bgsavechildpid = -1; | |
857 | server.bgrewritechildpid = -1; | |
858 | server.bgrewritebuf = sdsempty(); | |
859 | server.aofbuf = sdsempty(); | |
860 | server.lastsave = time(NULL); | |
861 | server.dirty = 0; | |
862 | server.stat_numcommands = 0; | |
863 | server.stat_numconnections = 0; | |
864 | server.stat_expiredkeys = 0; | |
865 | server.stat_starttime = time(NULL); | |
866 | server.stat_keyspace_misses = 0; | |
867 | server.stat_keyspace_hits = 0; | |
868 | server.unixtime = time(NULL); | |
869 | aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL); | |
870 | if (server.ipfd > 0 && aeCreateFileEvent(server.el,server.ipfd,AE_READABLE, | |
871 | acceptTcpHandler,NULL) == AE_ERR) oom("creating file event"); | |
872 | if (server.sofd > 0 && aeCreateFileEvent(server.el,server.sofd,AE_READABLE, | |
873 | acceptUnixHandler,NULL) == AE_ERR) oom("creating file event"); | |
874 | ||
875 | if (server.appendonly) { | |
876 | server.appendfd = open(server.appendfilename,O_WRONLY|O_APPEND|O_CREAT,0644); | |
877 | if (server.appendfd == -1) { | |
878 | redisLog(REDIS_WARNING, "Can't open the append-only file: %s", | |
879 | strerror(errno)); | |
880 | exit(1); | |
881 | } | |
882 | } | |
883 | ||
884 | if (server.vm_enabled) vmInit(); | |
885 | } | |
886 | ||
887 | /* Populates the Redis Command Table starting from the hard coded list | |
888 | * we have on top of redis.c file. */ | |
889 | void populateCommandTable(void) { | |
890 | int j; | |
891 | int numcommands = sizeof(readonlyCommandTable)/sizeof(struct redisCommand); | |
892 | ||
893 | for (j = 0; j < numcommands; j++) { | |
894 | struct redisCommand *c = readonlyCommandTable+j; | |
895 | int retval; | |
896 | ||
897 | retval = dictAdd(server.commands, sdsnew(c->name), c); | |
898 | assert(retval == DICT_OK); | |
899 | } | |
900 | } | |
901 | ||
902 | /* ====================== Commands lookup and execution ===================== */ | |
903 | ||
904 | struct redisCommand *lookupCommand(sds name) { | |
905 | return dictFetchValue(server.commands, name); | |
906 | } | |
907 | ||
908 | struct redisCommand *lookupCommandByCString(char *s) { | |
909 | struct redisCommand *cmd; | |
910 | sds name = sdsnew(s); | |
911 | ||
912 | cmd = dictFetchValue(server.commands, name); | |
913 | sdsfree(name); | |
914 | return cmd; | |
915 | } | |
916 | ||
917 | /* Call() is the core of Redis execution of a command */ | |
918 | void call(redisClient *c, struct redisCommand *cmd) { | |
919 | long long dirty; | |
920 | ||
921 | dirty = server.dirty; | |
922 | cmd->proc(c); | |
923 | dirty = server.dirty-dirty; | |
924 | ||
925 | if (server.appendonly && dirty) | |
926 | feedAppendOnlyFile(cmd,c->db->id,c->argv,c->argc); | |
927 | if ((dirty || cmd->flags & REDIS_CMD_FORCE_REPLICATION) && | |
928 | listLength(server.slaves)) | |
929 | replicationFeedSlaves(server.slaves,c->db->id,c->argv,c->argc); | |
930 | if (listLength(server.monitors)) | |
931 | replicationFeedMonitors(server.monitors,c->db->id,c->argv,c->argc); | |
932 | server.stat_numcommands++; | |
933 | } | |
934 | ||
935 | /* If this function gets called we already read a whole | |
936 | * command, argments are in the client argv/argc fields. | |
937 | * processCommand() execute the command or prepare the | |
938 | * server for a bulk read from the client. | |
939 | * | |
940 | * If 1 is returned the client is still alive and valid and | |
941 | * and other operations can be performed by the caller. Otherwise | |
942 | * if 0 is returned the client was destroied (i.e. after QUIT). */ | |
943 | int processCommand(redisClient *c) { | |
944 | struct redisCommand *cmd; | |
945 | ||
946 | /* The QUIT command is handled separately. Normal command procs will | |
947 | * go through checking for replication and QUIT will cause trouble | |
948 | * when FORCE_REPLICATION is enabled and would be implemented in | |
949 | * a regular command proc. */ | |
950 | if (!strcasecmp(c->argv[0]->ptr,"quit")) { | |
951 | addReply(c,shared.ok); | |
952 | c->flags |= REDIS_CLOSE_AFTER_REPLY; | |
953 | return REDIS_ERR; | |
954 | } | |
955 | ||
956 | /* Now lookup the command and check ASAP about trivial error conditions | |
957 | * such wrong arity, bad command name and so forth. */ | |
958 | cmd = lookupCommand(c->argv[0]->ptr); | |
959 | if (!cmd) { | |
960 | addReplyErrorFormat(c,"unknown command '%s'", | |
961 | (char*)c->argv[0]->ptr); | |
962 | return REDIS_OK; | |
963 | } else if ((cmd->arity > 0 && cmd->arity != c->argc) || | |
964 | (c->argc < -cmd->arity)) { | |
965 | addReplyErrorFormat(c,"wrong number of arguments for '%s' command", | |
966 | cmd->name); | |
967 | return REDIS_OK; | |
968 | } | |
969 | ||
970 | /* Check if the user is authenticated */ | |
971 | if (server.requirepass && !c->authenticated && cmd->proc != authCommand) { | |
972 | addReplyError(c,"operation not permitted"); | |
973 | return REDIS_OK; | |
974 | } | |
975 | ||
976 | /* Handle the maxmemory directive. | |
977 | * | |
978 | * First we try to free some memory if possible (if there are volatile | |
979 | * keys in the dataset). If there are not the only thing we can do | |
980 | * is returning an error. */ | |
981 | if (server.maxmemory) freeMemoryIfNeeded(); | |
982 | if (server.maxmemory && (cmd->flags & REDIS_CMD_DENYOOM) && | |
983 | zmalloc_used_memory() > server.maxmemory) | |
984 | { | |
985 | addReplyError(c,"command not allowed when used memory > 'maxmemory'"); | |
986 | return REDIS_OK; | |
987 | } | |
988 | ||
989 | /* Only allow SUBSCRIBE and UNSUBSCRIBE in the context of Pub/Sub */ | |
990 | if ((dictSize(c->pubsub_channels) > 0 || listLength(c->pubsub_patterns) > 0) | |
991 | && | |
992 | cmd->proc != subscribeCommand && cmd->proc != unsubscribeCommand && | |
993 | cmd->proc != psubscribeCommand && cmd->proc != punsubscribeCommand) { | |
994 | addReplyError(c,"only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context"); | |
995 | return REDIS_OK; | |
996 | } | |
997 | ||
998 | /* Only allow INFO and SLAVEOF when slave-serve-stale-data is no and | |
999 | * we are a slave with a broken link with master. */ | |
1000 | if (server.masterhost && server.replstate != REDIS_REPL_CONNECTED && | |
1001 | server.repl_serve_stale_data == 0 && | |
1002 | cmd->proc != infoCommand && cmd->proc != slaveofCommand) | |
1003 | { | |
1004 | addReplyError(c, | |
1005 | "link with MASTER is down and slave-serve-stale-data is set to no"); | |
1006 | return REDIS_OK; | |
1007 | } | |
1008 | ||
1009 | /* Exec the command */ | |
1010 | if (c->flags & REDIS_MULTI && | |
1011 | cmd->proc != execCommand && cmd->proc != discardCommand && | |
1012 | cmd->proc != multiCommand && cmd->proc != watchCommand) | |
1013 | { | |
1014 | queueMultiCommand(c,cmd); | |
1015 | addReply(c,shared.queued); | |
1016 | } else { | |
1017 | if (server.vm_enabled && server.vm_max_threads > 0 && | |
1018 | blockClientOnSwappedKeys(c,cmd)) return REDIS_ERR; | |
1019 | call(c,cmd); | |
1020 | } | |
1021 | return REDIS_OK; | |
1022 | } | |
1023 | ||
1024 | /*================================== Shutdown =============================== */ | |
1025 | ||
1026 | int prepareForShutdown() { | |
1027 | redisLog(REDIS_WARNING,"User requested shutdown, saving DB..."); | |
1028 | /* Kill the saving child if there is a background saving in progress. | |
1029 | We want to avoid race conditions, for instance our saving child may | |
1030 | overwrite the synchronous saving did by SHUTDOWN. */ | |
1031 | if (server.bgsavechildpid != -1) { | |
1032 | redisLog(REDIS_WARNING,"There is a live saving child. Killing it!"); | |
1033 | kill(server.bgsavechildpid,SIGKILL); | |
1034 | rdbRemoveTempFile(server.bgsavechildpid); | |
1035 | } | |
1036 | if (server.appendonly) { | |
1037 | /* Append only file: fsync() the AOF and exit */ | |
1038 | aof_fsync(server.appendfd); | |
1039 | if (server.vm_enabled) unlink(server.vm_swap_file); | |
1040 | } else if (server.saveparamslen > 0) { | |
1041 | /* Snapshotting. Perform a SYNC SAVE and exit */ | |
1042 | if (rdbSave(server.dbfilename) != REDIS_OK) { | |
1043 | /* Ooops.. error saving! The best we can do is to continue | |
1044 | * operating. Note that if there was a background saving process, | |
1045 | * in the next cron() Redis will be notified that the background | |
1046 | * saving aborted, handling special stuff like slaves pending for | |
1047 | * synchronization... */ | |
1048 | redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit"); | |
1049 | return REDIS_ERR; | |
1050 | } | |
1051 | } else { | |
1052 | redisLog(REDIS_WARNING,"Not saving DB."); | |
1053 | } | |
1054 | if (server.daemonize) unlink(server.pidfile); | |
1055 | redisLog(REDIS_WARNING,"Server exit now, bye bye..."); | |
1056 | return REDIS_OK; | |
1057 | } | |
1058 | ||
1059 | /*================================== Commands =============================== */ | |
1060 | ||
1061 | void authCommand(redisClient *c) { | |
1062 | if (!server.requirepass || !strcmp(c->argv[1]->ptr, server.requirepass)) { | |
1063 | c->authenticated = 1; | |
1064 | addReply(c,shared.ok); | |
1065 | } else { | |
1066 | c->authenticated = 0; | |
1067 | addReplyError(c,"invalid password"); | |
1068 | } | |
1069 | } | |
1070 | ||
1071 | void pingCommand(redisClient *c) { | |
1072 | addReply(c,shared.pong); | |
1073 | } | |
1074 | ||
1075 | void echoCommand(redisClient *c) { | |
1076 | addReplyBulk(c,c->argv[1]); | |
1077 | } | |
1078 | ||
1079 | /* Convert an amount of bytes into a human readable string in the form | |
1080 | * of 100B, 2G, 100M, 4K, and so forth. */ | |
1081 | void bytesToHuman(char *s, unsigned long long n) { | |
1082 | double d; | |
1083 | ||
1084 | if (n < 1024) { | |
1085 | /* Bytes */ | |
1086 | sprintf(s,"%lluB",n); | |
1087 | return; | |
1088 | } else if (n < (1024*1024)) { | |
1089 | d = (double)n/(1024); | |
1090 | sprintf(s,"%.2fK",d); | |
1091 | } else if (n < (1024LL*1024*1024)) { | |
1092 | d = (double)n/(1024*1024); | |
1093 | sprintf(s,"%.2fM",d); | |
1094 | } else if (n < (1024LL*1024*1024*1024)) { | |
1095 | d = (double)n/(1024LL*1024*1024); | |
1096 | sprintf(s,"%.2fG",d); | |
1097 | } | |
1098 | } | |
1099 | ||
1100 | /* Create the string returned by the INFO command. This is decoupled | |
1101 | * by the INFO command itself as we need to report the same information | |
1102 | * on memory corruption problems. */ | |
1103 | sds genRedisInfoString(void) { | |
1104 | sds info; | |
1105 | time_t uptime = time(NULL)-server.stat_starttime; | |
1106 | int j; | |
1107 | char hmem[64]; | |
1108 | struct rusage self_ru, c_ru; | |
1109 | ||
1110 | getrusage(RUSAGE_SELF, &self_ru); | |
1111 | getrusage(RUSAGE_CHILDREN, &c_ru); | |
1112 | ||
1113 | bytesToHuman(hmem,zmalloc_used_memory()); | |
1114 | info = sdscatprintf(sdsempty(), | |
1115 | "redis_version:%s\r\n" | |
1116 | "redis_git_sha1:%s\r\n" | |
1117 | "redis_git_dirty:%d\r\n" | |
1118 | "arch_bits:%s\r\n" | |
1119 | "multiplexing_api:%s\r\n" | |
1120 | "process_id:%ld\r\n" | |
1121 | "uptime_in_seconds:%ld\r\n" | |
1122 | "uptime_in_days:%ld\r\n" | |
1123 | "lru_clock:%ld\r\n" | |
1124 | "used_cpu_sys:%.2f\r\n" | |
1125 | "used_cpu_user:%.2f\r\n" | |
1126 | "used_cpu_sys_childrens:%.2f\r\n" | |
1127 | "used_cpu_user_childrens:%.2f\r\n" | |
1128 | "connected_clients:%d\r\n" | |
1129 | "connected_slaves:%d\r\n" | |
1130 | "blocked_clients:%d\r\n" | |
1131 | "used_memory:%zu\r\n" | |
1132 | "used_memory_human:%s\r\n" | |
1133 | "used_memory_rss:%zu\r\n" | |
1134 | "mem_fragmentation_ratio:%.2f\r\n" | |
1135 | "use_tcmalloc:%d\r\n" | |
1136 | "changes_since_last_save:%lld\r\n" | |
1137 | "bgsave_in_progress:%d\r\n" | |
1138 | "last_save_time:%ld\r\n" | |
1139 | "bgrewriteaof_in_progress:%d\r\n" | |
1140 | "total_connections_received:%lld\r\n" | |
1141 | "total_commands_processed:%lld\r\n" | |
1142 | "expired_keys:%lld\r\n" | |
1143 | "keyspace_hits:%lld\r\n" | |
1144 | "keyspace_misses:%lld\r\n" | |
1145 | "hash_max_zipmap_entries:%zu\r\n" | |
1146 | "hash_max_zipmap_value:%zu\r\n" | |
1147 | "pubsub_channels:%ld\r\n" | |
1148 | "pubsub_patterns:%u\r\n" | |
1149 | "vm_enabled:%d\r\n" | |
1150 | "role:%s\r\n" | |
1151 | ,REDIS_VERSION, | |
1152 | redisGitSHA1(), | |
1153 | strtol(redisGitDirty(),NULL,10) > 0, | |
1154 | (sizeof(long) == 8) ? "64" : "32", | |
1155 | aeGetApiName(), | |
1156 | (long) getpid(), | |
1157 | uptime, | |
1158 | uptime/(3600*24), | |
1159 | (unsigned long) server.lruclock, | |
1160 | (float)self_ru.ru_utime.tv_sec+(float)self_ru.ru_utime.tv_usec/1000000, | |
1161 | (float)self_ru.ru_stime.tv_sec+(float)self_ru.ru_stime.tv_usec/1000000, | |
1162 | (float)c_ru.ru_utime.tv_sec+(float)c_ru.ru_utime.tv_usec/1000000, | |
1163 | (float)c_ru.ru_stime.tv_sec+(float)c_ru.ru_stime.tv_usec/1000000, | |
1164 | listLength(server.clients)-listLength(server.slaves), | |
1165 | listLength(server.slaves), | |
1166 | server.blpop_blocked_clients, | |
1167 | zmalloc_used_memory(), | |
1168 | hmem, | |
1169 | zmalloc_get_rss(), | |
1170 | zmalloc_get_fragmentation_ratio(), | |
1171 | #ifdef USE_TCMALLOC | |
1172 | 1, | |
1173 | #else | |
1174 | 0, | |
1175 | #endif | |
1176 | server.dirty, | |
1177 | server.bgsavechildpid != -1, | |
1178 | server.lastsave, | |
1179 | server.bgrewritechildpid != -1, | |
1180 | server.stat_numconnections, | |
1181 | server.stat_numcommands, | |
1182 | server.stat_expiredkeys, | |
1183 | server.stat_keyspace_hits, | |
1184 | server.stat_keyspace_misses, | |
1185 | server.hash_max_zipmap_entries, | |
1186 | server.hash_max_zipmap_value, | |
1187 | dictSize(server.pubsub_channels), | |
1188 | listLength(server.pubsub_patterns), | |
1189 | server.vm_enabled != 0, | |
1190 | server.masterhost == NULL ? "master" : "slave" | |
1191 | ); | |
1192 | if (server.masterhost) { | |
1193 | info = sdscatprintf(info, | |
1194 | "master_host:%s\r\n" | |
1195 | "master_port:%d\r\n" | |
1196 | "master_link_status:%s\r\n" | |
1197 | "master_last_io_seconds_ago:%d\r\n" | |
1198 | "master_sync_in_progress:%d\r\n" | |
1199 | ,server.masterhost, | |
1200 | server.masterport, | |
1201 | (server.replstate == REDIS_REPL_CONNECTED) ? | |
1202 | "up" : "down", | |
1203 | server.master ? ((int)(time(NULL)-server.master->lastinteraction)) : -1, | |
1204 | server.replstate == REDIS_REPL_TRANSFER | |
1205 | ); | |
1206 | ||
1207 | if (server.replstate == REDIS_REPL_TRANSFER) { | |
1208 | info = sdscatprintf(info, | |
1209 | "master_sync_left_bytes:%ld\r\n" | |
1210 | "master_sync_last_io_seconds_ago:%d\r\n" | |
1211 | ,(long)server.repl_transfer_left, | |
1212 | (int)(time(NULL)-server.repl_transfer_lastio) | |
1213 | ); | |
1214 | } | |
1215 | } | |
1216 | if (server.vm_enabled) { | |
1217 | lockThreadedIO(); | |
1218 | info = sdscatprintf(info, | |
1219 | "vm_conf_max_memory:%llu\r\n" | |
1220 | "vm_conf_page_size:%llu\r\n" | |
1221 | "vm_conf_pages:%llu\r\n" | |
1222 | "vm_stats_used_pages:%llu\r\n" | |
1223 | "vm_stats_swapped_objects:%llu\r\n" | |
1224 | "vm_stats_swappin_count:%llu\r\n" | |
1225 | "vm_stats_swappout_count:%llu\r\n" | |
1226 | "vm_stats_io_newjobs_len:%lu\r\n" | |
1227 | "vm_stats_io_processing_len:%lu\r\n" | |
1228 | "vm_stats_io_processed_len:%lu\r\n" | |
1229 | "vm_stats_io_active_threads:%lu\r\n" | |
1230 | "vm_stats_blocked_clients:%lu\r\n" | |
1231 | ,(unsigned long long) server.vm_max_memory, | |
1232 | (unsigned long long) server.vm_page_size, | |
1233 | (unsigned long long) server.vm_pages, | |
1234 | (unsigned long long) server.vm_stats_used_pages, | |
1235 | (unsigned long long) server.vm_stats_swapped_objects, | |
1236 | (unsigned long long) server.vm_stats_swapins, | |
1237 | (unsigned long long) server.vm_stats_swapouts, | |
1238 | (unsigned long) listLength(server.io_newjobs), | |
1239 | (unsigned long) listLength(server.io_processing), | |
1240 | (unsigned long) listLength(server.io_processed), | |
1241 | (unsigned long) server.io_active_threads, | |
1242 | (unsigned long) server.vm_blocked_clients | |
1243 | ); | |
1244 | unlockThreadedIO(); | |
1245 | } | |
1246 | for (j = 0; j < server.dbnum; j++) { | |
1247 | long long keys, vkeys; | |
1248 | ||
1249 | keys = dictSize(server.db[j].dict); | |
1250 | vkeys = dictSize(server.db[j].expires); | |
1251 | if (keys || vkeys) { | |
1252 | info = sdscatprintf(info, "db%d:keys=%lld,expires=%lld\r\n", | |
1253 | j, keys, vkeys); | |
1254 | } | |
1255 | } | |
1256 | return info; | |
1257 | } | |
1258 | ||
1259 | void infoCommand(redisClient *c) { | |
1260 | sds info = genRedisInfoString(); | |
1261 | addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n", | |
1262 | (unsigned long)sdslen(info))); | |
1263 | addReplySds(c,info); | |
1264 | addReply(c,shared.crlf); | |
1265 | } | |
1266 | ||
1267 | void monitorCommand(redisClient *c) { | |
1268 | /* ignore MONITOR if aleady slave or in monitor mode */ | |
1269 | if (c->flags & REDIS_SLAVE) return; | |
1270 | ||
1271 | c->flags |= (REDIS_SLAVE|REDIS_MONITOR); | |
1272 | c->slaveseldb = 0; | |
1273 | listAddNodeTail(server.monitors,c); | |
1274 | addReply(c,shared.ok); | |
1275 | } | |
1276 | ||
1277 | /* ============================ Maxmemory directive ======================== */ | |
1278 | ||
1279 | /* This function gets called when 'maxmemory' is set on the config file to limit | |
1280 | * the max memory used by the server, and we are out of memory. | |
1281 | * This function will try to, in order: | |
1282 | * | |
1283 | * - Free objects from the free list | |
1284 | * - Try to remove keys with an EXPIRE set | |
1285 | * | |
1286 | * It is not possible to free enough memory to reach used-memory < maxmemory | |
1287 | * the server will start refusing commands that will enlarge even more the | |
1288 | * memory usage. | |
1289 | */ | |
1290 | void freeMemoryIfNeeded(void) { | |
1291 | /* Remove keys accordingly to the active policy as long as we are | |
1292 | * over the memory limit. */ | |
1293 | while (server.maxmemory && zmalloc_used_memory() > server.maxmemory) { | |
1294 | int j, k, freed = 0; | |
1295 | ||
1296 | for (j = 0; j < server.dbnum; j++) { | |
1297 | long bestval = 0; /* just to prevent warning */ | |
1298 | sds bestkey = NULL; | |
1299 | struct dictEntry *de; | |
1300 | redisDb *db = server.db+j; | |
1301 | dict *dict; | |
1302 | ||
1303 | if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU || | |
1304 | server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM) | |
1305 | { | |
1306 | dict = server.db[j].dict; | |
1307 | } else { | |
1308 | dict = server.db[j].expires; | |
1309 | } | |
1310 | if (dictSize(dict) == 0) continue; | |
1311 | ||
1312 | /* volatile-random and allkeys-random policy */ | |
1313 | if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM || | |
1314 | server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM) | |
1315 | { | |
1316 | de = dictGetRandomKey(dict); | |
1317 | bestkey = dictGetEntryKey(de); | |
1318 | } | |
1319 | ||
1320 | /* volatile-lru and allkeys-lru policy */ | |
1321 | else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU || | |
1322 | server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU) | |
1323 | { | |
1324 | for (k = 0; k < server.maxmemory_samples; k++) { | |
1325 | sds thiskey; | |
1326 | long thisval; | |
1327 | robj *o; | |
1328 | ||
1329 | de = dictGetRandomKey(dict); | |
1330 | thiskey = dictGetEntryKey(de); | |
1331 | o = dictGetEntryVal(de); | |
1332 | thisval = estimateObjectIdleTime(o); | |
1333 | ||
1334 | /* Higher idle time is better candidate for deletion */ | |
1335 | if (bestkey == NULL || thisval > bestval) { | |
1336 | bestkey = thiskey; | |
1337 | bestval = thisval; | |
1338 | } | |
1339 | } | |
1340 | } | |
1341 | ||
1342 | /* volatile-ttl */ | |
1343 | else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) { | |
1344 | for (k = 0; k < server.maxmemory_samples; k++) { | |
1345 | sds thiskey; | |
1346 | long thisval; | |
1347 | ||
1348 | de = dictGetRandomKey(dict); | |
1349 | thiskey = dictGetEntryKey(de); | |
1350 | thisval = (long) dictGetEntryVal(de); | |
1351 | ||
1352 | /* Expire sooner (minor expire unix timestamp) is better | |
1353 | * candidate for deletion */ | |
1354 | if (bestkey == NULL || thisval < bestval) { | |
1355 | bestkey = thiskey; | |
1356 | bestval = thisval; | |
1357 | } | |
1358 | } | |
1359 | } | |
1360 | ||
1361 | /* Finally remove the selected key. */ | |
1362 | if (bestkey) { | |
1363 | robj *keyobj = createStringObject(bestkey,sdslen(bestkey)); | |
1364 | dbDelete(db,keyobj); | |
1365 | server.stat_expiredkeys++; | |
1366 | decrRefCount(keyobj); | |
1367 | freed++; | |
1368 | } | |
1369 | } | |
1370 | if (!freed) return; /* nothing to free... */ | |
1371 | } | |
1372 | ||
1373 | while(0) { | |
1374 | int j, k, freed = 0; | |
1375 | for (j = 0; j < server.dbnum; j++) { | |
1376 | int minttl = -1; | |
1377 | sds minkey = NULL; | |
1378 | robj *keyobj = NULL; | |
1379 | struct dictEntry *de; | |
1380 | ||
1381 | if (dictSize(server.db[j].expires)) { | |
1382 | freed = 1; | |
1383 | /* From a sample of three keys drop the one nearest to | |
1384 | * the natural expire */ | |
1385 | for (k = 0; k < 3; k++) { | |
1386 | time_t t; | |
1387 | ||
1388 | de = dictGetRandomKey(server.db[j].expires); | |
1389 | t = (time_t) dictGetEntryVal(de); | |
1390 | if (minttl == -1 || t < minttl) { | |
1391 | minkey = dictGetEntryKey(de); | |
1392 | minttl = t; | |
1393 | } | |
1394 | } | |
1395 | keyobj = createStringObject(minkey,sdslen(minkey)); | |
1396 | dbDelete(server.db+j,keyobj); | |
1397 | server.stat_expiredkeys++; | |
1398 | decrRefCount(keyobj); | |
1399 | } | |
1400 | } | |
1401 | if (!freed) return; /* nothing to free... */ | |
1402 | } | |
1403 | } | |
1404 | ||
1405 | /* =================================== Main! ================================ */ | |
1406 | ||
1407 | #ifdef __linux__ | |
1408 | int linuxOvercommitMemoryValue(void) { | |
1409 | FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r"); | |
1410 | char buf[64]; | |
1411 | ||
1412 | if (!fp) return -1; | |
1413 | if (fgets(buf,64,fp) == NULL) { | |
1414 | fclose(fp); | |
1415 | return -1; | |
1416 | } | |
1417 | fclose(fp); | |
1418 | ||
1419 | return atoi(buf); | |
1420 | } | |
1421 | ||
1422 | void linuxOvercommitMemoryWarning(void) { | |
1423 | if (linuxOvercommitMemoryValue() == 0) { | |
1424 | 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."); | |
1425 | } | |
1426 | } | |
1427 | #endif /* __linux__ */ | |
1428 | ||
1429 | void createPidFile(void) { | |
1430 | /* Try to write the pid file in a best-effort way. */ | |
1431 | FILE *fp = fopen(server.pidfile,"w"); | |
1432 | if (fp) { | |
1433 | fprintf(fp,"%d\n",getpid()); | |
1434 | fclose(fp); | |
1435 | } | |
1436 | } | |
1437 | ||
1438 | void daemonize(void) { | |
1439 | int fd; | |
1440 | ||
1441 | if (fork() != 0) exit(0); /* parent exits */ | |
1442 | setsid(); /* create a new session */ | |
1443 | ||
1444 | /* Every output goes to /dev/null. If Redis is daemonized but | |
1445 | * the 'logfile' is set to 'stdout' in the configuration file | |
1446 | * it will not log at all. */ | |
1447 | if ((fd = open("/dev/null", O_RDWR, 0)) != -1) { | |
1448 | dup2(fd, STDIN_FILENO); | |
1449 | dup2(fd, STDOUT_FILENO); | |
1450 | dup2(fd, STDERR_FILENO); | |
1451 | if (fd > STDERR_FILENO) close(fd); | |
1452 | } | |
1453 | } | |
1454 | ||
1455 | void version() { | |
1456 | printf("Redis server version %s (%s:%d)\n", REDIS_VERSION, | |
1457 | redisGitSHA1(), atoi(redisGitDirty()) > 0); | |
1458 | exit(0); | |
1459 | } | |
1460 | ||
1461 | void usage() { | |
1462 | fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n"); | |
1463 | fprintf(stderr," ./redis-server - (read config from stdin)\n"); | |
1464 | exit(1); | |
1465 | } | |
1466 | ||
1467 | int main(int argc, char **argv) { | |
1468 | time_t start; | |
1469 | ||
1470 | initServerConfig(); | |
1471 | if (argc == 2) { | |
1472 | if (strcmp(argv[1], "-v") == 0 || | |
1473 | strcmp(argv[1], "--version") == 0) version(); | |
1474 | if (strcmp(argv[1], "--help") == 0) usage(); | |
1475 | resetServerSaveParams(); | |
1476 | loadServerConfig(argv[1]); | |
1477 | } else if ((argc > 2)) { | |
1478 | usage(); | |
1479 | } else { | |
1480 | 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'"); | |
1481 | } | |
1482 | if (server.daemonize) daemonize(); | |
1483 | initServer(); | |
1484 | if (server.daemonize) createPidFile(); | |
1485 | redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION); | |
1486 | #ifdef __linux__ | |
1487 | linuxOvercommitMemoryWarning(); | |
1488 | #endif | |
1489 | start = time(NULL); | |
1490 | if (server.appendonly) { | |
1491 | if (loadAppendOnlyFile(server.appendfilename) == REDIS_OK) | |
1492 | redisLog(REDIS_NOTICE,"DB loaded from append only file: %ld seconds",time(NULL)-start); | |
1493 | } else { | |
1494 | if (rdbLoad(server.dbfilename) == REDIS_OK) | |
1495 | redisLog(REDIS_NOTICE,"DB loaded from disk: %ld seconds",time(NULL)-start); | |
1496 | } | |
1497 | if (server.ipfd > 0) | |
1498 | redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port); | |
1499 | if (server.sofd > 0) | |
1500 | redisLog(REDIS_NOTICE,"The server is now ready to accept connections at %s", server.unixsocket); | |
1501 | aeSetBeforeSleepProc(server.el,beforeSleep); | |
1502 | aeMain(server.el); | |
1503 | aeDeleteEventLoop(server.el); | |
1504 | return 0; | |
1505 | } | |
1506 | ||
1507 | /* ============================= Backtrace support ========================= */ | |
1508 | ||
1509 | #ifdef HAVE_BACKTRACE | |
1510 | void *getMcontextEip(ucontext_t *uc) { | |
1511 | #if defined(__FreeBSD__) | |
1512 | return (void*) uc->uc_mcontext.mc_eip; | |
1513 | #elif defined(__dietlibc__) | |
1514 | return (void*) uc->uc_mcontext.eip; | |
1515 | #elif defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6) | |
1516 | #if __x86_64__ | |
1517 | return (void*) uc->uc_mcontext->__ss.__rip; | |
1518 | #else | |
1519 | return (void*) uc->uc_mcontext->__ss.__eip; | |
1520 | #endif | |
1521 | #elif defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6) | |
1522 | #if defined(_STRUCT_X86_THREAD_STATE64) && !defined(__i386__) | |
1523 | return (void*) uc->uc_mcontext->__ss.__rip; | |
1524 | #else | |
1525 | return (void*) uc->uc_mcontext->__ss.__eip; | |
1526 | #endif | |
1527 | #elif defined(__i386__) | |
1528 | return (void*) uc->uc_mcontext.gregs[14]; /* Linux 32 */ | |
1529 | #elif defined(__X86_64__) || defined(__x86_64__) | |
1530 | return (void*) uc->uc_mcontext.gregs[16]; /* Linux 64 */ | |
1531 | #elif defined(__ia64__) /* Linux IA64 */ | |
1532 | return (void*) uc->uc_mcontext.sc_ip; | |
1533 | #else | |
1534 | return NULL; | |
1535 | #endif | |
1536 | } | |
1537 | ||
1538 | void segvHandler(int sig, siginfo_t *info, void *secret) { | |
1539 | void *trace[100]; | |
1540 | char **messages = NULL; | |
1541 | int i, trace_size = 0; | |
1542 | ucontext_t *uc = (ucontext_t*) secret; | |
1543 | sds infostring; | |
1544 | struct sigaction act; | |
1545 | REDIS_NOTUSED(info); | |
1546 | ||
1547 | redisLog(REDIS_WARNING, | |
1548 | "======= Ooops! Redis %s got signal: -%d- =======", REDIS_VERSION, sig); | |
1549 | infostring = genRedisInfoString(); | |
1550 | redisLog(REDIS_WARNING, "%s",infostring); | |
1551 | /* It's not safe to sdsfree() the returned string under memory | |
1552 | * corruption conditions. Let it leak as we are going to abort */ | |
1553 | ||
1554 | trace_size = backtrace(trace, 100); | |
1555 | /* overwrite sigaction with caller's address */ | |
1556 | if (getMcontextEip(uc) != NULL) { | |
1557 | trace[1] = getMcontextEip(uc); | |
1558 | } | |
1559 | messages = backtrace_symbols(trace, trace_size); | |
1560 | ||
1561 | for (i=1; i<trace_size; ++i) | |
1562 | redisLog(REDIS_WARNING,"%s", messages[i]); | |
1563 | ||
1564 | /* free(messages); Don't call free() with possibly corrupted memory. */ | |
1565 | if (server.daemonize) unlink(server.pidfile); | |
1566 | ||
1567 | /* Make sure we exit with the right signal at the end. So for instance | |
1568 | * the core will be dumped if enabled. */ | |
1569 | sigemptyset (&act.sa_mask); | |
1570 | /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction | |
1571 | * is used. Otherwise, sa_handler is used */ | |
1572 | act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND; | |
1573 | act.sa_handler = SIG_DFL; | |
1574 | sigaction (sig, &act, NULL); | |
1575 | kill(getpid(),sig); | |
1576 | } | |
1577 | ||
1578 | void sigtermHandler(int sig) { | |
1579 | REDIS_NOTUSED(sig); | |
1580 | ||
1581 | redisLog(REDIS_WARNING,"SIGTERM received, scheduling shutting down..."); | |
1582 | server.shutdown_asap = 1; | |
1583 | } | |
1584 | ||
1585 | void setupSigSegvAction(void) { | |
1586 | struct sigaction act; | |
1587 | ||
1588 | sigemptyset (&act.sa_mask); | |
1589 | /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction | |
1590 | * is used. Otherwise, sa_handler is used */ | |
1591 | act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO; | |
1592 | act.sa_sigaction = segvHandler; | |
1593 | sigaction (SIGSEGV, &act, NULL); | |
1594 | sigaction (SIGBUS, &act, NULL); | |
1595 | sigaction (SIGFPE, &act, NULL); | |
1596 | sigaction (SIGILL, &act, NULL); | |
1597 | sigaction (SIGBUS, &act, NULL); | |
1598 | ||
1599 | act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND; | |
1600 | act.sa_handler = sigtermHandler; | |
1601 | sigaction (SIGTERM, &act, NULL); | |
1602 | return; | |
1603 | } | |
1604 | ||
1605 | #else /* HAVE_BACKTRACE */ | |
1606 | void setupSigSegvAction(void) { | |
1607 | } | |
1608 | #endif /* HAVE_BACKTRACE */ | |
1609 | ||
1610 | /* The End */ |