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