redis.c 121.5 KB
Newer Older
1
/*
2
 * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *   * Neither the name of Redis nor the names of its contributors may be used
 *     to endorse or promote products derived from this software without
 *     specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "redis.h"
31
#include "cluster.h"
32
#include "slowlog.h"
33
#include "bio.h"
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

#include <time.h>
#include <signal.h>
#include <sys/wait.h>
#include <errno.h>
#include <assert.h>
#include <ctype.h>
#include <stdarg.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/uio.h>
#include <limits.h>
#include <float.h>
#include <math.h>
51
#include <sys/resource.h>
52
#include <sys/utsname.h>
53
#include <locale.h>
54 55 56 57 58

/* Our shared "common" objects */

struct sharedObjectsStruct shared;

59
/* Global vars that are actually used as constants. The following double
60 61 62 63 64 65 66 67 68 69
 * values are used for double on-disk serialization, and are initialized
 * at runtime to avoid strange compiler optimizations. */

double R_Zero, R_PosInf, R_NegInf, R_Nan;

/*================================= Globals ================================= */

/* Global vars */
struct redisServer server; /* server global state */
struct redisCommand *commandTable;
70

71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
/* Our command table.
 *
 * Every entry is composed of the following fields:
 *
 * name: a string representing the command name.
 * function: pointer to the C function implementing the command.
 * arity: number of arguments, it is possible to use -N to say >= N
 * sflags: command flags as string. See below for a table of flags.
 * flags: flags as bitmask. Computed by Redis using the 'sflags' field.
 * get_keys_proc: an optional function to get key arguments from a command.
 *                This is only used when the following three fields are not
 *                enough to specify what arguments are keys.
 * first_key_index: first argument that is a key
 * last_key_index: last argument that is a key
 * key_step: step to get all the keys from first to last argument. For instance
 *           in MSET the step is two since arguments are key,val,key,val,...
 * microseconds: microseconds of total execution time for this command.
 * calls: total number of calls of this command.
 *
 * The flags, microseconds and calls fields are computed by Redis and should
 * always be set to zero.
 *
 * Command flags are expressed using strings where every character represents
 * a flag. Later the populateCommandTable() function will take care of
 * populating the real 'flags' field using this characters.
96 97 98 99 100 101 102 103
 *
 * This is the meaning of the flags:
 *
 * w: write command (may modify the key space).
 * r: read command  (will never modify the key space).
 * m: may increase memory usage once called. Don't allow if out of memory.
 * a: admin command, like SAVE or SHUTDOWN.
 * p: Pub/Sub related command.
G
guiquanz 已提交
104
 * f: force replication of this command, regardless of server.dirty.
105
 * s: command not allowed in scripts.
106
 * R: random command. Command is not deterministic, that is, the same command
107
 *    with the same arguments, with the same key space, may have different
108 109 110
 *    results. For instance SPOP and RANDOMKEY are two random commands.
 * S: Sort command output array if called from script, so that the output
 *    is deterministic.
111 112 113 114
 * l: Allow command while loading the database.
 * t: Allow command while a slave has stale data but is not allowed to
 *    server this data. Normally no command is accepted in this condition
 *    but just a few.
115
 * M: Do not automatically propagate the command on MONITOR.
116 117
 * k: Perform an implicit ASKING for this command, so the command will be
 *    accepted in cluster mode if the slot is marked as 'importing'.
118
 */
119
struct redisCommand redisCommandTable[] = {
120
    {"get",getCommand,2,"r",0,NULL,1,1,1,0,0},
121
    {"set",setCommand,-3,"wm",0,noPreloadGetKeys,1,1,1,0,0},
122
    {"setnx",setnxCommand,3,"wm",0,noPreloadGetKeys,1,1,1,0,0},
123 124
    {"setex",setexCommand,4,"wm",0,noPreloadGetKeys,1,1,1,0,0},
    {"psetex",psetexCommand,4,"wm",0,noPreloadGetKeys,1,1,1,0,0},
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
    {"append",appendCommand,3,"wm",0,NULL,1,1,1,0,0},
    {"strlen",strlenCommand,2,"r",0,NULL,1,1,1,0,0},
    {"del",delCommand,-2,"w",0,noPreloadGetKeys,1,-1,1,0,0},
    {"exists",existsCommand,2,"r",0,NULL,1,1,1,0,0},
    {"setbit",setbitCommand,4,"wm",0,NULL,1,1,1,0,0},
    {"getbit",getbitCommand,3,"r",0,NULL,1,1,1,0,0},
    {"setrange",setrangeCommand,4,"wm",0,NULL,1,1,1,0,0},
    {"getrange",getrangeCommand,4,"r",0,NULL,1,1,1,0,0},
    {"substr",getrangeCommand,4,"r",0,NULL,1,1,1,0,0},
    {"incr",incrCommand,2,"wm",0,NULL,1,1,1,0,0},
    {"decr",decrCommand,2,"wm",0,NULL,1,1,1,0,0},
    {"mget",mgetCommand,-2,"r",0,NULL,1,-1,1,0,0},
    {"rpush",rpushCommand,-3,"wm",0,NULL,1,1,1,0,0},
    {"lpush",lpushCommand,-3,"wm",0,NULL,1,1,1,0,0},
    {"rpushx",rpushxCommand,3,"wm",0,NULL,1,1,1,0,0},
    {"lpushx",lpushxCommand,3,"wm",0,NULL,1,1,1,0,0},
    {"linsert",linsertCommand,5,"wm",0,NULL,1,1,1,0,0},
    {"rpop",rpopCommand,2,"w",0,NULL,1,1,1,0,0},
    {"lpop",lpopCommand,2,"w",0,NULL,1,1,1,0,0},
A
antirez 已提交
144 145 146
    {"brpop",brpopCommand,-3,"ws",0,NULL,1,1,1,0,0},
    {"brpoplpush",brpoplpushCommand,4,"wms",0,NULL,1,2,1,0,0},
    {"blpop",blpopCommand,-3,"ws",0,NULL,1,-2,1,0,0},
147 148 149 150 151 152 153 154 155 156 157 158
    {"llen",llenCommand,2,"r",0,NULL,1,1,1,0,0},
    {"lindex",lindexCommand,3,"r",0,NULL,1,1,1,0,0},
    {"lset",lsetCommand,4,"wm",0,NULL,1,1,1,0,0},
    {"lrange",lrangeCommand,4,"r",0,NULL,1,1,1,0,0},
    {"ltrim",ltrimCommand,4,"w",0,NULL,1,1,1,0,0},
    {"lrem",lremCommand,4,"w",0,NULL,1,1,1,0,0},
    {"rpoplpush",rpoplpushCommand,3,"wm",0,NULL,1,2,1,0,0},
    {"sadd",saddCommand,-3,"wm",0,NULL,1,1,1,0,0},
    {"srem",sremCommand,-3,"w",0,NULL,1,1,1,0,0},
    {"smove",smoveCommand,4,"w",0,NULL,1,2,1,0,0},
    {"sismember",sismemberCommand,3,"r",0,NULL,1,1,1,0,0},
    {"scard",scardCommand,2,"r",0,NULL,1,1,1,0,0},
159
    {"spop",spopCommand,2,"wRs",0,NULL,1,1,1,0,0},
160
    {"srandmember",srandmemberCommand,-2,"rR",0,NULL,1,1,1,0,0},
161
    {"sinter",sinterCommand,-2,"rS",0,NULL,1,-1,1,0,0},
162
    {"sinterstore",sinterstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
163
    {"sunion",sunionCommand,-2,"rS",0,NULL,1,-1,1,0,0},
164
    {"sunionstore",sunionstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
165
    {"sdiff",sdiffCommand,-2,"rS",0,NULL,1,-1,1,0,0},
166
    {"sdiffstore",sdiffstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
167
    {"smembers",sinterCommand,2,"rS",0,NULL,1,1,1,0,0},
A
antirez 已提交
168
    {"sscan",sscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
    {"zadd",zaddCommand,-4,"wm",0,NULL,1,1,1,0,0},
    {"zincrby",zincrbyCommand,4,"wm",0,NULL,1,1,1,0,0},
    {"zrem",zremCommand,-3,"w",0,NULL,1,1,1,0,0},
    {"zremrangebyscore",zremrangebyscoreCommand,4,"w",0,NULL,1,1,1,0,0},
    {"zremrangebyrank",zremrangebyrankCommand,4,"w",0,NULL,1,1,1,0,0},
    {"zunionstore",zunionstoreCommand,-4,"wm",0,zunionInterGetKeys,0,0,0,0,0},
    {"zinterstore",zinterstoreCommand,-4,"wm",0,zunionInterGetKeys,0,0,0,0,0},
    {"zrange",zrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
    {"zrangebyscore",zrangebyscoreCommand,-4,"r",0,NULL,1,1,1,0,0},
    {"zrevrangebyscore",zrevrangebyscoreCommand,-4,"r",0,NULL,1,1,1,0,0},
    {"zcount",zcountCommand,4,"r",0,NULL,1,1,1,0,0},
    {"zrevrange",zrevrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
    {"zcard",zcardCommand,2,"r",0,NULL,1,1,1,0,0},
    {"zscore",zscoreCommand,3,"r",0,NULL,1,1,1,0,0},
    {"zrank",zrankCommand,3,"r",0,NULL,1,1,1,0,0},
    {"zrevrank",zrevrankCommand,3,"r",0,NULL,1,1,1,0,0},
A
antirez 已提交
185
    {"zscan",zscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
186 187 188 189 190 191
    {"hset",hsetCommand,4,"wm",0,NULL,1,1,1,0,0},
    {"hsetnx",hsetnxCommand,4,"wm",0,NULL,1,1,1,0,0},
    {"hget",hgetCommand,3,"r",0,NULL,1,1,1,0,0},
    {"hmset",hmsetCommand,-4,"wm",0,NULL,1,1,1,0,0},
    {"hmget",hmgetCommand,-3,"r",0,NULL,1,1,1,0,0},
    {"hincrby",hincrbyCommand,4,"wm",0,NULL,1,1,1,0,0},
A
antirez 已提交
192
    {"hincrbyfloat",hincrbyfloatCommand,4,"wm",0,NULL,1,1,1,0,0},
193 194
    {"hdel",hdelCommand,-3,"w",0,NULL,1,1,1,0,0},
    {"hlen",hlenCommand,2,"r",0,NULL,1,1,1,0,0},
195 196
    {"hkeys",hkeysCommand,2,"rS",0,NULL,1,1,1,0,0},
    {"hvals",hvalsCommand,2,"rS",0,NULL,1,1,1,0,0},
197 198
    {"hgetall",hgetallCommand,2,"r",0,NULL,1,1,1,0,0},
    {"hexists",hexistsCommand,3,"r",0,NULL,1,1,1,0,0},
A
antirez 已提交
199
    {"hscan",hscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
200 201
    {"incrby",incrbyCommand,3,"wm",0,NULL,1,1,1,0,0},
    {"decrby",decrbyCommand,3,"wm",0,NULL,1,1,1,0,0},
A
antirez 已提交
202
    {"incrbyfloat",incrbyfloatCommand,3,"wm",0,NULL,1,1,1,0,0},
203 204 205
    {"getset",getsetCommand,3,"wm",0,NULL,1,1,1,0,0},
    {"mset",msetCommand,-3,"wm",0,NULL,1,-1,2,0,0},
    {"msetnx",msetnxCommand,-3,"wm",0,NULL,1,-1,2,0,0},
206
    {"randomkey",randomkeyCommand,1,"rR",0,NULL,0,0,0,0,0},
A
antirez 已提交
207
    {"select",selectCommand,2,"rl",0,NULL,0,0,0,0,0},
208 209 210
    {"move",moveCommand,3,"w",0,NULL,1,1,1,0,0},
    {"rename",renameCommand,3,"w",0,renameGetKeys,1,2,1,0,0},
    {"renamenx",renamenxCommand,3,"w",0,renameGetKeys,1,2,1,0,0},
211 212 213 214
    {"expire",expireCommand,3,"w",0,NULL,1,1,1,0,0},
    {"expireat",expireatCommand,3,"w",0,NULL,1,1,1,0,0},
    {"pexpire",pexpireCommand,3,"w",0,NULL,1,1,1,0,0},
    {"pexpireat",pexpireatCommand,3,"w",0,NULL,1,1,1,0,0},
215
    {"keys",keysCommand,2,"rS",0,NULL,0,0,0,0,0},
216
    {"scan",scanCommand,-2,"rR",0,NULL,0,0,0,0,0},
217
    {"dbsize",dbsizeCommand,1,"r",0,NULL,0,0,0,0,0},
218 219
    {"auth",authCommand,2,"rslt",0,NULL,0,0,0,0,0},
    {"ping",pingCommand,1,"rt",0,NULL,0,0,0,0,0},
220
    {"echo",echoCommand,2,"r",0,NULL,0,0,0,0,0},
A
antirez 已提交
221
    {"save",saveCommand,1,"ars",0,NULL,0,0,0,0,0},
222 223
    {"bgsave",bgsaveCommand,1,"ar",0,NULL,0,0,0,0,0},
    {"bgrewriteaof",bgrewriteaofCommand,1,"ar",0,NULL,0,0,0,0,0},
224
    {"shutdown",shutdownCommand,-1,"arlt",0,NULL,0,0,0,0,0},
A
antirez 已提交
225
    {"lastsave",lastsaveCommand,1,"rR",0,NULL,0,0,0,0,0},
226
    {"type",typeCommand,2,"r",0,NULL,1,1,1,0,0},
227
    {"multi",multiCommand,1,"rs",0,NULL,0,0,0,0,0},
228
    {"exec",execCommand,1,"sM",0,NULL,0,0,0,0,0},
229 230
    {"discard",discardCommand,1,"rs",0,NULL,0,0,0,0,0},
    {"sync",syncCommand,1,"ars",0,NULL,0,0,0,0,0},
231
    {"psync",syncCommand,3,"ars",0,NULL,0,0,0,0,0},
A
antirez 已提交
232
    {"replconf",replconfCommand,-1,"arslt",0,NULL,0,0,0,0,0},
233 234
    {"flushdb",flushdbCommand,1,"w",0,NULL,0,0,0,0,0},
    {"flushall",flushallCommand,1,"w",0,NULL,0,0,0,0,0},
235
    {"sort",sortCommand,-2,"wm",0,NULL,1,1,1,0,0},
236
    {"info",infoCommand,-1,"rlt",0,NULL,0,0,0,0,0},
237
    {"monitor",monitorCommand,1,"ars",0,NULL,0,0,0,0,0},
238 239
    {"ttl",ttlCommand,2,"r",0,NULL,1,1,1,0,0},
    {"pttl",pttlCommand,2,"r",0,NULL,1,1,1,0,0},
240
    {"persist",persistCommand,2,"w",0,NULL,1,1,1,0,0},
241
    {"slaveof",slaveofCommand,3,"ast",0,NULL,0,0,0,0,0},
242
    {"debug",debugCommand,-2,"as",0,NULL,0,0,0,0,0},
243
    {"config",configCommand,-2,"art",0,NULL,0,0,0,0,0},
244 245 246 247
    {"subscribe",subscribeCommand,-2,"rpslt",0,NULL,0,0,0,0,0},
    {"unsubscribe",unsubscribeCommand,-1,"rpslt",0,NULL,0,0,0,0,0},
    {"psubscribe",psubscribeCommand,-2,"rpslt",0,NULL,0,0,0,0,0},
    {"punsubscribe",punsubscribeCommand,-1,"rpslt",0,NULL,0,0,0,0,0},
A
antirez 已提交
248
    {"publish",publishCommand,3,"pltr",0,NULL,0,0,0,0,0},
A
antirez 已提交
249
    {"pubsub",pubsubCommand,-2,"pltrR",0,NULL,0,0,0,0,0},
250 251
    {"watch",watchCommand,-2,"rs",0,noPreloadGetKeys,1,-1,1,0,0},
    {"unwatch",unwatchCommand,1,"rs",0,NULL,0,0,0,0,0},
252
    {"cluster",clusterCommand,-2,"ar",0,NULL,0,0,0,0,0},
A
antirez 已提交
253
    {"restore",restoreCommand,-4,"awm",0,NULL,1,1,1,0,0},
254
    {"restore-asking",restoreCommand,-4,"awmk",0,NULL,1,1,1,0,0},
A
antirez 已提交
255
    {"migrate",migrateCommand,-6,"aw",0,NULL,0,0,0,0,0},
256
    {"asking",askingCommand,1,"r",0,NULL,0,0,0,0,0},
257 258
    {"readonly",readonlyCommand,1,"r",0,NULL,0,0,0,0,0},
    {"readwrite",readwriteCommand,1,"r",0,NULL,0,0,0,0,0},
259 260
    {"dump",dumpCommand,2,"ar",0,NULL,1,1,1,0,0},
    {"object",objectCommand,-2,"r",0,NULL,2,2,2,0,0},
261
    {"client",clientCommand,-2,"ar",0,NULL,0,0,0,0,0},
262 263
    {"eval",evalCommand,-3,"s",0,zunionInterGetKeys,0,0,0,0,0},
    {"evalsha",evalShaCommand,-3,"s",0,zunionInterGetKeys,0,0,0,0,0},
264
    {"slowlog",slowlogCommand,-2,"r",0,NULL,0,0,0,0,0},
A
antirez 已提交
265
    {"script",scriptCommand,-2,"ras",0,NULL,0,0,0,0,0},
A
antirez 已提交
266 267
    {"time",timeCommand,1,"rR",0,NULL,0,0,0,0,0},
    {"bitop",bitopCommand,-4,"wm",0,NULL,2,-1,1,0,0},
268 269
    {"bitcount",bitcountCommand,-2,"r",0,NULL,1,1,1,0,0},
    {"wait",waitCommand,3,"rs",0,NULL,0,0,0,0,0}
270 271 272 273
};

/*============================ Utility functions ============================ */

274 275 276
/* Low level logging. To use only for very big messages, otherwise
 * redisLog() is to prefer. */
void redisLogRaw(int level, const char *msg) {
J
Jonah H. Harris 已提交
277 278
    const int syslogLevelMap[] = { LOG_DEBUG, LOG_INFO, LOG_NOTICE, LOG_WARNING };
    const char *c = ".-*#";
279
    FILE *fp;
280
    char buf[64];
A
antirez 已提交
281
    int rawmode = (level & REDIS_LOG_RAW);
282
    int log_to_stdout = server.logfile[0] == '\0';
283

A
antirez 已提交
284
    level &= 0xff; /* clear flags */
285
    if (level < server.verbosity) return;
286

287
    fp = log_to_stdout ? stdout : fopen(server.logfile,"a");
288 289
    if (!fp) return;

A
antirez 已提交
290 291 292
    if (rawmode) {
        fprintf(fp,"%s",msg);
    } else {
293 294 295 296 297 298
        int off;
        struct timeval tv;

        gettimeofday(&tv,NULL);
        off = strftime(buf,sizeof(buf),"%d %b %H:%M:%S.",localtime(&tv.tv_sec));
        snprintf(buf+off,sizeof(buf)-off,"%03d",(int)tv.tv_usec/1000);
A
antirez 已提交
299 300
        fprintf(fp,"[%d] %s %c %s\n",(int)getpid(),buf,c[level],msg);
    }
J
Jonah H. Harris 已提交
301 302
    fflush(fp);

303
    if (!log_to_stdout) fclose(fp);
J
Jonah H. Harris 已提交
304
    if (server.syslog_enabled) syslog(syslogLevelMap[level], "%s", msg);
305 306
}

G
guiquanz 已提交
307
/* Like redisLogRaw() but with printf-alike support. This is the function that
308 309 310 311 312 313
 * is used across the code. The raw version is only used in order to dump
 * the INFO output on crash. */
void redisLog(int level, const char *fmt, ...) {
    va_list ap;
    char msg[REDIS_MAX_LOGMSG_LEN];

A
antirez 已提交
314
    if ((level&0xff) < server.verbosity) return;
315 316 317 318 319 320 321 322

    va_start(ap, fmt);
    vsnprintf(msg, sizeof(msg), fmt, ap);
    va_end(ap);

    redisLogRaw(level,msg);
}

A
antirez 已提交
323 324 325 326 327 328 329 330
/* Log a fixed message without printf-alike capabilities, in a way that is
 * safe to call from a signal handler.
 *
 * We actually use this only for signals that are not fatal from the point
 * of view of Redis. Signals that are going to kill the server anyway and
 * where we need printf-alike features are served by redisLog(). */
void redisLogFromHandler(int level, const char *msg) {
    int fd;
331
    int log_to_stdout = server.logfile[0] == '\0';
A
antirez 已提交
332 333
    char buf[64];

334 335 336 337
    if ((level&0xff) < server.verbosity || (log_to_stdout && server.daemonize))
        return;
    fd = log_to_stdout ? STDOUT_FILENO : 
                         open(server.logfile, O_APPEND|O_CREAT|O_WRONLY, 0644);
A
antirez 已提交
338 339
    if (fd == -1) return;
    ll2string(buf,sizeof(buf),getpid());
340 341 342
    if (write(fd,"[",1) == -1) goto err;
    if (write(fd,buf,strlen(buf)) == -1) goto err;
    if (write(fd," | signal handler] (",20) == -1) goto err;
A
antirez 已提交
343
    ll2string(buf,sizeof(buf),time(NULL));
344 345 346 347 348
    if (write(fd,buf,strlen(buf)) == -1) goto err;
    if (write(fd,") ",2) == -1) goto err;
    if (write(fd,msg,strlen(msg)) == -1) goto err;
    if (write(fd,"\n",1) == -1) goto err;
err:
349
    if (!log_to_stdout) close(fd);
A
antirez 已提交
350 351
}

A
antirez 已提交
352 353 354 355 356 357 358 359 360 361 362
/* Return the UNIX time in microseconds */
long long ustime(void) {
    struct timeval tv;
    long long ust;

    gettimeofday(&tv, NULL);
    ust = ((long long)tv.tv_sec)*1000000;
    ust += tv.tv_usec;
    return ust;
}

363 364 365 366 367
/* Return the UNIX time in milliseconds */
long long mstime(void) {
    return ustime()/1000;
}

368 369 370 371 372 373 374 375 376 377 378 379
/* After an RDB dump or AOF rewrite we exit from children using _exit() instead of
 * exit(), because the latter may interact with the same file objects used by
 * the parent process. However if we are testing the coverage normal exit() is
 * used in order to obtain the right coverage information. */
void exitFromChild(int retcode) {
#ifdef COVERAGE_TEST
    exit(retcode);
#else
    _exit(retcode);
#endif
}

380 381
/*====================== Hash table type implementation  ==================== */

382
/* This is a hash table type that uses the SDS dynamic strings library as
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
 * keys and radis objects as values (objects can hold SDS strings,
 * lists, sets). */

void dictVanillaFree(void *privdata, void *val)
{
    DICT_NOTUSED(privdata);
    zfree(val);
}

void dictListDestructor(void *privdata, void *val)
{
    DICT_NOTUSED(privdata);
    listRelease((list*)val);
}

int dictSdsKeyCompare(void *privdata, const void *key1,
        const void *key2)
{
    int l1,l2;
    DICT_NOTUSED(privdata);

    l1 = sdslen((sds)key1);
    l2 = sdslen((sds)key2);
    if (l1 != l2) return 0;
    return memcmp(key1, key2, l1) == 0;
}

A
antirez 已提交
410 411
/* A case insensitive version used for the command lookup table and other
 * places where case insensitive non binary-safe comparison is needed. */
412 413 414 415 416 417 418 419
int dictSdsKeyCaseCompare(void *privdata, const void *key1,
        const void *key2)
{
    DICT_NOTUSED(privdata);

    return strcasecmp(key1, key2) == 0;
}

420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
void dictRedisObjectDestructor(void *privdata, void *val)
{
    DICT_NOTUSED(privdata);

    if (val == NULL) return; /* Values of swapped out keys as set to NULL */
    decrRefCount(val);
}

void dictSdsDestructor(void *privdata, void *val)
{
    DICT_NOTUSED(privdata);

    sdsfree(val);
}

int dictObjKeyCompare(void *privdata, const void *key1,
        const void *key2)
{
    const robj *o1 = key1, *o2 = key2;
    return dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
}

unsigned int dictObjHash(const void *key) {
    const robj *o = key;
    return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
}

unsigned int dictSdsHash(const void *key) {
    return dictGenHashFunction((unsigned char*)key, sdslen((char*)key));
}

451 452 453 454
unsigned int dictSdsCaseHash(const void *key) {
    return dictGenCaseHashFunction((unsigned char*)key, sdslen((char*)key));
}

455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
int dictEncObjKeyCompare(void *privdata, const void *key1,
        const void *key2)
{
    robj *o1 = (robj*) key1, *o2 = (robj*) key2;
    int cmp;

    if (o1->encoding == REDIS_ENCODING_INT &&
        o2->encoding == REDIS_ENCODING_INT)
            return o1->ptr == o2->ptr;

    o1 = getDecodedObject(o1);
    o2 = getDecodedObject(o2);
    cmp = dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
    decrRefCount(o1);
    decrRefCount(o2);
    return cmp;
}

unsigned int dictEncObjHash(const void *key) {
    robj *o = (robj*) key;

476
    if (sdsEncodedObject(o)) {
477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
        return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
    } else {
        if (o->encoding == REDIS_ENCODING_INT) {
            char buf[32];
            int len;

            len = ll2string(buf,32,(long)o->ptr);
            return dictGenHashFunction((unsigned char*)buf, len);
        } else {
            unsigned int hash;

            o = getDecodedObject(o);
            hash = dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
            decrRefCount(o);
            return hash;
        }
    }
}

496
/* Sets type hash table */
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
dictType setDictType = {
    dictEncObjHash,            /* hash function */
    NULL,                      /* key dup */
    NULL,                      /* val dup */
    dictEncObjKeyCompare,      /* key compare */
    dictRedisObjectDestructor, /* key destructor */
    NULL                       /* val destructor */
};

/* Sorted sets hash (note: a skiplist is used in addition to the hash table) */
dictType zsetDictType = {
    dictEncObjHash,            /* hash function */
    NULL,                      /* key dup */
    NULL,                      /* val dup */
    dictEncObjKeyCompare,      /* key compare */
    dictRedisObjectDestructor, /* key destructor */
513
    NULL                       /* val destructor */
514 515 516 517 518 519 520 521 522 523 524 525
};

/* Db->dict, keys are sds strings, vals are Redis objects. */
dictType dbDictType = {
    dictSdsHash,                /* hash function */
    NULL,                       /* key dup */
    NULL,                       /* val dup */
    dictSdsKeyCompare,          /* key compare */
    dictSdsDestructor,          /* key destructor */
    dictRedisObjectDestructor   /* val destructor */
};

A
antirez 已提交
526 527 528 529 530 531 532 533 534 535
/* server.lua_scripts sha (as sds string) -> scripts (as robj) cache. */
dictType shaScriptObjectDictType = {
    dictSdsCaseHash,            /* hash function */
    NULL,                       /* key dup */
    NULL,                       /* val dup */
    dictSdsKeyCaseCompare,      /* key compare */
    dictSdsDestructor,          /* key destructor */
    dictRedisObjectDestructor   /* val destructor */
};

536 537 538 539 540 541 542 543 544 545
/* Db->expires */
dictType keyptrDictType = {
    dictSdsHash,               /* hash function */
    NULL,                      /* key dup */
    NULL,                      /* val dup */
    dictSdsKeyCompare,         /* key compare */
    NULL,                      /* key destructor */
    NULL                       /* val destructor */
};

546 547 548 549 550 551 552 553 554 555
/* Command table. sds string -> command struct pointer. */
dictType commandTableDictType = {
    dictSdsCaseHash,           /* hash function */
    NULL,                      /* key dup */
    NULL,                      /* val dup */
    dictSdsKeyCaseCompare,     /* key compare */
    dictSdsDestructor,         /* key destructor */
    NULL                       /* val destructor */
};

556
/* Hash type hash table (note that small hashes are represented with ziplists) */
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
dictType hashDictType = {
    dictEncObjHash,             /* hash function */
    NULL,                       /* key dup */
    NULL,                       /* val dup */
    dictEncObjKeyCompare,       /* key compare */
    dictRedisObjectDestructor,  /* key destructor */
    dictRedisObjectDestructor   /* val destructor */
};

/* Keylist hash table type has unencoded redis objects as keys and
 * lists as values. It's used for blocking operations (BLPOP) and to
 * map swapped keys to a list of clients waiting for this keys to be loaded. */
dictType keylistDictType = {
    dictObjHash,                /* hash function */
    NULL,                       /* key dup */
    NULL,                       /* val dup */
    dictObjKeyCompare,          /* key compare */
    dictRedisObjectDestructor,  /* key destructor */
    dictListDestructor          /* val destructor */
};

A
antirez 已提交
578 579 580 581 582 583 584 585 586 587 588
/* Cluster nodes hash table, mapping nodes addresses 1.2.3.4:6379 to
 * clusterNode structures. */
dictType clusterNodesDictType = {
    dictSdsHash,                /* hash function */
    NULL,                       /* key dup */
    NULL,                       /* val dup */
    dictSdsKeyCompare,          /* key compare */
    dictSdsDestructor,          /* key destructor */
    NULL                        /* val destructor */
};

589 590 591 592 593 594 595 596 597 598 599 600
/* Cluster re-addition blacklist. This maps node IDs to the time
 * we can re-add this node. The goal is to avoid readding a removed
 * node for some time. */
dictType clusterNodesBlackListDictType = {
    dictSdsCaseHash,            /* hash function */
    NULL,                       /* key dup */
    NULL,                       /* val dup */
    dictSdsKeyCaseCompare,      /* key compare */
    dictSdsDestructor,          /* key destructor */
    NULL                        /* val destructor */
};

A
antirez 已提交
601 602 603 604 605 606 607 608 609 610
/* Migrate cache dict type. */
dictType migrateCacheDictType = {
    dictSdsHash,                /* hash function */
    NULL,                       /* key dup */
    NULL,                       /* val dup */
    dictSdsKeyCompare,          /* key compare */
    dictSdsDestructor,          /* key destructor */
    NULL                        /* val destructor */
};

611 612 613 614
/* Replication cached script dict (server.repl_scriptcache_dict).
 * Keys are sds SHA1 strings, while values are not used at all in the current
 * implementation. */
dictType replScriptCacheDictType = {
615
    dictSdsCaseHash,            /* hash function */
616 617
    NULL,                       /* key dup */
    NULL,                       /* val dup */
618
    dictSdsKeyCaseCompare,      /* key compare */
619 620 621 622
    dictSdsDestructor,          /* key destructor */
    NULL                        /* val destructor */
};

623 624 625 626 627 628 629 630 631 632 633
int htNeedsResize(dict *dict) {
    long long size, used;

    size = dictSlots(dict);
    used = dictSize(dict);
    return (size && used && size > DICT_HT_INITIAL_SIZE &&
            (used*100/size < REDIS_HT_MINFILL));
}

/* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
 * we resize the hash table to save memory */
634 635 636 637 638
void tryResizeHashTables(int dbid) {
    if (htNeedsResize(server.db[dbid].dict))
        dictResize(server.db[dbid].dict);
    if (htNeedsResize(server.db[dbid].expires))
        dictResize(server.db[dbid].expires);
639 640 641 642 643
}

/* Our hash table implementation performs rehashing incrementally while
 * we write/read from the hash table. Still if the server is idle, the hash
 * table will use two tables for a long time. So we try to use 1 millisecond
644 645 646 647 648 649 650 651 652 653 654 655 656 657
 * of CPU time at every call of this function to perform some rehahsing.
 *
 * The function returns 1 if some rehashing was performed, otherwise 0
 * is returned. */
int incrementallyRehash(int dbid) {
    /* Keys dictionary */
    if (dictIsRehashing(server.db[dbid].dict)) {
        dictRehashMilliseconds(server.db[dbid].dict,1);
        return 1; /* already used our millisecond for this loop... */
    }
    /* Expires */
    if (dictIsRehashing(server.db[dbid].expires)) {
        dictRehashMilliseconds(server.db[dbid].expires,1);
        return 1; /* already used our millisecond for this loop... */
658
    }
659
    return 0;
660 661 662 663 664 665 666 667 668
}

/* This function is called once a background process of some kind terminates,
 * as we want to avoid resizing the hash tables when there is a child in order
 * to play well with copy-on-write (otherwise when a resize happens lots of
 * memory pages are copied). The goal of this function is to update the ability
 * for dict.c to resize the hash tables accordingly to the fact we have o not
 * running childs. */
void updateDictResizePolicy(void) {
A
antirez 已提交
669
    if (server.rdb_child_pid == -1 && server.aof_child_pid == -1)
670 671 672 673 674 675 676
        dictEnableResize();
    else
        dictDisableResize();
}

/* ======================= Cron: called every 100 ms ======================== */

677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
/* Helper function for the activeExpireCycle() function.
 * This function will try to expire the key that is stored in the hash table
 * entry 'de' of the 'expires' hash table of a Redis database.
 *
 * If the key is found to be expired, it is removed from the database and
 * 1 is returned. Otherwise no operation is performed and 0 is returned.
 *
 * When a key is expired, server.stat_expiredkeys is incremented.
 *
 * The parameter 'now' is the current time in milliseconds as is passed
 * to the function to avoid too many gettimeofday() syscalls. */
int activeExpireCycleTryExpire(redisDb *db, struct dictEntry *de, long long now) {
    long long t = dictGetSignedIntegerVal(de);
    if (now > t) {
        sds key = dictGetKey(de);
        robj *keyobj = createStringObject(key,sdslen(key));

        propagateExpire(db,keyobj);
        dbDelete(db,keyobj);
        notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED,
            "expired",keyobj,db->id);
        decrRefCount(keyobj);
        server.stat_expiredkeys++;
        return 1;
    } else {
        return 0;
    }
}

706 707 708
/* Try to expire a few timed out keys. The algorithm used is adaptive and
 * will use few CPU cycles if there are few expiring keys, otherwise
 * it will get more aggressive to avoid that too much memory is used by
709 710
 * keys that can be removed from the keyspace.
 *
711
 * No more than REDIS_DBCRON_DBS_PER_CALL databases are tested at every
712 713
 * iteration.
 *
714 715
 * This kind of call is used when Redis detects that timelimit_exit is
 * true, so there is more work to do, and we do it more incrementally from
A
antirez 已提交
716 717 718 719 720 721 722 723 724 725 726
 * the beforeSleep() function of the event loop.
 *
 * Expire cycle type:
 *
 * If type is ACTIVE_EXPIRE_CYCLE_FAST the function will try to run a
 * "fast" expire cycle that takes no longer than EXPIRE_FAST_CYCLE_DURATION
 * microseconds, and is not repeated again before the same amount of time.
 *
 * If type is ACTIVE_EXPIRE_CYCLE_SLOW, that normal expire cycle is
 * executed, where the time limit is a percentage of the REDIS_HZ period
 * as specified by the REDIS_EXPIRELOOKUPS_TIME_PERC define. */
727

A
antirez 已提交
728
void activeExpireCycle(int type) {
729 730 731 732
    /* This function has some global state in order to continue the work
     * incrementally across calls. */
    static unsigned int current_db = 0; /* Last DB tested. */
    static int timelimit_exit = 0;      /* Time limit hit in previous call? */
A
antirez 已提交
733
    static long long last_fast_cycle = 0; /* When last fast cycle ran. */
734

735
    unsigned int j, iteration = 0;
736
    unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL;
737
    long long start = ustime(), timelimit;
738

A
antirez 已提交
739
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
740 741 742 743
        /* Don't start a fast cycle if the previous cycle did not exited
         * for time limt. Also don't repeat a fast cycle for the same period
         * as the fast cycle total duration itself. */
        if (!timelimit_exit) return;
744
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
745 746
        last_fast_cycle = start;
    }
747

748 749 750 751 752 753 754 755 756
    /* We usually should test REDIS_DBCRON_DBS_PER_CALL per iteration, with
     * two exceptions:
     *
     * 1) Don't test more DBs than we have.
     * 2) If last time we hit the time limit, we want to scan all DBs
     * in this iteration, as there is work to do in some DB and we don't want
     * expired keys to use memory for too much time. */
    if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;
757

A
antirez 已提交
758
    /* We can use at max ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC percentage of CPU time
759
     * per iteration. Since this function gets called with a frequency of
760
     * server.hz times per second, the following is the max amount of
761
     * microseconds we can spend in this function. */
A
antirez 已提交
762
    timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
763
    timelimit_exit = 0;
764
    if (timelimit <= 0) timelimit = 1;
765

A
antirez 已提交
766 767
    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* in microseconds. */
768

769
    for (j = 0; j < dbs_per_call; j++) {
770
        int expired;
771 772 773 774 775 776
        redisDb *db = server.db+(current_db % server.dbnum);

        /* Increment the DB now so we are sure if we run out of time
         * in the current DB we'll restart from the next. This allows to
         * distribute the time evenly across DBs. */
        current_db++;
777 778 779 780

        /* Continue to expire if at the end of the cycle more than 25%
         * of the keys were expired. */
        do {
781
            unsigned long num, slots;
782 783
            long long now, ttl_sum;
            int ttl_samples;
784 785

            /* If there is nothing to expire try next DB ASAP. */
786 787 788 789
            if ((num = dictSize(db->expires)) == 0) {
                db->avg_ttl = 0;
                break;
            }
790 791
            slots = dictSlots(db->expires);
            now = mstime();
792

793 794 795 796 797 798
            /* When there are less than 1% filled slots getting random
             * keys is expensive, so stop here waiting for better times...
             * The dictionary will be resized asap. */
            if (num && slots > DICT_HT_INITIAL_SIZE &&
                (num*100/slots < 1)) break;

799 800
            /* The main collection cycle. Sample random keys among keys
             * with an expire set, checking for expired ones. */
801
            expired = 0;
802 803 804
            ttl_sum = 0;
            ttl_samples = 0;

A
antirez 已提交
805 806
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
807

808 809
            while (num--) {
                dictEntry *de;
810
                long long ttl;
811 812

                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
813
                ttl = dictGetSignedIntegerVal(de)-now;
814
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
815 816 817
                if (ttl < 0) ttl = 0;
                ttl_sum += ttl;
                ttl_samples++;
818
            }
819 820 821 822 823 824 825 826 827 828

            /* Update the average TTL stats for this database. */
            if (ttl_samples) {
                long long avg_ttl = ttl_sum/ttl_samples;

                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                /* Smooth the value averaging with the previous one. */
                db->avg_ttl = (db->avg_ttl+avg_ttl)/2;
            }

829 830 831 832
            /* We can't block forever here even if there are many keys to
             * expire. So after a given amount of milliseconds return to the
             * caller waiting for the other active expire cycle. */
            iteration++;
833
            if ((iteration & 0xf) == 0 && /* check once every 16 iterations. */
834 835 836 837
                (ustime()-start) > timelimit)
            {
                timelimit_exit = 1;
            }
838
            if (timelimit_exit) return;
A
antirez 已提交
839 840 841
            /* We don't repeat the cycle if there are less than 25% of keys
             * found expired in the current DB. */
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
842 843 844
    }
}

845
void updateLRUClock(void) {
846
    server.lruclock = (server.unixtime/REDIS_LRU_CLOCK_RESOLUTION) &
847 848
                                                REDIS_LRU_CLOCK_MAX;
}
849

850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874

/* Add a sample to the operations per second array of samples. */
void trackOperationsPerSecond(void) {
    long long t = mstime() - server.ops_sec_last_sample_time;
    long long ops = server.stat_numcommands - server.ops_sec_last_sample_ops;
    long long ops_sec;

    ops_sec = t > 0 ? (ops*1000/t) : 0;

    server.ops_sec_samples[server.ops_sec_idx] = ops_sec;
    server.ops_sec_idx = (server.ops_sec_idx+1) % REDIS_OPS_SEC_SAMPLES;
    server.ops_sec_last_sample_time = mstime();
    server.ops_sec_last_sample_ops = server.stat_numcommands;
}

/* Return the mean of all the samples. */
long long getOperationsPerSecond(void) {
    int j;
    long long sum = 0;

    for (j = 0; j < REDIS_OPS_SEC_SAMPLES; j++)
        sum += server.ops_sec_samples[j];
    return sum / REDIS_OPS_SEC_SAMPLES;
}

A
antirez 已提交
875 876
/* Check for timeouts. Returns non-zero if the client was terminated */
int clientsCronHandleTimeout(redisClient *c) {
A
antirez 已提交
877
    time_t now = server.unixtime;
878 879 880 881 882 883 884 885 886 887 888

    if (server.maxidletime &&
        !(c->flags & REDIS_SLAVE) &&    /* no timeout for slaves */
        !(c->flags & REDIS_MASTER) &&   /* no timeout for masters */
        !(c->flags & REDIS_BLOCKED) &&  /* no timeout for BLPOP */
        dictSize(c->pubsub_channels) == 0 && /* no timeout for pubsub */
        listLength(c->pubsub_patterns) == 0 &&
        (now - c->lastinteraction > server.maxidletime))
    {
        redisLog(REDIS_VERBOSE,"Closing idle client");
        freeClient(c);
A
antirez 已提交
889
        return 1;
890
    } else if (c->flags & REDIS_BLOCKED) {
A
antirez 已提交
891 892 893 894 895 896
        /* Blocked OPS timeout is handled with milliseconds resolution.
         * However note that the actual resolution is limited by
         * server.hz. */
        mstime_t now_ms = mstime();

        if (c->bpop.timeout != 0 && c->bpop.timeout < now_ms) {
897 898
            replyToBlockedClientTimedOut(c);
            unblockClient(c);
899 900
        }
    }
A
antirez 已提交
901
    return 0;
902 903
}

904
/* The client query buffer is an sds.c string that can end with a lot of
A
antirez 已提交
905 906
 * free space not used, this function reclaims space if needed.
 *
G
guiquanz 已提交
907
 * The function always returns 0 as it never terminates the client. */
A
antirez 已提交
908
int clientsCronResizeQueryBuffer(redisClient *c) {
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
    size_t querybuf_size = sdsAllocSize(c->querybuf);
    time_t idletime = server.unixtime - c->lastinteraction;

    /* There are two conditions to resize the query buffer:
     * 1) Query buffer is > BIG_ARG and too big for latest peak.
     * 2) Client is inactive and the buffer is bigger than 1k. */
    if (((querybuf_size > REDIS_MBULK_BIG_ARG) &&
         (querybuf_size/(c->querybuf_peak+1)) > 2) ||
         (querybuf_size > 1024 && idletime > 2))
    {
        /* Only resize the query buffer if it is actually wasting space. */
        if (sdsavail(c->querybuf) > 1024) {
            c->querybuf = sdsRemoveFreeSpace(c->querybuf);
        }
    }
    /* Reset the peak again to capture the peak memory usage in the next
     * cycle. */
    c->querybuf_peak = 0;
A
antirez 已提交
927
    return 0;
928 929
}

930
void clientsCron(void) {
931 932
    /* Make sure to process at least 1/(server.hz*10) of clients per call.
     * Since this function is called server.hz times per second we are sure that
933 934 935
     * in the worst case we process all the clients in 10 seconds.
     * In normal conditions (a reasonable number of clients) we process
     * all the clients in a shorter time. */
936
    int numclients = listLength(server.clients);
937
    int iterations = numclients/(server.hz*10);
938

939 940
    if (iterations < 50)
        iterations = (numclients < 50) ? numclients : 50;
941 942 943 944 945 946 947 948 949 950
    while(listLength(server.clients) && iterations--) {
        redisClient *c;
        listNode *head;

        /* Rotate the list, take the current head, process.
         * This way if the client must be removed from the list it's the
         * first element and we don't incur into O(N) computation. */
        listRotate(server.clients);
        head = listFirst(server.clients);
        c = listNodeValue(head);
A
antirez 已提交
951 952 953 954 955
        /* The following functions do different service checks on the client.
         * The protocol is that they return non-zero if the client was
         * terminated. */
        if (clientsCronHandleTimeout(c)) continue;
        if (clientsCronResizeQueryBuffer(c)) continue;
956 957 958
    }
}

959 960 961 962
/* This function handles 'background' operations we are required to do
 * incrementally in Redis databases, such as active key expiring, resizing,
 * rehashing. */
void databasesCron(void) {
963 964
    /* Expire keys by random sampling. Not required for slaves
     * as master will synthesize DELs for us. */
965
    if (server.active_expire_enabled && server.masterhost == NULL)
A
antirez 已提交
966
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
967

968 969 970
    /* Perform hash tables rehashing if needed, but only if there are no
     * other processes saving the DB on disk. Otherwise rehashing is bad
     * as will cause a lot of copy-on-write of memory pages. */
971
    if (server.rdb_child_pid == -1 && server.aof_child_pid == -1) {
972 973 974
        /* We use global counters so if we stop the computation at a given
         * DB we'll be able to start from the successive in the next
         * cron loop iteration. */
975 976
        static unsigned int resize_db = 0;
        static unsigned int rehash_db = 0;
977
        unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL;
978
        unsigned int j;
979

980 981 982
        /* Don't test more DBs than we have. */
        if (dbs_per_call > server.dbnum) dbs_per_call = server.dbnum;

983
        /* Resize */
984
        for (j = 0; j < dbs_per_call; j++) {
985 986 987 988 989 990
            tryResizeHashTables(resize_db % server.dbnum);
            resize_db++;
        }

        /* Rehash */
        if (server.activerehashing) {
991
            for (j = 0; j < dbs_per_call; j++) {
992 993 994 995 996 997 998 999 1000
                int work_done = incrementallyRehash(rehash_db % server.dbnum);
                rehash_db++;
                if (work_done) {
                    /* If the function did some work, stop here, we'll do
                     * more at the next cron loop. */
                    break;
                }
            }
        }
1001 1002 1003
    }
}

1004
/* This is our timer interrupt, called server.hz times per second.
1005 1006 1007 1008 1009
 * Here is where we do a number of things that need to be done asynchronously.
 * For instance:
 *
 * - Active expired keys collection (it is also performed in a lazy way on
 *   lookup).
G
guiquanz 已提交
1010
 * - Software watchdog.
1011 1012 1013
 * - Update some statistic.
 * - Incremental rehashing of the DBs hash tables.
 * - Triggering BGSAVE / AOF rewrite, and handling of terminated children.
G
guiquanz 已提交
1014
 * - Clients timeout of different kinds.
1015 1016 1017
 * - Replication reconnection.
 * - Many more...
 *
1018
 * Everything directly called here will be called server.hz times per second,
1019 1020 1021 1022
 * so in order to throttle execution of things we want to do less frequently
 * a macro is used: run_with_period(milliseconds) { .... }
 */

1023
int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
1024
    int j;
1025 1026 1027 1028
    REDIS_NOTUSED(eventLoop);
    REDIS_NOTUSED(id);
    REDIS_NOTUSED(clientData);

A
antirez 已提交
1029 1030 1031 1032
    /* Software watchdog: deliver the SIGALRM that will reach the signal
     * handler if we don't return here fast enough. */
    if (server.watchdog_period) watchdogScheduleSignal(server.watchdog_period);

1033 1034 1035 1036 1037
    /* We take a cached value of the unix time in the global state because
     * with virtual memory and aging there is to store the current time
     * in objects at every object access, and accuracy is not needed.
     * To access a global var is faster than calling time(NULL) */
    server.unixtime = time(NULL);
1038
    server.mstime = mstime();
A
antirez 已提交
1039

1040
    run_with_period(100) trackOperationsPerSecond();
1041

1042
    /* We have just 22 bits per object for LRU information.
1043
     * So we use an (eventually wrapping) LRU clock with 10 seconds resolution.
G
guiquanz 已提交
1044
     * 2^22 bits with 10 seconds resolution is more or less 1.5 years.
1045
     *
1046
     * Note that even if this will wrap after 1.5 years it's not a problem,
1047
     * everything will still work but just some object will appear younger
1048 1049 1050 1051 1052
     * to Redis. But for this to happen a given object should never be touched
     * for 1.5 years.
     *
     * Note that you can change the resolution altering the
     * REDIS_LRU_CLOCK_RESOLUTION define.
1053
     */
1054
    updateLRUClock();
1055

1056 1057 1058 1059
    /* Record the max memory used since the server was started. */
    if (zmalloc_used_memory() > server.stat_peak_memory)
        server.stat_peak_memory = zmalloc_used_memory();

1060 1061 1062
    /* We received a SIGTERM, shutting down here in a safe way, as it is
     * not ok doing so inside the signal handler. */
    if (server.shutdown_asap) {
1063
        if (prepareForShutdown(0) == REDIS_OK) exit(0);
1064
        redisLog(REDIS_WARNING,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
1065
        server.shutdown_asap = 0;
1066 1067 1068
    }

    /* Show some info about non-empty databases */
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
    run_with_period(5000) {
        for (j = 0; j < server.dbnum; j++) {
            long long size, used, vkeys;

            size = dictSlots(server.db[j].dict);
            used = dictSize(server.db[j].dict);
            vkeys = dictSize(server.db[j].expires);
            if (used || vkeys) {
                redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
                /* dictPrintStats(server.dict); */
            }
1080 1081 1082 1083
        }
    }

    /* Show information about connected clients */
1084 1085 1086
    if (!server.sentinel_mode) {
        run_with_period(5000) {
            redisLog(REDIS_VERBOSE,
1087
                "%lu clients connected (%lu slaves), %zu bytes in use",
1088 1089 1090 1091
                listLength(server.clients)-listLength(server.slaves),
                listLength(server.slaves),
                zmalloc_used_memory());
        }
1092 1093
    }

1094 1095
    /* We need to do a few operations on clients asynchronously. */
    clientsCron();
1096

1097 1098 1099
    /* Handle background operations on Redis databases. */
    databasesCron();

1100 1101
    /* Start a scheduled AOF rewrite if this was requested by the user while
     * a BGSAVE was in progress. */
A
antirez 已提交
1102
    if (server.rdb_child_pid == -1 && server.aof_child_pid == -1 &&
1103
        server.aof_rewrite_scheduled)
1104 1105 1106 1107
    {
        rewriteAppendOnlyFileBackground();
    }

A
antirez 已提交
1108
    /* Check if a background saving or AOF rewrite in progress terminated. */
A
antirez 已提交
1109
    if (server.rdb_child_pid != -1 || server.aof_child_pid != -1) {
1110 1111 1112 1113
        int statloc;
        pid_t pid;

        if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
1114 1115 1116 1117 1118
            int exitcode = WEXITSTATUS(statloc);
            int bysignal = 0;
            
            if (WIFSIGNALED(statloc)) bysignal = WTERMSIG(statloc);

A
antirez 已提交
1119
            if (pid == server.rdb_child_pid) {
1120
                backgroundSaveDoneHandler(exitcode,bysignal);
1121
            } else if (pid == server.aof_child_pid) {
1122
                backgroundRewriteDoneHandler(exitcode,bysignal);
1123 1124 1125 1126
            } else {
                redisLog(REDIS_WARNING,
                    "Warning, detected child with unmatched pid: %ld",
                    (long)pid);
1127 1128 1129
            }
            updateDictResizePolicy();
        }
A
antirez 已提交
1130
    } else {
1131 1132
        /* If there is not a background saving/rewrite in progress check if
         * we have to save/rewrite now */
1133 1134 1135
         for (j = 0; j < server.saveparamslen; j++) {
            struct saveparam *sp = server.saveparams+j;

1136 1137 1138 1139
            /* Save if we reached the given amount of changes,
             * the given amount of seconds, and if the latest bgsave was
             * successful or if, in case of an error, at least
             * REDIS_BGSAVE_RETRY_DELAY seconds already elapsed. */
1140
            if (server.dirty >= sp->changes &&
1141 1142 1143 1144 1145
                server.unixtime-server.lastsave > sp->seconds &&
                (server.unixtime-server.lastbgsave_try >
                 REDIS_BGSAVE_RETRY_DELAY ||
                 server.lastbgsave_status == REDIS_OK))
            {
1146
                redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
1147
                    sp->changes, (int)sp->seconds);
A
antirez 已提交
1148
                rdbSaveBackground(server.rdb_filename);
1149 1150 1151
                break;
            }
         }
1152 1153

         /* Trigger an AOF rewrite if needed */
A
antirez 已提交
1154
         if (server.rdb_child_pid == -1 &&
A
antirez 已提交
1155
             server.aof_child_pid == -1 &&
1156 1157
             server.aof_rewrite_perc &&
             server.aof_current_size > server.aof_rewrite_min_size)
1158
         {
1159 1160 1161 1162
            long long base = server.aof_rewrite_base_size ?
                            server.aof_rewrite_base_size : 1;
            long long growth = (server.aof_current_size*100/base) - 100;
            if (growth >= server.aof_rewrite_perc) {
1163
                redisLog(REDIS_NOTICE,"Starting automatic rewriting of AOF on %lld%% growth",growth);
1164 1165 1166
                rewriteAppendOnlyFileBackground();
            }
         }
1167 1168
    }

1169 1170 1171 1172 1173

    /* If we postponed an AOF buffer flush, let's try to do it every time the
     * cron function is called. */
    if (server.aof_flush_postponed_start) flushAppendOnlyFile(0);

1174 1175 1176
    /* Close clients that need to be closed asynchronous */
    freeClientsInAsyncFreeQueue();

1177 1178 1179
    /* Clear the paused clients flag if needed. */
    clientsArePaused(); /* Don't check return value, just use the side effect. */

1180 1181
    /* Replication cron function -- used to reconnect to master and
     * to detect transfer failures. */
1182
    run_with_period(1000) replicationCron();
1183

A
antirez 已提交
1184
    /* Run the Redis Cluster cron. */
1185
    run_with_period(100) {
1186 1187
        if (server.cluster_enabled) clusterCron();
    }
A
antirez 已提交
1188

A
antirez 已提交
1189
    /* Run the Sentinel timer if we are in sentinel mode. */
1190 1191 1192 1193
    run_with_period(100) {
        if (server.sentinel_mode) sentinelTimer();
    }

A
antirez 已提交
1194 1195 1196 1197 1198
    /* Cleanup expired MIGRATE cached sockets. */
    run_with_period(1000) {
        migrateCloseTimedoutSockets();
    }

1199
    server.cronloops++;
1200
    return 1000/server.hz;
1201 1202 1203 1204 1205 1206 1207 1208
}

/* This function gets called every time Redis is entering the
 * main loop of the event driven library, that is, before to sleep
 * for ready file descriptors. */
void beforeSleep(struct aeEventLoop *eventLoop) {
    REDIS_NOTUSED(eventLoop);

1209 1210 1211 1212
    /* Run a fast expire cycle (the called function will return
     * ASAP if a fast cycle is not needed). */
    if (server.active_expire_enabled && server.masterhost == NULL)
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);
1213

1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
    /* Send all the slaves an ACK request if at least one client blocked
     * during the previous event loop iteration. */
    if (server.get_ack_from_slaves) {
        robj *argv[3];

        argv[0] = createStringObject("REPLCONF",8);
        argv[1] = createStringObject("GETACK",6);
        argv[2] = createStringObject("*",1); /* Not used argument. */
        replicationFeedSlaves(server.slaves, server.slaveseldb, argv, 3);
        decrRefCount(argv[0]);
        decrRefCount(argv[1]);
        decrRefCount(argv[2]);
        server.get_ack_from_slaves = 0;
    }

    /* Unblock all the clients blocked for synchronous replication
     * in WAIT. */
    if (listLength(server.clients_waiting_acks))
        processClientsWaitingReplicas();

1234
    /* Try to process pending commands for clients that were just unblocked. */
1235 1236
    if (listLength(server.unblocked_clients))
        processUnblockedClients();
1237

1238
    /* Write the AOF buffer on disk */
1239
    flushAppendOnlyFile(0);
1240 1241 1242

    /* Call the Redis Cluster before sleep function. */
    if (server.cluster_enabled) clusterBeforeSleep();
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
}

/* =========================== Server initialization ======================== */

void createSharedObjects(void) {
    int j;

    shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
    shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
    shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
    shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
    shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
    shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
    shared.cnegone = createObject(REDIS_STRING,sdsnew(":-1\r\n"));
    shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
    shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
    shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
    shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
    shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n"));
A
antirez 已提交
1262
    shared.emptyscan = createObject(REDIS_STRING,sdsnew("*2\r\n$1\r\n0\r\n*0\r\n"));
1263
    shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
1264
        "-WRONGTYPE Operation against a key holding the wrong kind of value\r\n"));
1265 1266 1267 1268 1269 1270 1271 1272
    shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
        "-ERR no such key\r\n"));
    shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
        "-ERR syntax error\r\n"));
    shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
        "-ERR source and destination objects are the same\r\n"));
    shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
        "-ERR index out of range\r\n"));
A
antirez 已提交
1273 1274
    shared.noscripterr = createObject(REDIS_STRING,sdsnew(
        "-NOSCRIPT No matching script. Please use EVAL.\r\n"));
1275 1276
    shared.loadingerr = createObject(REDIS_STRING,sdsnew(
        "-LOADING Redis is loading the dataset in memory\r\n"));
1277
    shared.slowscripterr = createObject(REDIS_STRING,sdsnew(
1278
        "-BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.\r\n"));
1279 1280
    shared.masterdownerr = createObject(REDIS_STRING,sdsnew(
        "-MASTERDOWN Link with MASTER is down and slave-serve-stale-data is set to 'no'.\r\n"));
1281
    shared.bgsaveerr = createObject(REDIS_STRING,sdsnew(
1282 1283 1284
        "-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"));
    shared.roslaveerr = createObject(REDIS_STRING,sdsnew(
        "-READONLY You can't write against a read only slave.\r\n"));
1285 1286
    shared.noautherr = createObject(REDIS_STRING,sdsnew(
        "-NOAUTH Authentication required.\r\n"));
1287 1288
    shared.oomerr = createObject(REDIS_STRING,sdsnew(
        "-OOM command not allowed when used memory > 'maxmemory'.\r\n"));
A
antirez 已提交
1289 1290
    shared.execaborterr = createObject(REDIS_STRING,sdsnew(
        "-EXECABORT Transaction discarded because of previous errors.\r\n"));
1291 1292
    shared.noreplicaserr = createObject(REDIS_STRING,sdsnew(
        "-NOREPLICAS Not enough good slaves to write.\r\n"));
1293 1294 1295
    shared.space = createObject(REDIS_STRING,sdsnew(" "));
    shared.colon = createObject(REDIS_STRING,sdsnew(":"));
    shared.plus = createObject(REDIS_STRING,sdsnew("+"));
1296 1297

    for (j = 0; j < REDIS_SHARED_SELECT_CMDS; j++) {
1298 1299 1300 1301
        char dictid_str[64];
        int dictid_len;

        dictid_len = ll2string(dictid_str,sizeof(dictid_str),j);
1302
        shared.select[j] = createObject(REDIS_STRING,
1303 1304 1305
            sdscatprintf(sdsempty(),
                "*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n",
                dictid_len, dictid_str));
1306
    }
1307 1308 1309 1310 1311 1312
    shared.messagebulk = createStringObject("$7\r\nmessage\r\n",13);
    shared.pmessagebulk = createStringObject("$8\r\npmessage\r\n",14);
    shared.subscribebulk = createStringObject("$9\r\nsubscribe\r\n",15);
    shared.unsubscribebulk = createStringObject("$11\r\nunsubscribe\r\n",18);
    shared.psubscribebulk = createStringObject("$10\r\npsubscribe\r\n",17);
    shared.punsubscribebulk = createStringObject("$12\r\npunsubscribe\r\n",19);
1313
    shared.del = createStringObject("DEL",3);
1314 1315
    shared.rpop = createStringObject("RPOP",4);
    shared.lpop = createStringObject("LPOP",4);
1316
    shared.lpush = createStringObject("LPUSH",5);
1317 1318 1319 1320
    for (j = 0; j < REDIS_SHARED_INTEGERS; j++) {
        shared.integers[j] = createObject(REDIS_STRING,(void*)(long)j);
        shared.integers[j]->encoding = REDIS_ENCODING_INT;
    }
1321 1322 1323 1324 1325 1326
    for (j = 0; j < REDIS_SHARED_BULKHDR_LEN; j++) {
        shared.mbulkhdr[j] = createObject(REDIS_STRING,
            sdscatprintf(sdsempty(),"*%d\r\n",j));
        shared.bulkhdr[j] = createObject(REDIS_STRING,
            sdscatprintf(sdsempty(),"$%d\r\n",j));
    }
1327 1328 1329
}

void initServerConfig() {
1330 1331
    int j;

A
antirez 已提交
1332
    getRandomHexChars(server.runid,REDIS_RUN_ID_SIZE);
1333
    server.configfile = NULL;
1334
    server.hz = REDIS_DEFAULT_HZ;
A
antirez 已提交
1335
    server.runid[REDIS_RUN_ID_SIZE] = '\0';
1336
    server.arch_bits = (sizeof(long) == 8) ? 64 : 32;
1337
    server.port = REDIS_SERVERPORT;
1338
    server.tcp_backlog = REDIS_TCP_BACKLOG;
A
antirez 已提交
1339
    server.bindaddr_count = 0;
1340
    server.unixsocket = NULL;
1341
    server.unixsocketperm = REDIS_DEFAULT_UNIX_SOCKET_PERM;
1342
    server.ipfd_count = 0;
1343 1344
    server.sofd = -1;
    server.dbnum = REDIS_DEFAULT_DBNUM;
1345
    server.verbosity = REDIS_DEFAULT_VERBOSITY;
1346
    server.maxidletime = REDIS_MAXIDLETIME;
1347
    server.tcpkeepalive = REDIS_DEFAULT_TCP_KEEPALIVE;
A
antirez 已提交
1348
    server.active_expire_enabled = 1;
1349
    server.client_max_querybuf_len = REDIS_MAX_QUERYBUF_LEN;
1350
    server.saveparams = NULL;
1351
    server.loading = 0;
1352 1353
    server.logfile = zstrdup(REDIS_DEFAULT_LOGFILE);
    server.syslog_enabled = REDIS_DEFAULT_SYSLOG_ENABLED;
1354
    server.syslog_ident = zstrdup(REDIS_DEFAULT_SYSLOG_IDENT);
J
Jonah H. Harris 已提交
1355
    server.syslog_facility = LOG_LOCAL0;
1356
    server.daemonize = REDIS_DEFAULT_DAEMONIZE;
1357
    server.aof_state = REDIS_AOF_OFF;
1358 1359
    server.aof_fsync = REDIS_DEFAULT_AOF_FSYNC;
    server.aof_no_fsync_on_rewrite = REDIS_DEFAULT_AOF_NO_FSYNC_ON_REWRITE;
1360 1361 1362 1363
    server.aof_rewrite_perc = REDIS_AOF_REWRITE_PERC;
    server.aof_rewrite_min_size = REDIS_AOF_REWRITE_MIN_SIZE;
    server.aof_rewrite_base_size = 0;
    server.aof_rewrite_scheduled = 0;
A
antirez 已提交
1364
    server.aof_last_fsync = time(NULL);
1365 1366
    server.aof_rewrite_time_last = -1;
    server.aof_rewrite_time_start = -1;
1367
    server.aof_lastbgrewrite_status = REDIS_OK;
1368
    server.aof_delayed_fsync = 0;
A
antirez 已提交
1369 1370
    server.aof_fd = -1;
    server.aof_selected_db = -1; /* Make sure the first time will not match */
1371
    server.aof_flush_postponed_start = 0;
1372
    server.aof_rewrite_incremental_fsync = REDIS_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC;
1373
    server.pidfile = zstrdup(REDIS_DEFAULT_PID_FILE);
1374
    server.rdb_filename = zstrdup(REDIS_DEFAULT_RDB_FILENAME);
1375
    server.aof_filename = zstrdup(REDIS_DEFAULT_AOF_FILENAME);
1376
    server.requirepass = NULL;
1377 1378 1379 1380
    server.rdb_compression = REDIS_DEFAULT_RDB_COMPRESSION;
    server.rdb_checksum = REDIS_DEFAULT_RDB_CHECKSUM;
    server.stop_writes_on_bgsave_err = REDIS_DEFAULT_STOP_WRITES_ON_BGSAVE_ERROR;
    server.activerehashing = REDIS_DEFAULT_ACTIVE_REHASHING;
A
antirez 已提交
1381
    server.notify_keyspace_events = 0;
1382
    server.maxclients = REDIS_MAX_CLIENTS;
1383
    server.bpop_blocked_clients = 0;
1384 1385 1386
    server.maxmemory = REDIS_DEFAULT_MAXMEMORY;
    server.maxmemory_policy = REDIS_DEFAULT_MAXMEMORY_POLICY;
    server.maxmemory_samples = REDIS_DEFAULT_MAXMEMORY_SAMPLES;
1387 1388
    server.hash_max_ziplist_entries = REDIS_HASH_MAX_ZIPLIST_ENTRIES;
    server.hash_max_ziplist_value = REDIS_HASH_MAX_ZIPLIST_VALUE;
1389 1390
    server.list_max_ziplist_entries = REDIS_LIST_MAX_ZIPLIST_ENTRIES;
    server.list_max_ziplist_value = REDIS_LIST_MAX_ZIPLIST_VALUE;
1391
    server.set_max_intset_entries = REDIS_SET_MAX_INTSET_ENTRIES;
1392 1393
    server.zset_max_ziplist_entries = REDIS_ZSET_MAX_ZIPLIST_ENTRIES;
    server.zset_max_ziplist_value = REDIS_ZSET_MAX_ZIPLIST_VALUE;
1394
    server.shutdown_asap = 0;
A
1fe4cd5  
antirez 已提交
1395 1396
    server.repl_ping_slave_period = REDIS_REPL_PING_SLAVE_PERIOD;
    server.repl_timeout = REDIS_REPL_TIMEOUT;
1397 1398
    server.repl_min_slaves_to_write = REDIS_DEFAULT_MIN_SLAVES_TO_WRITE;
    server.repl_min_slaves_max_lag = REDIS_DEFAULT_MIN_SLAVES_MAX_LAG;
A
antirez 已提交
1399
    server.cluster_enabled = 0;
1400
    server.cluster_node_timeout = REDIS_CLUSTER_DEFAULT_NODE_TIMEOUT;
1401
    server.cluster_migration_barrier = REDIS_CLUSTER_DEFAULT_MIGRATION_BARRIER;
1402
    server.cluster_configfile = zstrdup(REDIS_DEFAULT_CLUSTER_CONFIG_FILE);
1403
    server.lua_caller = NULL;
A
antirez 已提交
1404
    server.lua_time_limit = REDIS_LUA_TIME_LIMIT;
1405
    server.lua_client = NULL;
1406
    server.lua_timedout = 0;
A
antirez 已提交
1407
    server.migrate_cached_sockets = dictCreate(&migrateCacheDictType,NULL);
1408
    server.loading_process_events_interval_bytes = (1024*1024*2);
1409

A
antirez 已提交
1410
    updateLRUClock();
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
    resetServerSaveParams();

    appendServerSaveParams(60*60,1);  /* save after 1 hour and 1 change */
    appendServerSaveParams(300,100);  /* save after 5 minutes and 100 changes */
    appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
    /* Replication related */
    server.masterauth = NULL;
    server.masterhost = NULL;
    server.masterport = 6379;
    server.master = NULL;
1421 1422
    server.cached_master = NULL;
    server.repl_master_initial_offset = -1;
A
antirez 已提交
1423
    server.repl_state = REDIS_REPL_NONE;
1424
    server.repl_syncio_timeout = REDIS_REPL_SYNCIO_TIMEOUT;
1425 1426
    server.repl_serve_stale_data = REDIS_DEFAULT_SLAVE_SERVE_STALE_DATA;
    server.repl_slave_ro = REDIS_DEFAULT_SLAVE_READ_ONLY;
1427
    server.repl_down_since = 0; /* Never connected, repl is down since EVER. */
1428
    server.repl_disable_tcp_nodelay = REDIS_DEFAULT_REPL_DISABLE_TCP_NODELAY;
1429
    server.slave_priority = REDIS_DEFAULT_SLAVE_PRIORITY;
1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
    server.master_repl_offset = 0;

    /* Replication partial resync backlog */
    server.repl_backlog = NULL;
    server.repl_backlog_size = REDIS_DEFAULT_REPL_BACKLOG_SIZE;
    server.repl_backlog_histlen = 0;
    server.repl_backlog_idx = 0;
    server.repl_backlog_off = 0;
    server.repl_backlog_time_limit = REDIS_DEFAULT_REPL_BACKLOG_TIME_LIMIT;
    server.repl_no_slaves_since = time(NULL);
1440

1441
    /* Client output buffer limits */
1442 1443
    for (j = 0; j < REDIS_CLIENT_LIMIT_NUM_CLASSES; j++)
        server.client_obuf_limits[j] = clientBufferLimitsDefaults[j];
1444

1445 1446 1447 1448 1449
    /* Double constants initialization */
    R_Zero = 0.0;
    R_PosInf = 1.0/R_Zero;
    R_NegInf = -1.0/R_Zero;
    R_Nan = R_Zero/R_Zero;
1450

G
guiquanz 已提交
1451
    /* Command table -- we initiialize it here as it is part of the
1452 1453 1454
     * initial configuration, since command names may be changed via
     * redis.conf using the rename-command directive. */
    server.commands = dictCreate(&commandTableDictType,NULL);
1455
    server.orig_commands = dictCreate(&commandTableDictType,NULL);
1456 1457 1458
    populateCommandTable();
    server.delCommand = lookupCommandByCString("del");
    server.multiCommand = lookupCommandByCString("multi");
1459
    server.lpushCommand = lookupCommandByCString("lpush");
1460 1461
    server.lpopCommand = lookupCommandByCString("lpop");
    server.rpopCommand = lookupCommandByCString("rpop");
1462 1463 1464 1465
    
    /* Slow log */
    server.slowlog_log_slower_than = REDIS_SLOWLOG_LOG_SLOWER_THAN;
    server.slowlog_max_len = REDIS_SLOWLOG_MAX_LEN;
A
antirez 已提交
1466

A
antirez 已提交
1467
    /* Debugging */
A
antirez 已提交
1468 1469 1470 1471
    server.assert_failed = "<no assertion failed>";
    server.assert_file = "<no file>";
    server.assert_line = 0;
    server.bug_report_start = 0;
A
antirez 已提交
1472
    server.watchdog_period = 0;
1473 1474
}

1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
/* This function will try to raise the max number of open files accordingly to
 * the configured max number of clients. It will also account for 32 additional
 * file descriptors as we need a few more for persistence, listening
 * sockets, log files and so forth.
 *
 * If it will not be possible to set the limit accordingly to the configured
 * max number of clients, the function will do the reverse setting
 * server.maxclients to the value that we can actually handle. */
void adjustOpenFilesLimit(void) {
    rlim_t maxfiles = server.maxclients+32;
    struct rlimit limit;

    if (getrlimit(RLIMIT_NOFILE,&limit) == -1) {
        redisLog(REDIS_WARNING,"Unable to obtain the current NOFILE limit (%s), assuming 1024 and setting the max clients configuration accordingly.",
            strerror(errno));
        server.maxclients = 1024-32;
    } else {
        rlim_t oldlimit = limit.rlim_cur;

        /* Set the max number of files if the current limit is not enough
         * for our needs. */
        if (oldlimit < maxfiles) {
1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508
            rlim_t f;
            
            f = maxfiles;
            while(f > oldlimit) {
                limit.rlim_cur = f;
                limit.rlim_max = f;
                if (setrlimit(RLIMIT_NOFILE,&limit) != -1) break;
                f -= 128;
            }
            if (f < oldlimit) f = oldlimit;
            if (f != maxfiles) {
                server.maxclients = f-32;
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
                redisLog(REDIS_WARNING,"Unable to set the max number of files limit to %d (%s), setting the max clients configuration to %d.",
                    (int) maxfiles, strerror(errno), (int) server.maxclients);
            } else {
                redisLog(REDIS_NOTICE,"Max number of open files set to %d",
                    (int) maxfiles);
            }
        }
    }
}

1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
/* Initialize a set of file descriptors to listen to the specified 'port'
 * binding the addresses specified in the Redis server configuration.
 *
 * The listening file descriptors are stored in the integer array 'fds'
 * and their number is set in '*count'.
 *
 * The addresses to bind are specified in the global server.bindaddr array
 * and their number is server.bindaddr_count. If the server configuration
 * contains no specific addresses to bind, this function will try to
 * bind * (all addresses) for both the IPv4 and IPv6 protocols.
 *
 * On success the function returns REDIS_OK.
 *
 * On error the function returns REDIS_ERR. For the function to be on
 * error, at least one of the server.bindaddr addresses was
 * impossible to bind, or no bind addresses were specified in the server
 * configuration but the function is not able to bind * for at least
 * one of the IPv4 or IPv6 protocols. */
int listenToPort(int port, int *fds, int *count) {
    int j;

    /* Force binding of 0.0.0.0 if no bind address is specified, always
     * entering the loop if j == 0. */
    if (server.bindaddr_count == 0) server.bindaddr[0] = NULL;
    for (j = 0; j < server.bindaddr_count || j == 0; j++) {
        if (server.bindaddr[j] == NULL) {
            /* Bind * for both IPv6 and IPv4, we enter here only if
             * server.bindaddr_count == 0. */
1547 1548
            fds[*count] = anetTcp6Server(server.neterr,port,NULL,
                server.tcp_backlog);
1549
            if (fds[*count] != ANET_ERR) (*count)++;
1550 1551
            fds[*count] = anetTcpServer(server.neterr,port,NULL,
                server.tcp_backlog);
1552 1553 1554 1555 1556 1557 1558
            if (fds[*count] != ANET_ERR) (*count)++;
            /* Exit the loop if we were able to bind * on IPv4 or IPv6,
             * otherwise fds[*count] will be ANET_ERR and we'll print an
             * error and return to the caller with an error. */
            if (*count) break;
        } else if (strchr(server.bindaddr[j],':')) {
            /* Bind IPv6 address. */
1559 1560
            fds[*count] = anetTcp6Server(server.neterr,port,server.bindaddr[j],
                server.tcp_backlog);
1561 1562
        } else {
            /* Bind IPv4 address. */
1563 1564
            fds[*count] = anetTcpServer(server.neterr,port,server.bindaddr[j],
                server.tcp_backlog);
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
        }
        if (fds[*count] == ANET_ERR) {
            redisLog(REDIS_WARNING,
                "Creating Server TCP listening socket %s:%d: %s",
                server.bindaddr[j] ? server.bindaddr[j] : "*",
                server.port, server.neterr);
            return REDIS_ERR;
        }
        (*count)++;
    }
    return REDIS_OK;
}

1578 1579 1580 1581 1582
void initServer() {
    int j;

    signal(SIGHUP, SIG_IGN);
    signal(SIGPIPE, SIG_IGN);
1583
    setupSignalHandlers();
1584

J
Jonah H. Harris 已提交
1585 1586 1587 1588 1589
    if (server.syslog_enabled) {
        openlog(server.syslog_ident, LOG_PID | LOG_NDELAY | LOG_NOWAIT,
            server.syslog_facility);
    }

1590
    server.current_client = NULL;
1591
    server.clients = listCreate();
1592
    server.clients_to_close = listCreate();
1593 1594
    server.slaves = listCreate();
    server.monitors = listCreate();
1595
    server.slaveseldb = -1; /* Force to emit the first SELECT command. */
1596
    server.unblocked_clients = listCreate();
1597
    server.ready_keys = listCreate();
1598 1599
    server.clients_waiting_acks = listCreate();
    server.get_ack_from_slaves = 0;
1600
    server.clients_paused = 0;
1601

1602
    createSharedObjects();
1603
    adjustOpenFilesLimit();
A
antirez 已提交
1604
    server.el = aeCreateEventLoop(server.maxclients+REDIS_EVENTLOOP_FDSET_INCR);
1605
    server.db = zmalloc(sizeof(redisDb)*server.dbnum);
1606

1607
    /* Open the TCP listening socket for the user commands. */
1608 1609
    if (server.port != 0 &&
        listenToPort(server.port,server.ipfd,&server.ipfd_count) == REDIS_ERR)
1610
        exit(1);
1611 1612

    /* Open the listening Unix domain socket. */
1613 1614
    if (server.unixsocket != NULL) {
        unlink(server.unixsocket); /* don't care if this fails */
1615 1616
        server.sofd = anetUnixServer(server.neterr,server.unixsocket,
            server.unixsocketperm, server.tcp_backlog);
1617 1618 1619 1620
        if (server.sofd == ANET_ERR) {
            redisLog(REDIS_WARNING, "Opening socket: %s", server.neterr);
            exit(1);
        }
1621
    }
1622 1623 1624

    /* Abort if there are no listening sockets at all. */
    if (server.ipfd_count == 0 && server.sofd < 0) {
1625
        redisLog(REDIS_WARNING, "Configured to not listen anywhere, exiting.");
1626 1627
        exit(1);
    }
1628 1629

    /* Create the Redis databases, and initialize other internal state. */
1630 1631 1632 1633
    for (j = 0; j < server.dbnum; j++) {
        server.db[j].dict = dictCreate(&dbDictType,NULL);
        server.db[j].expires = dictCreate(&keyptrDictType,NULL);
        server.db[j].blocking_keys = dictCreate(&keylistDictType,NULL);
1634
        server.db[j].ready_keys = dictCreate(&setDictType,NULL);
1635 1636
        server.db[j].watched_keys = dictCreate(&keylistDictType,NULL);
        server.db[j].id = j;
1637
        server.db[j].avg_ttl = 0;
1638 1639 1640 1641 1642 1643
    }
    server.pubsub_channels = dictCreate(&keylistDictType,NULL);
    server.pubsub_patterns = listCreate();
    listSetFreeMethod(server.pubsub_patterns,freePubsubPattern);
    listSetMatchMethod(server.pubsub_patterns,listMatchPubsubPattern);
    server.cronloops = 0;
A
antirez 已提交
1644
    server.rdb_child_pid = -1;
A
antirez 已提交
1645
    server.aof_child_pid = -1;
1646
    aofRewriteBufferReset();
A
antirez 已提交
1647
    server.aof_buf = sdsempty();
1648 1649
    server.lastsave = time(NULL); /* At startup we consider the DB saved. */
    server.lastbgsave_try = 0;    /* At startup we never tried to BGSAVE. */
1650 1651
    server.rdb_save_time_last = -1;
    server.rdb_save_time_start = -1;
1652 1653 1654 1655
    server.dirty = 0;
    server.stat_numcommands = 0;
    server.stat_numconnections = 0;
    server.stat_expiredkeys = 0;
1656
    server.stat_evictedkeys = 0;
1657
    server.stat_starttime = time(NULL);
1658 1659
    server.stat_keyspace_misses = 0;
    server.stat_keyspace_hits = 0;
1660
    server.stat_peak_memory = 0;
1661
    server.stat_fork_time = 0;
1662
    server.stat_rejected_conn = 0;
1663 1664 1665
    server.stat_sync_full = 0;
    server.stat_sync_partial_ok = 0;
    server.stat_sync_partial_err = 0;
1666 1667 1668 1669
    memset(server.ops_sec_samples,0,sizeof(server.ops_sec_samples));
    server.ops_sec_idx = 0;
    server.ops_sec_last_sample_time = mstime();
    server.ops_sec_last_sample_ops = 0;
1670
    server.unixtime = time(NULL);
1671
    server.mstime = mstime();
1672
    server.lastbgsave_status = REDIS_OK;
1673
    server.repl_good_slaves_count = 0;
1674 1675 1676

    /* Create the serverCron() time event, that's our main way to process
     * background operations. */
stamhe's avatar
stamhe 已提交
1677
    if(aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL) == AE_ERR) {
1678
        redisPanic("Can't create the serverCron time event.");
stamhe's avatar
stamhe 已提交
1679 1680
        exit(1);
    }
1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691

    /* Create an event handler for accepting new connections in TCP and Unix
     * domain sockets. */
    for (j = 0; j < server.ipfd_count; j++) {
        if (aeCreateFileEvent(server.el, server.ipfd[j], AE_READABLE,
            acceptTcpHandler,NULL) == AE_ERR)
            {
                redisPanic(
                    "Unrecoverable error creating server.ipfd file event.");
            }
    }
1692
    if (server.sofd > 0 && aeCreateFileEvent(server.el,server.sofd,AE_READABLE,
A
antirez 已提交
1693
        acceptUnixHandler,NULL) == AE_ERR) redisPanic("Unrecoverable error creating server.sofd file event.");
1694

1695
    /* Open the AOF file if needed. */
1696
    if (server.aof_state == REDIS_AOF_ON) {
A
antirez 已提交
1697
        server.aof_fd = open(server.aof_filename,
1698
                               O_WRONLY|O_APPEND|O_CREAT,0644);
A
antirez 已提交
1699
        if (server.aof_fd == -1) {
1700 1701 1702 1703 1704 1705
            redisLog(REDIS_WARNING, "Can't open the append-only file: %s",
                strerror(errno));
            exit(1);
        }
    }

1706 1707
    /* 32 bit instances are limited to 4GB of address space, so if there is
     * no explicit limit in the user provided configuration we set a limit
1708 1709
     * at 3 GB using maxmemory with 'noeviction' policy'. This avoids
     * useless crashes of the Redis instance for out of memory. */
1710
    if (server.arch_bits == 32 && server.maxmemory == 0) {
1711 1712
        redisLog(REDIS_WARNING,"Warning: 32 bit instance detected but no memory limit set. Setting 3 GB maxmemory limit with 'noeviction' policy now.");
        server.maxmemory = 3072LL*(1024*1024); /* 3 GB */
1713 1714 1715
        server.maxmemory_policy = REDIS_MAXMEMORY_NO_EVICTION;
    }

A
antirez 已提交
1716
    if (server.cluster_enabled) clusterInit();
1717
    replicationScriptCacheInit();
1718
    scriptingInit();
1719
    slowlogInit();
1720
    bioInit();
1721 1722
}

1723 1724 1725 1726
/* Populates the Redis Command Table starting from the hard coded list
 * we have on top of redis.c file. */
void populateCommandTable(void) {
    int j;
1727
    int numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
1728 1729

    for (j = 0; j < numcommands; j++) {
1730
        struct redisCommand *c = redisCommandTable+j;
1731
        char *f = c->sflags;
1732
        int retval1, retval2;
1733

1734 1735 1736 1737 1738 1739 1740
        while(*f != '\0') {
            switch(*f) {
            case 'w': c->flags |= REDIS_CMD_WRITE; break;
            case 'r': c->flags |= REDIS_CMD_READONLY; break;
            case 'm': c->flags |= REDIS_CMD_DENYOOM; break;
            case 'a': c->flags |= REDIS_CMD_ADMIN; break;
            case 'p': c->flags |= REDIS_CMD_PUBSUB; break;
1741 1742
            case 's': c->flags |= REDIS_CMD_NOSCRIPT; break;
            case 'R': c->flags |= REDIS_CMD_RANDOM; break;
1743
            case 'S': c->flags |= REDIS_CMD_SORT_FOR_SCRIPT; break;
1744 1745
            case 'l': c->flags |= REDIS_CMD_LOADING; break;
            case 't': c->flags |= REDIS_CMD_STALE; break;
1746
            case 'M': c->flags |= REDIS_CMD_SKIP_MONITOR; break;
1747
            case 'k': c->flags |= REDIS_CMD_ASKING; break;
1748 1749 1750 1751 1752
            default: redisPanic("Unsupported command flag"); break;
            }
            f++;
        }

1753 1754 1755 1756 1757
        retval1 = dictAdd(server.commands, sdsnew(c->name), c);
        /* Populate an additional dictionary that will be unaffected
         * by rename-command statements in redis.conf. */
        retval2 = dictAdd(server.orig_commands, sdsnew(c->name), c);
        redisAssert(retval1 == DICT_OK && retval2 == DICT_OK);
1758
    }
1759 1760
}

1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
void resetCommandTableStats(void) {
    int numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
    int j;

    for (j = 0; j < numcommands; j++) {
        struct redisCommand *c = redisCommandTable+j;

        c->microseconds = 0;
        c->calls = 0;
    }
}

1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
/* ========================== Redis OP Array API ============================ */

void redisOpArrayInit(redisOpArray *oa) {
    oa->ops = NULL;
    oa->numops = 0;
}

int redisOpArrayAppend(redisOpArray *oa, struct redisCommand *cmd, int dbid,
                       robj **argv, int argc, int target)
{
    redisOp *op;

    oa->ops = zrealloc(oa->ops,sizeof(redisOp)*(oa->numops+1));
    op = oa->ops+oa->numops;
    op->cmd = cmd;
    op->dbid = dbid;
    op->argv = argv;
    op->argc = argc;
    op->target = target;
    oa->numops++;
    return oa->numops;
}

void redisOpArrayFree(redisOpArray *oa) {
    while(oa->numops) {
        int j;
        redisOp *op;

        oa->numops--;
        op = oa->ops+oa->numops;
        for (j = 0; j < op->argc; j++)
            decrRefCount(op->argv[j]);
        zfree(op->argv);
    }
    zfree(oa->ops);
}

1810 1811
/* ====================== Commands lookup and execution ===================== */

1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
struct redisCommand *lookupCommand(sds name) {
    return dictFetchValue(server.commands, name);
}

struct redisCommand *lookupCommandByCString(char *s) {
    struct redisCommand *cmd;
    sds name = sdsnew(s);

    cmd = dictFetchValue(server.commands, name);
    sdsfree(name);
    return cmd;
1823 1824
}

1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
/* Lookup the command in the current table, if not found also check in
 * the original table containing the original command names unaffected by
 * redis.conf rename-command statement.
 *
 * This is used by functions rewriting the argument vector such as
 * rewriteClientCommandVector() in order to set client->cmd pointer
 * correctly even if the command was renamed. */
struct redisCommand *lookupCommandOrOriginal(sds name) {
    struct redisCommand *cmd = dictFetchValue(server.commands, name);

    if (!cmd) cmd = dictFetchValue(server.orig_commands,name);
    return cmd;
}

A
antirez 已提交
1839
/* Propagate the specified command (in the context of the specified database id)
1840
 * to AOF and Slaves.
A
antirez 已提交
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
 *
 * flags are an xor between:
 * + REDIS_PROPAGATE_NONE (no propagation of command at all)
 * + REDIS_PROPAGATE_AOF (propagate into the AOF file if is enabled)
 * + REDIS_PROPAGATE_REPL (propagate into the replication link)
 */
void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
               int flags)
{
    if (server.aof_state != REDIS_AOF_OFF && flags & REDIS_PROPAGATE_AOF)
        feedAppendOnlyFile(cmd,dbid,argv,argc);
1852
    if (flags & REDIS_PROPAGATE_REPL)
A
antirez 已提交
1853 1854 1855
        replicationFeedSlaves(server.slaves,dbid,argv,argc);
}

1856 1857
/* Used inside commands to schedule the propagation of additional commands
 * after the current command is propagated to AOF / Replication. */
1858 1859 1860
void alsoPropagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
                   int target)
{
1861
    redisOpArrayAppend(&server.also_propagate,cmd,dbid,argv,argc,target);
1862 1863
}

A
antirez 已提交
1864 1865 1866 1867 1868 1869 1870 1871
/* It is possible to call the function forceCommandPropagation() inside a
 * Redis command implementaiton in order to to force the propagation of a
 * specific command execution into AOF / Replication. */
void forceCommandPropagation(redisClient *c, int flags) {
    if (flags & REDIS_PROPAGATE_REPL) c->flags |= REDIS_FORCE_REPL;
    if (flags & REDIS_PROPAGATE_AOF) c->flags |= REDIS_FORCE_AOF;
}

1872
/* Call() is the core of Redis execution of a command */
1873
void call(redisClient *c, int flags) {
1874
    long long dirty, start = ustime(), duration;
A
antirez 已提交
1875
    int client_old_flags = c->flags;
1876

A
antirez 已提交
1877
    /* Sent the command to clients in MONITOR mode, only if the commands are
G
guiquanz 已提交
1878
     * not generated from reading an AOF. */
1879 1880 1881 1882
    if (listLength(server.monitors) &&
        !server.loading &&
        !(c->cmd->flags & REDIS_CMD_SKIP_MONITOR))
    {
1883
        replicationFeedMonitors(c,server.monitors,c->db->id,c->argv,c->argc);
1884
    }
A
antirez 已提交
1885 1886

    /* Call the command. */
A
antirez 已提交
1887
    c->flags &= ~(REDIS_FORCE_AOF|REDIS_FORCE_REPL);
1888
    redisOpArrayInit(&server.also_propagate);
1889
    dirty = server.dirty;
1890
    c->cmd->proc(c);
1891
    dirty = server.dirty-dirty;
1892
    duration = ustime()-start;
1893 1894 1895 1896 1897 1898

    /* When EVAL is called loading the AOF we don't want commands called
     * from Lua to go into the slowlog or to populate statistics. */
    if (server.loading && c->flags & REDIS_LUA_CLIENT)
        flags &= ~(REDIS_CALL_SLOWLOG | REDIS_CALL_STATS);

A
antirez 已提交
1899 1900 1901 1902 1903 1904 1905 1906 1907 1908
    /* If the caller is Lua, we want to force the EVAL caller to propagate
     * the script if the command flag or client flag are forcing the
     * propagation. */
    if (c->flags & REDIS_LUA_CLIENT && server.lua_caller) {
        if (c->flags & REDIS_FORCE_REPL)
            server.lua_caller->flags |= REDIS_FORCE_REPL;
        if (c->flags & REDIS_FORCE_AOF)
            server.lua_caller->flags |= REDIS_FORCE_AOF;
    }

A
antirez 已提交
1909 1910
    /* Log the command into the Slow log if needed, and populate the
     * per-command statistics that we show in INFO commandstats. */
1911
    if (flags & REDIS_CALL_SLOWLOG && c->cmd->proc != execCommand)
1912 1913 1914 1915 1916
        slowlogPushEntryIfNeeded(c->argv,c->argc,duration);
    if (flags & REDIS_CALL_STATS) {
        c->cmd->microseconds += duration;
        c->cmd->calls++;
    }
A
antirez 已提交
1917 1918

    /* Propagate the command into the AOF and replication link */
1919
    if (flags & REDIS_CALL_PROPAGATE) {
A
antirez 已提交
1920 1921
        int flags = REDIS_PROPAGATE_NONE;

A
antirez 已提交
1922 1923
        if (c->flags & REDIS_FORCE_REPL) flags |= REDIS_PROPAGATE_REPL;
        if (c->flags & REDIS_FORCE_AOF) flags |= REDIS_PROPAGATE_AOF;
A
antirez 已提交
1924 1925 1926 1927
        if (dirty)
            flags |= (REDIS_PROPAGATE_REPL | REDIS_PROPAGATE_AOF);
        if (flags != REDIS_PROPAGATE_NONE)
            propagate(c->cmd,c->db->id,c->argv,c->argc,flags);
1928
    }
1929

A
antirez 已提交
1930 1931 1932 1933 1934
    /* Restore the old FORCE_AOF/REPL flags, since call can be executed
     * recursively. */
    c->flags &= ~(REDIS_FORCE_AOF|REDIS_FORCE_REPL);
    c->flags |= client_old_flags & (REDIS_FORCE_AOF|REDIS_FORCE_REPL);

1935 1936
    /* Handle the alsoPropagate() API to handle commands that want to propagate
     * multiple separated commands. */
1937
    if (server.also_propagate.numops) {
1938
        int j;
1939
        redisOp *rop;
1940

1941 1942 1943 1944 1945
        for (j = 0; j < server.also_propagate.numops; j++) {
            rop = &server.also_propagate.ops[j];
            propagate(rop->cmd, rop->dbid, rop->argv, rop->argc, rop->target);
        }
        redisOpArrayFree(&server.also_propagate);
1946
    }
1947 1948 1949 1950
    server.stat_numcommands++;
}

/* If this function gets called we already read a whole
1951
 * command, arguments are in the client argv/argc fields.
1952 1953 1954 1955
 * processCommand() execute the command or prepare the
 * server for a bulk read from the client.
 *
 * If 1 is returned the client is still alive and valid and
G
guiquanz 已提交
1956 1957
 * other operations can be performed by the caller. Otherwise
 * if 0 is returned the client was destroyed (i.e. after QUIT). */
1958
int processCommand(redisClient *c) {
P
Pieter Noordhuis 已提交
1959 1960 1961 1962
    /* The QUIT command is handled separately. Normal command procs will
     * go through checking for replication and QUIT will cause trouble
     * when FORCE_REPLICATION is enabled and would be implemented in
     * a regular command proc. */
1963
    if (!strcasecmp(c->argv[0]->ptr,"quit")) {
P
Pieter Noordhuis 已提交
1964
        addReply(c,shared.ok);
1965
        c->flags |= REDIS_CLOSE_AFTER_REPLY;
1966
        return REDIS_ERR;
1967 1968 1969
    }

    /* Now lookup the command and check ASAP about trivial error conditions
1970
     * such as wrong arity, bad command name and so forth. */
1971
    c->cmd = c->lastcmd = lookupCommand(c->argv[0]->ptr);
1972
    if (!c->cmd) {
A
antirez 已提交
1973
        flagTransaction(c);
1974 1975
        addReplyErrorFormat(c,"unknown command '%s'",
            (char*)c->argv[0]->ptr);
1976
        return REDIS_OK;
1977 1978
    } else if ((c->cmd->arity > 0 && c->cmd->arity != c->argc) ||
               (c->argc < -c->cmd->arity)) {
A
antirez 已提交
1979
        flagTransaction(c);
1980
        addReplyErrorFormat(c,"wrong number of arguments for '%s' command",
1981
            c->cmd->name);
1982
        return REDIS_OK;
1983 1984 1985
    }

    /* Check if the user is authenticated */
1986 1987
    if (server.requirepass && !c->authenticated && c->cmd->proc != authCommand)
    {
A
antirez 已提交
1988
        flagTransaction(c);
1989
        addReply(c,shared.noautherr);
1990
        return REDIS_OK;
1991 1992
    }

1993 1994 1995 1996
    /* If cluster is enabled perform the cluster redirection here.
     * However we don't perform the redirection if:
     * 1) The sender of this command is our master.
     * 2) The command has no key arguments. */
A
antirez 已提交
1997
    if (server.cluster_enabled &&
1998 1999 2000
        !(c->flags & REDIS_MASTER) &&
        !(c->cmd->getkeys_proc == NULL && c->cmd->firstkey == 0))
    {
A
antirez 已提交
2001 2002
        int hashslot;

2003
        if (server.cluster->state != REDIS_CLUSTER_OK) {
2004
            addReplySds(c,sdsnew("-CLUSTERDOWN The cluster is down. Use CLUSTER INFO for more information\r\n"));
A
antirez 已提交
2005 2006
            return REDIS_OK;
        } else {
2007
            int ask;
2008
            clusterNode *n = getNodeByQuery(c,c->cmd,c->argv,c->argc,&hashslot,&ask);
A
antirez 已提交
2009
            if (n == NULL) {
2010
                addReplyError(c,"Multi keys request invalid in cluster");
A
antirez 已提交
2011
                return REDIS_OK;
2012
            } else if (n != server.cluster->myself) {
A
antirez 已提交
2013
                addReplySds(c,sdscatprintf(sdsempty(),
2014 2015
                    "-%s %d %s:%d\r\n", ask ? "ASK" : "MOVED",
                    hashslot,n->ip,n->port));
A
antirez 已提交
2016 2017 2018 2019 2020
                return REDIS_OK;
            }
        }
    }

2021 2022 2023 2024 2025
    /* Handle the maxmemory directive.
     *
     * First we try to free some memory if possible (if there are volatile
     * keys in the dataset). If there are not the only thing we can do
     * is returning an error. */
2026 2027 2028
    if (server.maxmemory) {
        int retval = freeMemoryIfNeeded();
        if ((c->cmd->flags & REDIS_CMD_DENYOOM) && retval == REDIS_ERR) {
A
antirez 已提交
2029
            flagTransaction(c);
2030
            addReply(c, shared.oomerr);
2031 2032
            return REDIS_OK;
        }
2033 2034
    }

2035 2036
    /* Don't accept write commands if there are problems persisting on disk
     * and if this is a master instance. */
2037 2038 2039
    if (server.stop_writes_on_bgsave_err &&
        server.saveparamslen > 0
        && server.lastbgsave_status == REDIS_ERR &&
2040
        server.masterhost == NULL &&
2041 2042
        (c->cmd->flags & REDIS_CMD_WRITE ||
         c->cmd->proc == pingCommand))
2043
    {
A
antirez 已提交
2044
        flagTransaction(c);
2045 2046 2047 2048
        addReply(c, shared.bgsaveerr);
        return REDIS_OK;
    }

2049
    /* Don't accept write commands if there are not enough good slaves and
2050
     * user configured the min-slaves-to-write option. */
2051 2052 2053
    if (server.repl_min_slaves_to_write &&
        server.repl_min_slaves_max_lag &&
        c->cmd->flags & REDIS_CMD_WRITE &&
2054 2055 2056 2057 2058 2059 2060
        server.repl_good_slaves_count < server.repl_min_slaves_to_write)
    {
        flagTransaction(c);
        addReply(c, shared.noreplicaserr);
        return REDIS_OK;
    }

2061
    /* Don't accept write commands if this is a read only slave. But
2062 2063 2064 2065 2066 2067 2068 2069 2070
     * accept write commands if this is our master. */
    if (server.masterhost && server.repl_slave_ro &&
        !(c->flags & REDIS_MASTER) &&
        c->cmd->flags & REDIS_CMD_WRITE)
    {
        addReply(c, shared.roslaveerr);
        return REDIS_OK;
    }

2071 2072 2073
    /* Only allow SUBSCRIBE and UNSUBSCRIBE in the context of Pub/Sub */
    if ((dictSize(c->pubsub_channels) > 0 || listLength(c->pubsub_patterns) > 0)
        &&
2074 2075 2076 2077
        c->cmd->proc != subscribeCommand &&
        c->cmd->proc != unsubscribeCommand &&
        c->cmd->proc != psubscribeCommand &&
        c->cmd->proc != punsubscribeCommand) {
2078
        addReplyError(c,"only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context");
2079
        return REDIS_OK;
2080 2081
    }

2082 2083
    /* Only allow INFO and SLAVEOF when slave-serve-stale-data is no and
     * we are a slave with a broken link with master. */
A
antirez 已提交
2084
    if (server.masterhost && server.repl_state != REDIS_REPL_CONNECTED &&
2085
        server.repl_serve_stale_data == 0 &&
2086
        !(c->cmd->flags & REDIS_CMD_STALE))
2087
    {
A
antirez 已提交
2088
        flagTransaction(c);
2089
        addReply(c, shared.masterdownerr);
2090 2091 2092
        return REDIS_OK;
    }

2093 2094 2095
    /* Loading DB? Return an error if the command has not the
     * REDIS_CMD_LOADING flag. */
    if (server.loading && !(c->cmd->flags & REDIS_CMD_LOADING)) {
2096 2097 2098 2099
        addReply(c, shared.loadingerr);
        return REDIS_OK;
    }

A
antirez 已提交
2100
    /* Lua script too slow? Only allow a limited number of commands. */
2101
    if (server.lua_timedout &&
2102
          c->cmd->proc != authCommand &&
A
antirez 已提交
2103
          c->cmd->proc != replconfCommand &&
2104
        !(c->cmd->proc == shutdownCommand &&
2105 2106 2107 2108 2109 2110
          c->argc == 2 &&
          tolower(((char*)c->argv[1]->ptr)[0]) == 'n') &&
        !(c->cmd->proc == scriptCommand &&
          c->argc == 2 &&
          tolower(((char*)c->argv[1]->ptr)[0]) == 'k'))
    {
A
antirez 已提交
2111
        flagTransaction(c);
2112 2113 2114 2115
        addReply(c, shared.slowscripterr);
        return REDIS_OK;
    }

2116 2117
    /* Exec the command */
    if (c->flags & REDIS_MULTI &&
2118 2119
        c->cmd->proc != execCommand && c->cmd->proc != discardCommand &&
        c->cmd->proc != multiCommand && c->cmd->proc != watchCommand)
2120
    {
2121
        queueMultiCommand(c);
2122 2123
        addReply(c,shared.queued);
    } else {
2124
        call(c,REDIS_CALL_FULL);
2125
        c->woff = server.master_repl_offset;
2126 2127
        if (listLength(server.ready_keys))
            handleClientsBlockedOnLists();
2128
    }
2129
    return REDIS_OK;
2130 2131 2132 2133
}

/*================================== Shutdown =============================== */

2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
/* Close listening sockets. Also unlink the unix domain socket if
 * unlink_unix_socket is non-zero. */
void closeListeningSockets(int unlink_unix_socket) {
    int j;

    for (j = 0; j < server.ipfd_count; j++) close(server.ipfd[j]);
    if (server.sofd != -1) close(server.sofd);
    if (server.cluster_enabled)
        for (j = 0; j < server.cfd_count; j++) close(server.cfd[j]);
    if (unlink_unix_socket && server.unixsocket) {
        redisLog(REDIS_NOTICE,"Removing the unix socket file.");
        unlink(server.unixsocket); /* don't care if this fails */
    }
}

2149 2150 2151 2152
int prepareForShutdown(int flags) {
    int save = flags & REDIS_SHUTDOWN_SAVE;
    int nosave = flags & REDIS_SHUTDOWN_NOSAVE;

2153
    redisLog(REDIS_WARNING,"User requested shutdown...");
2154 2155 2156
    /* Kill the saving child if there is a background saving in progress.
       We want to avoid race conditions, for instance our saving child may
       overwrite the synchronous saving did by SHUTDOWN. */
A
antirez 已提交
2157
    if (server.rdb_child_pid != -1) {
2158
        redisLog(REDIS_WARNING,"There is a child saving an .rdb. Killing it!");
2159
        kill(server.rdb_child_pid,SIGUSR1);
A
antirez 已提交
2160
        rdbRemoveTempFile(server.rdb_child_pid);
2161
    }
2162
    if (server.aof_state != REDIS_AOF_OFF) {
2163 2164
        /* Kill the AOF saving child as the AOF we already have may be longer
         * but contains the full dataset anyway. */
A
antirez 已提交
2165
        if (server.aof_child_pid != -1) {
2166 2167
            redisLog(REDIS_WARNING,
                "There is a child rewriting the AOF. Killing it!");
2168
            kill(server.aof_child_pid,SIGUSR1);
2169
        }
2170
        /* Append only file: fsync() the AOF and exit */
2171
        redisLog(REDIS_NOTICE,"Calling fsync() on the AOF file.");
A
antirez 已提交
2172
        aof_fsync(server.aof_fd);
2173
    }
2174
    if ((server.saveparamslen > 0 && !nosave) || save) {
2175
        redisLog(REDIS_NOTICE,"Saving the final RDB snapshot before exiting.");
2176
        /* Snapshotting. Perform a SYNC SAVE and exit */
A
antirez 已提交
2177
        if (rdbSave(server.rdb_filename) != REDIS_OK) {
2178 2179 2180 2181 2182
            /* Ooops.. error saving! The best we can do is to continue
             * operating. Note that if there was a background saving process,
             * in the next cron() Redis will be notified that the background
             * saving aborted, handling special stuff like slaves pending for
             * synchronization... */
2183
            redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit.");
2184 2185 2186
            return REDIS_ERR;
        }
    }
2187 2188 2189 2190
    if (server.daemonize) {
        redisLog(REDIS_NOTICE,"Removing the pid file.");
        unlink(server.pidfile);
    }
2191
    /* Close the listening sockets. Apparently this allows faster restarts. */
2192
    closeListeningSockets(1);
2193
    redisLog(REDIS_WARNING,"Redis is now ready to exit, bye bye...");
2194 2195 2196 2197 2198
    return REDIS_OK;
}

/*================================== Commands =============================== */

2199
/* Return zero if strings are the same, non-zero if they are not.
2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
 * The comparison is performed in a way that prevents an attacker to obtain
 * information about the nature of the strings just monitoring the execution
 * time of the function.
 *
 * Note that limiting the comparison length to strings up to 512 bytes we
 * can avoid leaking any information about the password length and any
 * possible branch misprediction related leak.
 */
int time_independent_strcmp(char *a, char *b) {
    char bufa[REDIS_AUTHPASS_MAX_LEN], bufb[REDIS_AUTHPASS_MAX_LEN];
    /* The above two strlen perform len(a) + len(b) operations where either
     * a or b are fixed (our password) length, and the difference is only
     * relative to the length of the user provided string, so no information
     * leak is possible in the following two lines of code. */
    int alen = strlen(a);
    int blen = strlen(b);
    int j;
    int diff = 0;

    /* We can't compare strings longer than our static buffers.
     * Note that this will never pass the first test in practical circumstances
     * so there is no info leak. */
    if (alen > sizeof(bufa) || blen > sizeof(bufb)) return 1;

    memset(bufa,0,sizeof(bufa));        /* Constant time. */
    memset(bufb,0,sizeof(bufb));        /* Constant time. */
    /* Again the time of the following two copies is proportional to
     * len(a) + len(b) so no info is leaked. */
    memcpy(bufa,a,alen);
    memcpy(bufb,b,blen);

    /* Always compare all the chars in the two buffers without
     * conditional expressions. */
    for (j = 0; j < sizeof(bufa); j++) {
        diff |= (bufa[j] ^ bufb[j]);
    }
    /* Length must be equal as well. */
    diff |= alen ^ blen;
    return diff; /* If zero strings are the same. */
}

2241
void authCommand(redisClient *c) {
2242 2243
    if (!server.requirepass) {
        addReplyError(c,"Client sent AUTH, but no password is set");
2244
    } else if (!time_independent_strcmp(c->argv[1]->ptr, server.requirepass)) {
2245 2246 2247 2248
      c->authenticated = 1;
      addReply(c,shared.ok);
    } else {
      c->authenticated = 0;
2249
      addReplyError(c,"invalid password");
2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
    }
}

void pingCommand(redisClient *c) {
    addReply(c,shared.pong);
}

void echoCommand(redisClient *c) {
    addReplyBulk(c,c->argv[1]);
}

A
antirez 已提交
2261 2262 2263
void timeCommand(redisClient *c) {
    struct timeval tv;

G
guiquanz 已提交
2264
    /* gettimeofday() can only fail if &tv is a bad address so we
A
antirez 已提交
2265 2266 2267 2268 2269 2270 2271
     * don't check for errors. */
    gettimeofday(&tv,NULL);
    addReplyMultiBulkLen(c,2);
    addReplyBulkLongLong(c,tv.tv_sec);
    addReplyBulkLongLong(c,tv.tv_usec);
}

2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295
/* Convert an amount of bytes into a human readable string in the form
 * of 100B, 2G, 100M, 4K, and so forth. */
void bytesToHuman(char *s, unsigned long long n) {
    double d;

    if (n < 1024) {
        /* Bytes */
        sprintf(s,"%lluB",n);
        return;
    } else if (n < (1024*1024)) {
        d = (double)n/(1024);
        sprintf(s,"%.2fK",d);
    } else if (n < (1024LL*1024*1024)) {
        d = (double)n/(1024*1024);
        sprintf(s,"%.2fM",d);
    } else if (n < (1024LL*1024*1024*1024)) {
        d = (double)n/(1024LL*1024*1024);
        sprintf(s,"%.2fG",d);
    }
}

/* Create the string returned by the INFO command. This is decoupled
 * by the INFO command itself as we need to report the same information
 * on memory corruption problems. */
2296 2297
sds genRedisInfoString(char *section) {
    sds info = sdsempty();
2298
    time_t uptime = server.unixtime-server.stat_starttime;
A
antirez 已提交
2299
    int j, numcommands;
2300
    struct rusage self_ru, c_ru;
2301
    unsigned long lol, bib;
2302 2303
    int allsections = 0, defsections = 0;
    int sections = 0;
2304

2305 2306
    if (section) {
        allsections = strcasecmp(section,"all") == 0;
2307
        defsections = strcasecmp(section,"default") == 0;
2308
    }
2309 2310 2311

    getrusage(RUSAGE_SELF, &self_ru);
    getrusage(RUSAGE_CHILDREN, &c_ru);
2312
    getClientsMaxBuffers(&lol,&bib);
2313 2314 2315

    /* Server */
    if (allsections || defsections || !strcasecmp(section,"server")) {
2316
        struct utsname name;
2317
        char *mode;
2318

2319 2320 2321 2322
        if (server.cluster_enabled) mode = "cluster";
        else if (server.sentinel_mode) mode = "sentinel";
        else mode = "standalone";
    
2323
        if (sections++) info = sdscat(info,"\r\n");
2324
        uname(&name);
2325
        info = sdscatprintf(info,
2326 2327 2328 2329
            "# Server\r\n"
            "redis_version:%s\r\n"
            "redis_git_sha1:%s\r\n"
            "redis_git_dirty:%d\r\n"
2330
            "redis_build_id:%llx\r\n"
2331
            "redis_mode:%s\r\n"
2332
            "os:%s %s %s\r\n"
2333
            "arch_bits:%d\r\n"
2334
            "multiplexing_api:%s\r\n"
A
antirez 已提交
2335
            "gcc_version:%d.%d.%d\r\n"
2336
            "process_id:%ld\r\n"
A
antirez 已提交
2337
            "run_id:%s\r\n"
2338
            "tcp_port:%d\r\n"
Y
YAMAMOTO Takashi 已提交
2339 2340
            "uptime_in_seconds:%jd\r\n"
            "uptime_in_days:%jd\r\n"
2341
            "hz:%d\r\n"
2342 2343
            "lru_clock:%ld\r\n"
            "config_file:%s\r\n",
2344 2345 2346
            REDIS_VERSION,
            redisGitSHA1(),
            strtol(redisGitDirty(),NULL,10) > 0,
2347
            (unsigned long long) redisBuildId(),
2348
            mode,
2349
            name.sysname, name.release, name.machine,
2350
            server.arch_bits,
2351
            aeGetApiName(),
A
antirez 已提交
2352 2353 2354 2355 2356
#ifdef __GNUC__
            __GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__,
#else
            0,0,0,
#endif
2357
            (long) getpid(),
A
antirez 已提交
2358
            server.runid,
2359
            server.port,
Y
YAMAMOTO Takashi 已提交
2360 2361
            (intmax_t)uptime,
            (intmax_t)(uptime/(3600*24)),
2362
            server.hz,
2363 2364
            (unsigned long) server.lruclock,
            server.configfile ? server.configfile : "");
2365 2366 2367 2368 2369 2370 2371
    }

    /* Clients */
    if (allsections || defsections || !strcasecmp(section,"clients")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
            "# Clients\r\n"
2372
            "connected_clients:%lu\r\n"
2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
            "client_longest_output_list:%lu\r\n"
            "client_biggest_input_buf:%lu\r\n"
            "blocked_clients:%d\r\n",
            listLength(server.clients)-listLength(server.slaves),
            lol, bib,
            server.bpop_blocked_clients);
    }

    /* Memory */
    if (allsections || defsections || !strcasecmp(section,"memory")) {
2383 2384 2385 2386 2387
        char hmem[64];
        char peak_hmem[64];

        bytesToHuman(hmem,zmalloc_used_memory());
        bytesToHuman(peak_hmem,server.stat_peak_memory);
2388 2389 2390 2391 2392 2393
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
            "# Memory\r\n"
            "used_memory:%zu\r\n"
            "used_memory_human:%s\r\n"
            "used_memory_rss:%zu\r\n"
2394 2395
            "used_memory_peak:%zu\r\n"
            "used_memory_peak_human:%s\r\n"
A
antirez 已提交
2396
            "used_memory_lua:%lld\r\n"
2397
            "mem_fragmentation_ratio:%.2f\r\n"
2398
            "mem_allocator:%s\r\n",
2399 2400 2401
            zmalloc_used_memory(),
            hmem,
            zmalloc_get_rss(),
2402 2403
            server.stat_peak_memory,
            peak_hmem,
A
antirez 已提交
2404
            ((long long)lua_gc(server.lua,LUA_GCCOUNT,0))*1024LL,
2405
            zmalloc_get_fragmentation_ratio(),
2406
            ZMALLOC_LIB
2407
            );
2408 2409
    }

2410 2411 2412
    /* Persistence */
    if (allsections || defsections || !strcasecmp(section,"persistence")) {
        if (sections++) info = sdscat(info,"\r\n");
2413
        info = sdscatprintf(info,
2414 2415
            "# Persistence\r\n"
            "loading:%d\r\n"
2416 2417
            "rdb_changes_since_last_save:%lld\r\n"
            "rdb_bgsave_in_progress:%d\r\n"
Y
YAMAMOTO Takashi 已提交
2418
            "rdb_last_save_time:%jd\r\n"
2419
            "rdb_last_bgsave_status:%s\r\n"
Y
YAMAMOTO Takashi 已提交
2420 2421
            "rdb_last_bgsave_time_sec:%jd\r\n"
            "rdb_current_bgsave_time_sec:%jd\r\n"
2422
            "aof_enabled:%d\r\n"
2423 2424
            "aof_rewrite_in_progress:%d\r\n"
            "aof_rewrite_scheduled:%d\r\n"
Y
YAMAMOTO Takashi 已提交
2425 2426
            "aof_last_rewrite_time_sec:%jd\r\n"
            "aof_current_rewrite_time_sec:%jd\r\n"
2427
            "aof_last_bgrewrite_status:%s\r\n",
2428 2429
            server.loading,
            server.dirty,
A
antirez 已提交
2430
            server.rdb_child_pid != -1,
Y
YAMAMOTO Takashi 已提交
2431
            (intmax_t)server.lastsave,
2432
            (server.lastbgsave_status == REDIS_OK) ? "ok" : "err",
Y
YAMAMOTO Takashi 已提交
2433 2434 2435
            (intmax_t)server.rdb_save_time_last,
            (intmax_t)((server.rdb_child_pid == -1) ?
                -1 : time(NULL)-server.rdb_save_time_start),
2436
            server.aof_state != REDIS_AOF_OFF,
2437
            server.aof_child_pid != -1,
2438
            server.aof_rewrite_scheduled,
Y
YAMAMOTO Takashi 已提交
2439 2440 2441
            (intmax_t)server.aof_rewrite_time_last,
            (intmax_t)((server.aof_child_pid == -1) ?
                -1 : time(NULL)-server.aof_rewrite_time_start),
2442
            (server.aof_lastbgrewrite_status == REDIS_OK) ? "ok" : "err");
2443

2444
        if (server.aof_state != REDIS_AOF_OFF) {
2445 2446 2447
            info = sdscatprintf(info,
                "aof_current_size:%lld\r\n"
                "aof_base_size:%lld\r\n"
2448 2449
                "aof_pending_rewrite:%d\r\n"
                "aof_buffer_length:%zu\r\n"
2450
                "aof_rewrite_buffer_length:%lu\r\n"
2451 2452
                "aof_pending_bio_fsync:%llu\r\n"
                "aof_delayed_fsync:%lu\r\n",
2453 2454 2455
                (long long) server.aof_current_size,
                (long long) server.aof_rewrite_base_size,
                server.aof_rewrite_scheduled,
A
antirez 已提交
2456
                sdslen(server.aof_buf),
2457
                aofRewriteBufferSize(),
2458 2459
                bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC),
                server.aof_delayed_fsync);
2460 2461
        }

2462 2463 2464 2465 2466 2467 2468 2469 2470
        if (server.loading) {
            double perc;
            time_t eta, elapsed;
            off_t remaining_bytes = server.loading_total_bytes-
                                    server.loading_loaded_bytes;

            perc = ((double)server.loading_loaded_bytes /
                   server.loading_total_bytes) * 100;

2471
            elapsed = server.unixtime-server.loading_start_time;
2472 2473 2474 2475 2476 2477 2478 2479
            if (elapsed == 0) {
                eta = 1; /* A fake 1 second figure if we don't have
                            enough info */
            } else {
                eta = (elapsed*remaining_bytes)/server.loading_loaded_bytes;
            }

            info = sdscatprintf(info,
Y
YAMAMOTO Takashi 已提交
2480
                "loading_start_time:%jd\r\n"
2481 2482 2483
                "loading_total_bytes:%llu\r\n"
                "loading_loaded_bytes:%llu\r\n"
                "loading_loaded_perc:%.2f\r\n"
Y
YAMAMOTO Takashi 已提交
2484 2485
                "loading_eta_seconds:%jd\r\n",
                (intmax_t) server.loading_start_time,
2486 2487 2488
                (unsigned long long) server.loading_total_bytes,
                (unsigned long long) server.loading_loaded_bytes,
                perc,
Y
YAMAMOTO Takashi 已提交
2489
                (intmax_t)eta
2490 2491
            );
        }
2492
    }
2493 2494 2495 2496

    /* Stats */
    if (allsections || defsections || !strcasecmp(section,"stats")) {
        if (sections++) info = sdscat(info,"\r\n");
2497
        info = sdscatprintf(info,
2498 2499 2500
            "# Stats\r\n"
            "total_connections_received:%lld\r\n"
            "total_commands_processed:%lld\r\n"
2501
            "instantaneous_ops_per_sec:%lld\r\n"
2502
            "rejected_connections:%lld\r\n"
2503 2504 2505
            "sync_full:%lld\r\n"
            "sync_partial_ok:%lld\r\n"
            "sync_partial_err:%lld\r\n"
2506 2507 2508 2509 2510
            "expired_keys:%lld\r\n"
            "evicted_keys:%lld\r\n"
            "keyspace_hits:%lld\r\n"
            "keyspace_misses:%lld\r\n"
            "pubsub_channels:%ld\r\n"
2511
            "pubsub_patterns:%lu\r\n"
2512 2513
            "latest_fork_usec:%lld\r\n"
            "migrate_cached_sockets:%ld\r\n",
2514 2515
            server.stat_numconnections,
            server.stat_numcommands,
2516
            getOperationsPerSecond(),
2517
            server.stat_rejected_conn,
2518 2519 2520
            server.stat_sync_full,
            server.stat_sync_partial_ok,
            server.stat_sync_partial_err,
2521 2522 2523 2524 2525
            server.stat_expiredkeys,
            server.stat_evictedkeys,
            server.stat_keyspace_hits,
            server.stat_keyspace_misses,
            dictSize(server.pubsub_channels),
2526
            listLength(server.pubsub_patterns),
2527 2528
            server.stat_fork_time,
            dictSize(server.migrate_cached_sockets));
2529
    }
A
antirez 已提交
2530

2531 2532 2533 2534 2535 2536 2537 2538
    /* Replication */
    if (allsections || defsections || !strcasecmp(section,"replication")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
            "# Replication\r\n"
            "role:%s\r\n",
            server.masterhost == NULL ? "master" : "slave");
        if (server.masterhost) {
2539 2540 2541 2542 2543 2544 2545
            long long slave_repl_offset = 1;

            if (server.master)
                slave_repl_offset = server.master->reploff;
            else if (server.cached_master)
                slave_repl_offset = server.cached_master->reploff;

2546 2547 2548 2549 2550 2551
            info = sdscatprintf(info,
                "master_host:%s\r\n"
                "master_port:%d\r\n"
                "master_link_status:%s\r\n"
                "master_last_io_seconds_ago:%d\r\n"
                "master_sync_in_progress:%d\r\n"
2552
                "slave_repl_offset:%lld\r\n"
2553 2554
                ,server.masterhost,
                server.masterport,
A
antirez 已提交
2555
                (server.repl_state == REDIS_REPL_CONNECTED) ?
2556 2557
                    "up" : "down",
                server.master ?
2558
                ((int)(server.unixtime-server.master->lastinteraction)) : -1,
2559
                server.repl_state == REDIS_REPL_TRANSFER,
2560
                slave_repl_offset
2561 2562
            );

A
antirez 已提交
2563
            if (server.repl_state == REDIS_REPL_TRANSFER) {
2564
                info = sdscatprintf(info,
2565
                    "master_sync_left_bytes:%lld\r\n"
2566
                    "master_sync_last_io_seconds_ago:%d\r\n"
2567 2568
                    , (long long)
                        (server.repl_transfer_size - server.repl_transfer_read),
2569
                    (int)(server.unixtime-server.repl_transfer_lastio)
2570 2571
                );
            }
2572

A
antirez 已提交
2573
            if (server.repl_state != REDIS_REPL_CONNECTED) {
2574
                info = sdscatprintf(info,
Y
YAMAMOTO Takashi 已提交
2575 2576
                    "master_link_down_since_seconds:%jd\r\n",
                    (intmax_t)server.unixtime-server.repl_down_since);
2577
            }
2578
            info = sdscatprintf(info,
2579 2580 2581 2582
                "slave_priority:%d\r\n"
                "slave_read_only:%d\r\n",
                server.slave_priority,
                server.repl_slave_ro);
A
antirez 已提交
2583
        }
2584

2585
        info = sdscatprintf(info,
2586
            "connected_slaves:%lu\r\n",
2587
            listLength(server.slaves));
2588 2589 2590 2591 2592 2593 2594 2595 2596 2597

        /* If min-slaves-to-write is active, write the number of slaves
         * currently considered 'good'. */
        if (server.repl_min_slaves_to_write &&
            server.repl_min_slaves_max_lag) {
            info = sdscatprintf(info,
                "min_slaves_good_slaves:%d\r\n",
                server.repl_good_slaves_count);
        }

2598 2599 2600 2601 2602 2603 2604 2605 2606
        if (listLength(server.slaves)) {
            int slaveid = 0;
            listNode *ln;
            listIter li;

            listRewind(server.slaves,&li);
            while((ln = listNext(&li))) {
                redisClient *slave = listNodeValue(ln);
                char *state = NULL;
2607
                char ip[REDIS_IP_STR_LEN];
2608
                int port;
2609
                long lag = 0;
2610

2611
                if (anetPeerToString(slave->fd,ip,sizeof(ip),&port) == -1) continue;
2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624
                switch(slave->replstate) {
                case REDIS_REPL_WAIT_BGSAVE_START:
                case REDIS_REPL_WAIT_BGSAVE_END:
                    state = "wait_bgsave";
                    break;
                case REDIS_REPL_SEND_BULK:
                    state = "send_bulk";
                    break;
                case REDIS_REPL_ONLINE:
                    state = "online";
                    break;
                }
                if (state == NULL) continue;
2625 2626 2627 2628 2629
                if (slave->replstate == REDIS_REPL_ONLINE)
                    lag = time(NULL) - slave->repl_ack_time;

                info = sdscatprintf(info,
                    "slave%d:ip=%s,port=%d,state=%s,"
2630
                    "offset=%lld,lag=%ld\r\n",
2631
                    slaveid,ip,slave->slave_listening_port,state,
2632
                    slave->repl_ack_off, lag);
2633 2634 2635
                slaveid++;
            }
        }
2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
        info = sdscatprintf(info,
            "master_repl_offset:%lld\r\n"
            "repl_backlog_active:%d\r\n"
            "repl_backlog_size:%lld\r\n"
            "repl_backlog_first_byte_offset:%lld\r\n"
            "repl_backlog_histlen:%lld\r\n",
            server.master_repl_offset,
            server.repl_backlog != NULL,
            server.repl_backlog_size,
            server.repl_backlog_off,
            server.repl_backlog_histlen);
A
antirez 已提交
2647 2648
    }

2649 2650
    /* CPU */
    if (allsections || defsections || !strcasecmp(section,"cpu")) {
2651 2652
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
2653
        "# CPU\r\n"
2654 2655
        "used_cpu_sys:%.2f\r\n"
        "used_cpu_user:%.2f\r\n"
2656 2657
        "used_cpu_sys_children:%.2f\r\n"
        "used_cpu_user_children:%.2f\r\n",
2658
        (float)self_ru.ru_stime.tv_sec+(float)self_ru.ru_stime.tv_usec/1000000,
2659 2660 2661
        (float)self_ru.ru_utime.tv_sec+(float)self_ru.ru_utime.tv_usec/1000000,
        (float)c_ru.ru_stime.tv_sec+(float)c_ru.ru_stime.tv_usec/1000000,
        (float)c_ru.ru_utime.tv_sec+(float)c_ru.ru_utime.tv_usec/1000000);
2662
    }
2663

2664 2665 2666 2667
    /* cmdtime */
    if (allsections || !strcasecmp(section,"commandstats")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info, "# Commandstats\r\n");
2668
        numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
2669
        for (j = 0; j < numcommands; j++) {
2670
            struct redisCommand *c = redisCommandTable+j;
2671

2672 2673 2674 2675 2676
            if (!c->calls) continue;
            info = sdscatprintf(info,
                "cmdstat_%s:calls=%lld,usec=%lld,usec_per_call=%.2f\r\n",
                c->name, c->calls, c->microseconds,
                (c->calls == 0) ? 0 : ((float)c->microseconds/c->calls));
2677
        }
A
antirez 已提交
2678 2679
    }

2680
    /* Cluster */
2681 2682 2683 2684 2685 2686 2687 2688
    if (allsections || defsections || !strcasecmp(section,"cluster")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
        "# Cluster\r\n"
        "cluster_enabled:%d\r\n",
        server.cluster_enabled);
    }

2689 2690 2691 2692 2693 2694
    /* Key space */
    if (allsections || defsections || !strcasecmp(section,"keyspace")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info, "# Keyspace\r\n");
        for (j = 0; j < server.dbnum; j++) {
            long long keys, vkeys;
2695

2696 2697 2698
            keys = dictSize(server.db[j].dict);
            vkeys = dictSize(server.db[j].expires);
            if (keys || vkeys) {
2699 2700 2701
                info = sdscatprintf(info,
                    "db%d:keys=%lld,expires=%lld,avg_ttl=%lld\r\n",
                    j, keys, vkeys, server.db[j].avg_ttl);
2702
            }
2703 2704 2705 2706 2707 2708
        }
    }
    return info;
}

void infoCommand(redisClient *c) {
2709 2710 2711 2712 2713 2714 2715
    char *section = c->argc == 2 ? c->argv[1]->ptr : "default";

    if (c->argc > 2) {
        addReply(c,shared.syntaxerr);
        return;
    }
    sds info = genRedisInfoString(section);
2716 2717 2718 2719 2720 2721 2722
    addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
        (unsigned long)sdslen(info)));
    addReplySds(c,info);
    addReply(c,shared.crlf);
}

void monitorCommand(redisClient *c) {
2723
    /* ignore MONITOR if already slave or in monitor mode */
2724 2725 2726 2727 2728 2729 2730 2731 2732 2733
    if (c->flags & REDIS_SLAVE) return;

    c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
    listAddNodeTail(server.monitors,c);
    addReply(c,shared.ok);
}

/* ============================ Maxmemory directive  ======================== */

/* This function gets called when 'maxmemory' is set on the config file to limit
2734
 * the max memory used by the server, before processing a command.
2735
 *
2736 2737
 * The goal of the function is to free enough memory to keep Redis under the
 * configured memory limit.
2738
 *
2739 2740 2741 2742 2743 2744 2745 2746
 * The function starts calculating how many bytes should be freed to keep
 * Redis under the limit, and enters a loop selecting the best keys to
 * evict accordingly to the configured policy.
 *
 * If all the bytes needed to return back under the limit were freed the
 * function returns REDIS_OK, otherwise REDIS_ERR is returned, and the caller
 * should block the execution of commands that will result in more memory
 * used by the server.
2747
 */
2748 2749 2750 2751
int freeMemoryIfNeeded(void) {
    size_t mem_used, mem_tofree, mem_freed;
    int slaves = listLength(server.slaves);

2752 2753
    /* Remove the size of slaves output buffers and AOF buffer from the
     * count of used memory. */
2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768
    mem_used = zmalloc_used_memory();
    if (slaves) {
        listIter li;
        listNode *ln;

        listRewind(server.slaves,&li);
        while((ln = listNext(&li))) {
            redisClient *slave = listNodeValue(ln);
            unsigned long obuf_bytes = getClientOutputBufferMemoryUsage(slave);
            if (obuf_bytes > mem_used)
                mem_used = 0;
            else
                mem_used -= obuf_bytes;
        }
    }
2769 2770
    if (server.aof_state != REDIS_AOF_OFF) {
        mem_used -= sdslen(server.aof_buf);
2771
        mem_used -= aofRewriteBufferSize();
2772
    }
2773

2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784
    /* Check if we are over the memory limit. */
    if (mem_used <= server.maxmemory) return REDIS_OK;

    if (server.maxmemory_policy == REDIS_MAXMEMORY_NO_EVICTION)
        return REDIS_ERR; /* We need to free memory, but policy forbids. */

    /* Compute how much memory we need to free. */
    mem_tofree = mem_used - server.maxmemory;
    mem_freed = 0;
    while (mem_freed < mem_tofree) {
        int j, k, keys_freed = 0;
2785

2786
        for (j = 0; j < server.dbnum; j++) {
2787
            long bestval = 0; /* just to prevent warning */
2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806
            sds bestkey = NULL;
            struct dictEntry *de;
            redisDb *db = server.db+j;
            dict *dict;

            if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM)
            {
                dict = server.db[j].dict;
            } else {
                dict = server.db[j].expires;
            }
            if (dictSize(dict) == 0) continue;

            /* volatile-random and allkeys-random policy */
            if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM ||
                server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
            {
                de = dictGetRandomKey(dict);
2807
                bestkey = dictGetKey(de);
2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819
            }

            /* volatile-lru and allkeys-lru policy */
            else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
            {
                for (k = 0; k < server.maxmemory_samples; k++) {
                    sds thiskey;
                    long thisval;
                    robj *o;

                    de = dictGetRandomKey(dict);
2820
                    thiskey = dictGetKey(de);
2821
                    /* When policy is volatile-lru we need an additional lookup
2822 2823 2824
                     * to locate the real key, as dict is set to db->expires. */
                    if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
                        de = dictFind(db->dict, thiskey);
2825
                    o = dictGetVal(de);
2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842
                    thisval = estimateObjectIdleTime(o);

                    /* Higher idle time is better candidate for deletion */
                    if (bestkey == NULL || thisval > bestval) {
                        bestkey = thiskey;
                        bestval = thisval;
                    }
                }
            }

            /* volatile-ttl */
            else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) {
                for (k = 0; k < server.maxmemory_samples; k++) {
                    sds thiskey;
                    long thisval;

                    de = dictGetRandomKey(dict);
2843 2844
                    thiskey = dictGetKey(de);
                    thisval = (long) dictGetVal(de);
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856

                    /* Expire sooner (minor expire unix timestamp) is better
                     * candidate for deletion */
                    if (bestkey == NULL || thisval < bestval) {
                        bestkey = thiskey;
                        bestval = thisval;
                    }
                }
            }

            /* Finally remove the selected key. */
            if (bestkey) {
2857 2858
                long long delta;

2859
                robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
2860
                propagateExpire(db,keyobj);
2861 2862 2863 2864 2865 2866 2867 2868 2869
                /* We compute the amount of memory freed by dbDelete() alone.
                 * It is possible that actually the memory needed to propagate
                 * the DEL in AOF and replication link is greater than the one
                 * we are freeing removing the key, but we can't account for
                 * that otherwise we would never exit the loop.
                 *
                 * AOF and Output buffer memory will be freed eventually so
                 * we only care about memory used by the key space. */
                delta = (long long) zmalloc_used_memory();
2870
                dbDelete(db,keyobj);
2871 2872
                delta -= (long long) zmalloc_used_memory();
                mem_freed += delta;
2873
                server.stat_evictedkeys++;
2874 2875
                notifyKeyspaceEvent(REDIS_NOTIFY_EVICTED, "evicted",
                    keyobj, db->id);
2876
                decrRefCount(keyobj);
2877 2878 2879 2880 2881 2882
                keys_freed++;

                /* When the memory to free starts to be big enough, we may
                 * start spending so much time here that is impossible to
                 * deliver data to the slaves fast enough, so we force the
                 * transmission here inside the loop. */
A
antirez 已提交
2883
                if (slaves) flushSlavesOutputBuffers();
2884 2885
            }
        }
2886
        if (!keys_freed) return REDIS_ERR; /* nothing to free... */
2887
    }
2888
    return REDIS_OK;
2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914
}

/* =================================== Main! ================================ */

#ifdef __linux__
int linuxOvercommitMemoryValue(void) {
    FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r");
    char buf[64];

    if (!fp) return -1;
    if (fgets(buf,64,fp) == NULL) {
        fclose(fp);
        return -1;
    }
    fclose(fp);

    return atoi(buf);
}

void linuxOvercommitMemoryWarning(void) {
    if (linuxOvercommitMemoryValue() == 0) {
        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.");
    }
}
#endif /* __linux__ */

2915 2916 2917 2918
void createPidFile(void) {
    /* Try to write the pid file in a best-effort way. */
    FILE *fp = fopen(server.pidfile,"w");
    if (fp) {
2919
        fprintf(fp,"%d\n",(int)getpid());
2920 2921 2922 2923
        fclose(fp);
    }
}

2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941
void daemonize(void) {
    int fd;

    if (fork() != 0) exit(0); /* parent exits */
    setsid(); /* create a new session */

    /* Every output goes to /dev/null. If Redis is daemonized but
     * the 'logfile' is set to 'stdout' in the configuration file
     * it will not log at all. */
    if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
        dup2(fd, STDIN_FILENO);
        dup2(fd, STDOUT_FILENO);
        dup2(fd, STDERR_FILENO);
        if (fd > STDERR_FILENO) close(fd);
    }
}

void version() {
2942
    printf("Redis server v=%s sha=%s:%d malloc=%s bits=%d build=%llx\n",
A
antirez 已提交
2943 2944 2945 2946
        REDIS_VERSION,
        redisGitSHA1(),
        atoi(redisGitDirty()) > 0,
        ZMALLOC_LIB,
2947
        sizeof(long) == 4 ? 32 : 64,
2948
        (unsigned long long) redisBuildId());
2949 2950 2951 2952
    exit(0);
}

void usage() {
2953
    fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf] [options]\n");
2954
    fprintf(stderr,"       ./redis-server - (read config from stdin)\n");
2955
    fprintf(stderr,"       ./redis-server -v or --version\n");
2956 2957
    fprintf(stderr,"       ./redis-server -h or --help\n");
    fprintf(stderr,"       ./redis-server --test-memory <megabytes>\n\n");
2958 2959 2960 2961 2962
    fprintf(stderr,"Examples:\n");
    fprintf(stderr,"       ./redis-server (run the server with default conf)\n");
    fprintf(stderr,"       ./redis-server /etc/redis/6379.conf\n");
    fprintf(stderr,"       ./redis-server --port 7777\n");
    fprintf(stderr,"       ./redis-server --port 7777 --slaveof 127.0.0.1 8888\n");
2963 2964 2965
    fprintf(stderr,"       ./redis-server /etc/myredis.conf --loglevel verbose\n\n");
    fprintf(stderr,"Sentinel mode:\n");
    fprintf(stderr,"       ./redis-server /etc/sentinel.conf --sentinel\n");
2966 2967 2968
    exit(1);
}

A
antirez 已提交
2969 2970 2971
void redisAsciiArt(void) {
#include "asciilogo.h"
    char *buf = zmalloc(1024*16);
2972 2973 2974 2975
    char *mode = "stand alone";

    if (server.cluster_enabled) mode = "cluster";
    else if (server.sentinel_mode) mode = "sentinel";
A
antirez 已提交
2976 2977 2978 2979 2980 2981

    snprintf(buf,1024*16,ascii_logo,
        REDIS_VERSION,
        redisGitSHA1(),
        strtol(redisGitDirty(),NULL,10) > 0,
        (sizeof(long) == 8) ? "64" : "32",
2982
        mode, server.port,
A
antirez 已提交
2983 2984 2985 2986 2987 2988
        (long) getpid()
    );
    redisLogRaw(REDIS_NOTICE|REDIS_LOG_RAW,buf);
    zfree(buf);
}

2989
static void sigtermHandler(int sig) {
2990 2991
    REDIS_NOTUSED(sig);

A
antirez 已提交
2992
    redisLogFromHandler(REDIS_WARNING,"Received SIGTERM, scheduling shutdown...");
2993 2994 2995
    server.shutdown_asap = 1;
}

2996
void setupSignalHandlers(void) {
2997 2998
    struct sigaction act;

2999 3000 3001
    /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction is used.
     * Otherwise, sa_handler is used. */
    sigemptyset(&act.sa_mask);
3002
    act.sa_flags = 0;
3003
    act.sa_handler = sigtermHandler;
3004
    sigaction(SIGTERM, &act, NULL);
3005

3006 3007
#ifdef HAVE_BACKTRACE
    sigemptyset(&act.sa_mask);
3008
    act.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
3009 3010 3011 3012 3013 3014 3015
    act.sa_sigaction = sigsegvHandler;
    sigaction(SIGSEGV, &act, NULL);
    sigaction(SIGBUS, &act, NULL);
    sigaction(SIGFPE, &act, NULL);
    sigaction(SIGILL, &act, NULL);
#endif
    return;
3016 3017
}

3018 3019
void memtest(size_t megabytes, int passes);

3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041
/* Returns 1 if there is --sentinel among the arguments or if
 * argv[0] is exactly "redis-sentinel". */
int checkForSentinelMode(int argc, char **argv) {
    int j;

    if (strstr(argv[0],"redis-sentinel") != NULL) return 1;
    for (j = 1; j < argc; j++)
        if (!strcmp(argv[j],"--sentinel")) return 1;
    return 0;
}

/* Function called at startup to load RDB or AOF file in memory. */
void loadDataFromDisk(void) {
    long long start = ustime();
    if (server.aof_state == REDIS_AOF_ON) {
        if (loadAppendOnlyFile(server.aof_filename) == REDIS_OK)
            redisLog(REDIS_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);
    } else {
        if (rdbLoad(server.rdb_filename) == REDIS_OK) {
            redisLog(REDIS_NOTICE,"DB loaded from disk: %.3f seconds",
                (float)(ustime()-start)/1000000);
        } else if (errno != ENOENT) {
3042
            redisLog(REDIS_WARNING,"Fatal error loading the DB: %s. Exiting.",strerror(errno));
3043 3044 3045 3046 3047
            exit(1);
        }
    }
}

A
antirez 已提交
3048 3049 3050
void redisOutOfMemoryHandler(size_t allocation_size) {
    redisLog(REDIS_WARNING,"Out Of Memory allocating %zu bytes!",
        allocation_size);
3051
    redisPanic("Redis aborting for OUT OF MEMORY");
A
antirez 已提交
3052 3053
}

3054
void redisSetProcTitle(char *title) {
3055
#ifdef USE_SETPROCTITLE
3056 3057
    setproctitle("%s %s:%d",
        title,
A
antirez 已提交
3058
        server.bindaddr_count ? server.bindaddr[0] : "*",
3059
        server.port);
3060 3061 3062
#else
    REDIS_NOTUSED(title);
#endif
3063 3064
}

3065
int main(int argc, char **argv) {
3066
    struct timeval tv;
3067

A
antirez 已提交
3068
    /* We need to initialize our libraries, and the server configuration. */
3069 3070 3071
#ifdef INIT_SETPROCTITLE_REPLACEMENT
    spt_init(argc, argv);
#endif
3072
    setlocale(LC_COLLATE,"");
3073
    zmalloc_enable_thread_safeness();
A
antirez 已提交
3074
    zmalloc_set_oom_handler(redisOutOfMemoryHandler);
3075 3076 3077
    srand(time(NULL)^getpid());
    gettimeofday(&tv,NULL);
    dictSetHashFunctionSeed(tv.tv_sec^tv.tv_usec^getpid());
3078
    server.sentinel_mode = checkForSentinelMode(argc,argv);
3079
    initServerConfig();
3080

3081 3082 3083 3084 3085 3086 3087 3088
    /* We need to init sentinel right now as parsing the configuration file
     * in sentinel mode will have the effect of populating the sentinel
     * data structures with master nodes to monitor. */
    if (server.sentinel_mode) {
        initSentinelConfig();
        initSentinel();
    }

3089 3090 3091 3092 3093 3094
    if (argc >= 2) {
        int j = 1; /* First option to parse in argv[] */
        sds options = sdsempty();
        char *configfile = NULL;

        /* Handle special options --help and --version */
3095 3096
        if (strcmp(argv[1], "-v") == 0 ||
            strcmp(argv[1], "--version") == 0) version();
3097 3098
        if (strcmp(argv[1], "--help") == 0 ||
            strcmp(argv[1], "-h") == 0) usage();
3099 3100
        if (strcmp(argv[1], "--test-memory") == 0) {
            if (argc == 3) {
3101
                memtest(atoi(argv[2]),50);
3102 3103 3104 3105 3106 3107 3108 3109
                exit(0);
            } else {
                fprintf(stderr,"Please specify the amount of memory to test in megabytes.\n");
                fprintf(stderr,"Example: ./redis-server --test-memory 4096\n\n");
                exit(1);
            }
        }

3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129
        /* First argument is the config file name? */
        if (argv[j][0] != '-' || argv[j][1] != '-')
            configfile = argv[j++];
        /* All the other options are parsed and conceptually appended to the
         * configuration file. For instance --port 6380 will generate the
         * string "port 6380\n" to be parsed after the actual file name
         * is parsed, if any. */
        while(j != argc) {
            if (argv[j][0] == '-' && argv[j][1] == '-') {
                /* Option name */
                if (sdslen(options)) options = sdscat(options,"\n");
                options = sdscat(options,argv[j]+2);
                options = sdscat(options," ");
            } else {
                /* Option argument */
                options = sdscatrepr(options,argv[j],strlen(argv[j]));
                options = sdscat(options," ");
            }
            j++;
        }
3130
        resetServerSaveParams();
3131 3132
        loadServerConfig(configfile,options);
        sdsfree(options);
3133
        if (configfile) server.configfile = getAbsolutePath(configfile);
3134
    } else {
3135
        redisLog(REDIS_WARNING, "Warning: no config file specified, using the default config. In order to specify a config file use %s /path/to/%s.conf", argv[0], server.sentinel_mode ? "sentinel" : "redis");
3136 3137 3138 3139
    }
    if (server.daemonize) daemonize();
    initServer();
    if (server.daemonize) createPidFile();
3140
    redisSetProcTitle(argv[0]);
3141
    redisAsciiArt();
3142 3143

    if (!server.sentinel_mode) {
A
antirez 已提交
3144
        /* Things not needed when running in Sentinel mode. */
3145 3146 3147 3148 3149
        redisLog(REDIS_WARNING,"Server started, Redis version " REDIS_VERSION);
    #ifdef __linux__
        linuxOvercommitMemoryWarning();
    #endif
        loadDataFromDisk();
3150 3151 3152 3153 3154 3155 3156 3157
        if (server.cluster_enabled) {
            if (verifyClusterConfigWithData() == REDIS_ERR) {
                redisLog(REDIS_WARNING,
                    "You can't have keys in a DB different than DB 0 when in "
                    "Cluster mode. Exiting.");
                exit(1);
            }
        }
3158
        if (server.ipfd_count > 0)
3159 3160 3161
            redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);
        if (server.sofd > 0)
            redisLog(REDIS_NOTICE,"The server is now ready to accept connections at %s", server.unixsocket);
3162
    } else {
A
antirez 已提交
3163
        sentinelIsRunning();
3164
    }
3165

3166 3167 3168 3169 3170
    /* Warning the user about suspicious maxmemory setting. */
    if (server.maxmemory > 0 && server.maxmemory < 1024*1024) {
        redisLog(REDIS_WARNING,"WARNING: You specified a maxmemory value that is less than 1MB (current value is %llu bytes). Are you sure this is what you really want?", server.maxmemory);
    }

3171 3172 3173 3174 3175 3176
    aeSetBeforeSleepProc(server.el,beforeSleep);
    aeMain(server.el);
    aeDeleteEventLoop(server.el);
    return 0;
}

3177
/* The End */