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