X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/9f3c422c72d4cede717b5f61bb7bde5823db53f2..123d7c93cb73a0d09f2a8b34322f1a0f4acc71ba:/redis.c diff --git a/redis.c b/redis.c index ff8db0be..607c827a 100644 --- a/redis.c +++ b/redis.c @@ -27,16 +27,24 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#define REDIS_VERSION "0.101" +#define REDIS_VERSION "0.900" #include "fmacros.h" +#include "config.h" #include #include #include #include #include +#define __USE_POSIX199309 #include + +#ifdef HAVE_BACKTRACE +#include +#include +#endif /* HAVE_BACKTRACE */ + #include #include #include @@ -49,8 +57,8 @@ #include #include #include -#include +#include "redis.h" #include "ae.h" /* Event driven programming library */ #include "sds.h" /* Dynamic safe strings */ #include "anet.h" /* Networking the easy way */ @@ -60,8 +68,6 @@ #include "lzf.h" /* LZF compression library */ #include "pqsort.h" /* Partial qsort for SORT+LIMIT */ -#include "config.h" - /* Error codes */ #define REDIS_OK 0 #define REDIS_ERR -1 @@ -77,10 +83,11 @@ #define REDIS_OBJFREELIST_MAX 1000000 /* Max number of objects to cache */ #define REDIS_MAX_SYNC_TIME 60 /* Slave can't take more to sync */ #define REDIS_EXPIRELOOKUPS_PER_CRON 100 /* try to expire 100 keys/second */ +#define REDIS_MAX_WRITE_PER_EVENT (1024*64) +#define REDIS_REQUEST_MAX_SIZE (1024*1024*256) /* max bytes in inline command */ /* Hash table parameters */ #define REDIS_HT_MINFILL 10 /* Minimal hash table fill 10% */ -#define REDIS_HT_MINSLOTS 16384 /* Never resize the HT under this */ /* Command flags */ #define REDIS_CMD_BULK 1 /* Bulk write command */ @@ -170,6 +177,7 @@ /* Anti-warning macro... */ #define REDIS_NOTUSED(V) ((void) V) + /*================================= Data types ============================== */ /* A redis object, that is a type able to hold a string / list / set */ @@ -271,6 +279,11 @@ struct redisCommand { int flags; }; +struct redisFunctionSym { + char *name; + unsigned long pointer; +}; + typedef struct _redisSortObject { robj *obj; union { @@ -316,8 +329,11 @@ static int deleteIfVolatile(redisDb *db, robj *key); static int deleteKey(redisDb *db, robj *key); static time_t getExpire(redisDb *db, robj *key); static int setExpire(redisDb *db, robj *key, time_t when); -static void updateSalvesWaitingBgsave(int bgsaveerr); +static void updateSlavesWaitingBgsave(int bgsaveerr); static void freeMemoryIfNeeded(void); +static int processCommand(redisClient *c); +static void setupSigSegvAction(void); +static void rdbRemoveTempFile(pid_t childpid); static void authCommand(redisClient *c); static void pingCommand(redisClient *c); @@ -357,6 +373,7 @@ static void sremCommand(redisClient *c); static void smoveCommand(redisClient *c); static void sismemberCommand(redisClient *c); static void scardCommand(redisClient *c); +static void spopCommand(redisClient *c); static void sinterCommand(redisClient *c); static void sinterstoreCommand(redisClient *c); static void sunionCommand(redisClient *c); @@ -376,7 +393,6 @@ static void getSetCommand(redisClient *c); static void ttlCommand(redisClient *c); static void slaveofCommand(redisClient *c); static void debugCommand(redisClient *c); - /*================================= Globals ================================= */ /* Global vars */ @@ -405,6 +421,7 @@ static struct redisCommand cmdTable[] = { {"smove",smoveCommand,4,REDIS_CMD_BULK}, {"sismember",sismemberCommand,3,REDIS_CMD_BULK}, {"scard",scardCommand,2,REDIS_CMD_INLINE}, + {"spop",spopCommand,2,REDIS_CMD_INLINE}, {"sinter",sinterCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM}, {"sinterstore",sinterstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM}, {"sunion",sunionCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM}, @@ -442,7 +459,6 @@ static struct redisCommand cmdTable[] = { {"debug",debugCommand,-2,REDIS_CMD_INLINE}, {NULL,NULL,0,0} }; - /*============================ Utility functions ============================ */ /* Glob-style pattern matching. */ @@ -568,8 +584,7 @@ int stringmatchlen(const char *pattern, int patternLen, return 0; } -void redisLog(int level, const char *fmt, ...) -{ +static void redisLog(int level, const char *fmt, ...) { va_list ap; FILE *fp; @@ -664,7 +679,7 @@ static void oom(const char *msg) { } /* ====================== Redis server networking stuff ===================== */ -void closeTimedoutClients(void) { +static void closeTimedoutClients(void) { redisClient *c; listNode *ln; time_t now = time(NULL); @@ -681,26 +696,32 @@ void closeTimedoutClients(void) { } } +static 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 */ -void tryResizeHashTables(void) { +static void tryResizeHashTables(void) { int j; for (j = 0; j < server.dbnum; j++) { - long long size, used; - - size = dictSlots(server.db[j].dict); - used = dictSize(server.db[j].dict); - if (size && used && size > REDIS_HT_MINSLOTS && - (used*100/size < REDIS_HT_MINFILL)) { - redisLog(REDIS_NOTICE,"The hash table %d is too sparse, resize it...",j); + if (htNeedsResize(server.db[j].dict)) { + redisLog(REDIS_DEBUG,"The hash table %d is too sparse, resize it...",j); dictResize(server.db[j].dict); - redisLog(REDIS_NOTICE,"Hash table %d resized.",j); + redisLog(REDIS_DEBUG,"Hash table %d resized.",j); } + if (htNeedsResize(server.db[j].expires)) + dictResize(server.db[j].expires); } } -int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { +static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { int j, loops = server.cronloops++; REDIS_NOTUSED(eventLoop); REDIS_NOTUSED(id); @@ -716,8 +737,8 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { size = dictSlots(server.db[j].dict); used = dictSize(server.db[j].dict); vkeys = dictSize(server.db[j].expires); - if (!(loops % 5) && used > 0) { - redisLog(REDIS_DEBUG,"DB %d: %d keys (%d volatile) in %d slots HT.",j,used,vkeys,size); + if (!(loops % 5) && (used || vkeys)) { + redisLog(REDIS_DEBUG,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size); /* dictPrintStats(server.dict); */ } } @@ -732,7 +753,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { /* Show information about connected clients */ if (!(loops % 5)) { - redisLog(REDIS_DEBUG,"%d clients connected (%d slaves), %zu bytes in use", + redisLog(REDIS_DEBUG,"%d clients connected (%d slaves), %zu bytes in use, %d shared objects", listLength(server.clients)-listLength(server.slaves), listLength(server.slaves), server.usedmemory, @@ -746,7 +767,6 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { /* Check if a background saving in progress terminated */ if (server.bgsaveinprogress) { int statloc; - /* XXX: TODO handle the case of the saving child killed */ if (wait4(-1,&statloc,WNOHANG,NULL)) { int exitcode = WEXITSTATUS(statloc); int bysignal = WIFSIGNALED(statloc); @@ -761,10 +781,11 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { } else { redisLog(REDIS_WARNING, "Background saving terminated by signal"); + rdbRemoveTempFile(server.bgsavechildpid); } server.bgsaveinprogress = 0; server.bgsavechildpid = -1; - updateSalvesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR); + updateSlavesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR); } } else { /* If there is not a background saving in progress check if @@ -881,6 +902,7 @@ static void initServerConfig() { server.dbfilename = "dump.rdb"; server.requirepass = NULL; server.shareobjects = 0; + server.sharingpoolsize = 1024; server.maxclients = 0; server.maxmemory = 0; ResetServerSaveParams(); @@ -901,6 +923,7 @@ static void initServer() { signal(SIGHUP, SIG_IGN); signal(SIGPIPE, SIG_IGN); + setupSigSegvAction(); server.clients = listCreate(); server.slaves = listCreate(); @@ -910,7 +933,6 @@ static void initServer() { server.el = aeCreateEventLoop(); server.db = zmalloc(sizeof(redisDb)*server.dbnum); server.sharingpool = dictCreate(&setDictType,NULL); - server.sharingpoolsize = 1024; if (!server.db || !server.clients || !server.slaves || !server.monitors || !server.el || !server.objfreelist) oom("server initialization"); /* Fatal OOM */ server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr); @@ -957,15 +979,20 @@ static int yesnotoi(char *s) { /* I agree, this is a very rudimental way to load a configuration... will improve later if the config gets more complex */ static void loadServerConfig(char *filename) { - FILE *fp = fopen(filename,"r"); + FILE *fp; char buf[REDIS_CONFIGLINE_MAX+1], *err = NULL; int linenum = 0; sds line = NULL; - - if (!fp) { - redisLog(REDIS_WARNING,"Fatal error, can't open config file"); - exit(1); + + if (filename[0] == '-' && filename[1] == '\0') + fp = stdin; + else { + if ((fp = fopen(filename,"r")) == NULL) { + redisLog(REDIS_WARNING,"Fatal error, can't open config file"); + exit(1); + } } + while(fgets(buf,REDIS_CONFIGLINE_MAX+1,fp) != NULL) { sds *argv; int argc, j; @@ -1019,7 +1046,7 @@ static void loadServerConfig(char *filename) { goto loaderr; } } else if (!strcasecmp(argv[0],"logfile") && argc == 2) { - FILE *fp; + FILE *logfp; server.logfile = zstrdup(argv[1]); if (!strcasecmp(server.logfile,"stdout")) { @@ -1029,13 +1056,13 @@ static void loadServerConfig(char *filename) { if (server.logfile) { /* Test if we are able to open the file. The server will not * be able to abort just for this problem later... */ - fp = fopen(server.logfile,"a"); - if (fp == NULL) { + logfp = fopen(server.logfile,"a"); + if (logfp == NULL) { err = sdscatprintf(sdsempty(), "Can't open the log file: %s", strerror(errno)); goto loaderr; } - fclose(fp); + fclose(logfp); } } else if (!strcasecmp(argv[0],"databases") && argc == 2) { server.dbnum = atoi(argv[1]); @@ -1081,7 +1108,7 @@ static void loadServerConfig(char *filename) { zfree(argv); sdsfree(line); } - fclose(fp); + if (fp != stdin) fclose(fp); return; loaderr: @@ -1177,6 +1204,7 @@ static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) } if (c->flags & REDIS_MASTER) { + /* Don't reply to a master */ nwritten = objlen - c->sentlen; } else { nwritten = write(fd, ((char*)o->ptr)+c->sentlen, objlen - c->sentlen); @@ -1189,6 +1217,12 @@ static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) listDelNode(c->reply,listFirst(c->reply)); c->sentlen = 0; } + /* Note that we avoid to send more thank REDIS_MAX_WRITE_PER_EVENT + * bytes, in a single threaded server it's a good idea to server + * other clients as well, even if a very large request comes from + * super fast link that is always able to accept data (in real world + * terms think to 'KEYS *' against the loopback interfae) */ + if (totwritten > REDIS_MAX_WRITE_PER_EVENT) break; } if (nwritten == -1) { if (errno == EAGAIN) { @@ -1412,6 +1446,7 @@ again: /* Read the first line of the query */ char *p = strchr(c->querybuf,'\n'); size_t querylen; + if (p) { sds query, *argv; int argc, j; @@ -1453,9 +1488,9 @@ again: /* Execute the command. If the client is still valid * after processCommand() return and there is something * on the query buffer try to process the next command. */ - if (processCommand(c) && sdslen(c->querybuf)) goto again; + if (c->argc && processCommand(c) && sdslen(c->querybuf)) goto again; return; - } else if (sdslen(c->querybuf) >= 1024*32) { + } else if (sdslen(c->querybuf) >= REDIS_REQUEST_MAX_SIZE) { redisLog(REDIS_DEBUG, "Client protocol error"); freeClient(c); return; @@ -1765,7 +1800,7 @@ static int rdbSaveLen(FILE *fp, uint32_t len) { /* String objects in the form "2391" "-100" without any space and with a * range of values that can fit in an 8, 16 or 32 bit signed value can be * encoded as integers to save space */ -int rdbTryIntegerEncoding(sds s, unsigned char *enc) { +static int rdbTryIntegerEncoding(sds s, unsigned char *enc) { long long value; char *endptr, buf[32]; @@ -1869,7 +1904,7 @@ static int rdbSave(char *filename) { int j; time_t now = time(NULL); - snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random()); + snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid()); fp = fopen(tmpfile,"w"); if (!fp) { redisLog(REDIS_WARNING, "Failed saving the DB: %s", strerror(errno)); @@ -1996,6 +2031,13 @@ static int rdbSaveBackground(char *filename) { return REDIS_OK; /* unreached */ } +static void rdbRemoveTempFile(pid_t childpid) { + char tmpfile[256]; + + snprintf(tmpfile,256,"temp-%d.rdb", (int) childpid); + unlink(tmpfile); +} + static int rdbLoadType(FILE *fp) { unsigned char type; if (fread(&type,1,1,fp) == 0) return -1; @@ -2513,10 +2555,15 @@ static void bgsaveCommand(redisClient *c) { static void shutdownCommand(redisClient *c) { redisLog(REDIS_WARNING,"User requested shutdown, saving DB..."); + /* 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. */ if (server.bgsaveinprogress) { redisLog(REDIS_WARNING,"There is a live saving child. Killing it!"); kill(server.bgsavechildpid,SIGKILL); + rdbRemoveTempFile(server.bgsavechildpid); } + /* SYNC SAVE */ if (rdbSave(server.dbfilename) == REDIS_OK) { if (server.daemonize) unlink(server.pidfile); @@ -2524,6 +2571,10 @@ static void shutdownCommand(redisClient *c) { redisLog(REDIS_WARNING,"Server exit now, bye bye..."); exit(1); } else { + /* 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... */ redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit"); addReplySds(c,sdsnew("-ERR can't quit, problems saving the DB\r\n")); } @@ -2859,8 +2910,8 @@ static void ltrimCommand(redisClient *c) { ln = listLast(list); listDelNode(list,ln); } - addReply(c,shared.ok); server.dirty++; + addReply(c,shared.ok); } } } @@ -2941,6 +2992,7 @@ static void sremCommand(redisClient *c) { } if (dictDelete(set->ptr,c->argv[2]) == DICT_OK) { server.dirty++; + if (htNeedsResize(set->ptr)) dictResize(set->ptr); addReply(c,shared.cone); } else { addReply(c,shared.czero); @@ -3020,6 +3072,34 @@ static void scardCommand(redisClient *c) { } } +static void spopCommand(redisClient *c) { + robj *set; + dictEntry *de; + + set = lookupKeyWrite(c->db,c->argv[1]); + if (set == NULL) { + addReply(c,shared.nullbulk); + } else { + if (set->type != REDIS_SET) { + addReply(c,shared.wrongtypeerr); + return; + } + de = dictGetRandomKey(set->ptr); + if (de == NULL) { + addReply(c,shared.nullbulk); + } else { + robj *ele = dictGetEntryKey(de); + + addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(ele->ptr))); + addReply(c,ele); + addReply(c,shared.crlf); + dictDelete(set->ptr,ele); + if (htNeedsResize(set->ptr)) dictResize(set->ptr); + server.dirty++; + } + } +} + static int qsortCompareSetsByCardinality(const void *s1, const void *s2) { dict **d1 = (void*) s1, **d2 = (void*) s2; @@ -3255,7 +3335,7 @@ static void flushallCommand(redisClient *c) { server.dirty++; } -redisSortOperation *createSortOperation(int type, robj *pattern) { +static redisSortOperation *createSortOperation(int type, robj *pattern) { redisSortOperation *so = zmalloc(sizeof(*so)); if (!so) oom("createSortOperation"); so->type = type; @@ -3265,7 +3345,7 @@ redisSortOperation *createSortOperation(int type, robj *pattern) { /* Return the value associated to the key with a name obtained * substituting the first occurence of '*' in 'pattern' with 'subst' */ -robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) { +static robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) { char *p; sds spat, ssub; robj keyobj; @@ -3540,6 +3620,7 @@ static void sortCommand(redisClient *c) { static void infoCommand(redisClient *c) { sds info; time_t uptime = time(NULL)-server.stat_starttime; + int j; info = sdscatprintf(sdsempty(), "redis_version:%s\r\n" @@ -3580,6 +3661,16 @@ static void infoCommand(redisClient *c) { (int)(time(NULL)-server.master->lastinteraction) ); } + for (j = 0; j < server.dbnum; j++) { + long long keys, vkeys; + + keys = dictSize(server.db[j].dict); + vkeys = dictSize(server.db[j].expires); + if (keys || vkeys) { + info = sdscatprintf(info, "db%d: keys=%lld,expires=%lld\r\n", + j, keys, vkeys); + } + } addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(info))); addReplySds(c,info); addReply(c,shared.crlf); @@ -3669,10 +3760,12 @@ static void expireCommand(redisClient *c) { return; } else { time_t when = time(NULL)+seconds; - if (setExpire(c->db,c->argv[1],when)) + if (setExpire(c->db,c->argv[1],when)) { addReply(c,shared.cone); - else + server.dirty++; + } else { addReply(c,shared.czero); + } return; } } @@ -3866,7 +3959,13 @@ static void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) { } } -static void updateSalvesWaitingBgsave(int bgsaveerr) { +/* This function is called at the end of every backgrond saving. + * The argument bgsaveerr is REDIS_OK if the background saving succeeded + * otherwise REDIS_ERR is passed to the function. + * + * The goal of this function is to handle slaves waiting for a successful + * background saving in order to perform non-blocking synchronization. */ +static void updateSlavesWaitingBgsave(int bgsaveerr) { listNode *ln; int startbgsave = 0; @@ -4087,6 +4186,219 @@ static void debugCommand(redisClient *c) { } } +#ifdef HAVE_BACKTRACE +static struct redisFunctionSym symsTable[] = { +{"freeStringObject", (unsigned long)freeStringObject}, +{"freeListObject", (unsigned long)freeListObject}, +{"freeSetObject", (unsigned long)freeSetObject}, +{"decrRefCount", (unsigned long)decrRefCount}, +{"createObject", (unsigned long)createObject}, +{"freeClient", (unsigned long)freeClient}, +{"rdbLoad", (unsigned long)rdbLoad}, +{"addReply", (unsigned long)addReply}, +{"addReplySds", (unsigned long)addReplySds}, +{"incrRefCount", (unsigned long)incrRefCount}, +{"rdbSaveBackground", (unsigned long)rdbSaveBackground}, +{"createStringObject", (unsigned long)createStringObject}, +{"replicationFeedSlaves", (unsigned long)replicationFeedSlaves}, +{"syncWithMaster", (unsigned long)syncWithMaster}, +{"tryObjectSharing", (unsigned long)tryObjectSharing}, +{"removeExpire", (unsigned long)removeExpire}, +{"expireIfNeeded", (unsigned long)expireIfNeeded}, +{"deleteIfVolatile", (unsigned long)deleteIfVolatile}, +{"deleteKey", (unsigned long)deleteKey}, +{"getExpire", (unsigned long)getExpire}, +{"setExpire", (unsigned long)setExpire}, +{"updateSlavesWaitingBgsave", (unsigned long)updateSlavesWaitingBgsave}, +{"freeMemoryIfNeeded", (unsigned long)freeMemoryIfNeeded}, +{"authCommand", (unsigned long)authCommand}, +{"pingCommand", (unsigned long)pingCommand}, +{"echoCommand", (unsigned long)echoCommand}, +{"setCommand", (unsigned long)setCommand}, +{"setnxCommand", (unsigned long)setnxCommand}, +{"getCommand", (unsigned long)getCommand}, +{"delCommand", (unsigned long)delCommand}, +{"existsCommand", (unsigned long)existsCommand}, +{"incrCommand", (unsigned long)incrCommand}, +{"decrCommand", (unsigned long)decrCommand}, +{"incrbyCommand", (unsigned long)incrbyCommand}, +{"decrbyCommand", (unsigned long)decrbyCommand}, +{"selectCommand", (unsigned long)selectCommand}, +{"randomkeyCommand", (unsigned long)randomkeyCommand}, +{"keysCommand", (unsigned long)keysCommand}, +{"dbsizeCommand", (unsigned long)dbsizeCommand}, +{"lastsaveCommand", (unsigned long)lastsaveCommand}, +{"saveCommand", (unsigned long)saveCommand}, +{"bgsaveCommand", (unsigned long)bgsaveCommand}, +{"shutdownCommand", (unsigned long)shutdownCommand}, +{"moveCommand", (unsigned long)moveCommand}, +{"renameCommand", (unsigned long)renameCommand}, +{"renamenxCommand", (unsigned long)renamenxCommand}, +{"lpushCommand", (unsigned long)lpushCommand}, +{"rpushCommand", (unsigned long)rpushCommand}, +{"lpopCommand", (unsigned long)lpopCommand}, +{"rpopCommand", (unsigned long)rpopCommand}, +{"llenCommand", (unsigned long)llenCommand}, +{"lindexCommand", (unsigned long)lindexCommand}, +{"lrangeCommand", (unsigned long)lrangeCommand}, +{"ltrimCommand", (unsigned long)ltrimCommand}, +{"typeCommand", (unsigned long)typeCommand}, +{"lsetCommand", (unsigned long)lsetCommand}, +{"saddCommand", (unsigned long)saddCommand}, +{"sremCommand", (unsigned long)sremCommand}, +{"smoveCommand", (unsigned long)smoveCommand}, +{"sismemberCommand", (unsigned long)sismemberCommand}, +{"scardCommand", (unsigned long)scardCommand}, +{"spopCommand", (unsigned long)spopCommand}, +{"sinterCommand", (unsigned long)sinterCommand}, +{"sinterstoreCommand", (unsigned long)sinterstoreCommand}, +{"sunionCommand", (unsigned long)sunionCommand}, +{"sunionstoreCommand", (unsigned long)sunionstoreCommand}, +{"sdiffCommand", (unsigned long)sdiffCommand}, +{"sdiffstoreCommand", (unsigned long)sdiffstoreCommand}, +{"syncCommand", (unsigned long)syncCommand}, +{"flushdbCommand", (unsigned long)flushdbCommand}, +{"flushallCommand", (unsigned long)flushallCommand}, +{"sortCommand", (unsigned long)sortCommand}, +{"lremCommand", (unsigned long)lremCommand}, +{"infoCommand", (unsigned long)infoCommand}, +{"mgetCommand", (unsigned long)mgetCommand}, +{"monitorCommand", (unsigned long)monitorCommand}, +{"expireCommand", (unsigned long)expireCommand}, +{"getSetCommand", (unsigned long)getSetCommand}, +{"ttlCommand", (unsigned long)ttlCommand}, +{"slaveofCommand", (unsigned long)slaveofCommand}, +{"debugCommand", (unsigned long)debugCommand}, +{"processCommand", (unsigned long)processCommand}, +{"setupSigSegvAction", (unsigned long)setupSigSegvAction}, +{"readQueryFromClient", (unsigned long)readQueryFromClient}, +{"rdbRemoveTempFile", (unsigned long)rdbRemoveTempFile}, +{NULL,0} +}; + +/* This function try to convert a pointer into a function name. It's used in + * oreder to provide a backtrace under segmentation fault that's able to + * display functions declared as static (otherwise the backtrace is useless). */ +static char *findFuncName(void *pointer, unsigned long *offset){ + int i, ret = -1; + unsigned long off, minoff = 0; + + /* Try to match against the Symbol with the smallest offset */ + for (i=0; symsTable[i].pointer; i++) { + unsigned long lp = (unsigned long) pointer; + + if (lp != (unsigned long)-1 && lp >= symsTable[i].pointer) { + off=lp-symsTable[i].pointer; + if (ret < 0 || off < minoff) { + minoff=off; + ret=i; + } + } + } + if (ret == -1) return NULL; + *offset = minoff; + return symsTable[ret].name; +} + +static void *getMcontextEip(ucontext_t *uc) { +#if defined(__FreeBSD__) + return (void*) uc->uc_mcontext.mc_eip; +#elif defined(__dietlibc__) + return (void*) uc->uc_mcontext.eip; +#elif defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6) + return (void*) uc->uc_mcontext->__ss.__eip; +#elif defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6) + #ifdef _STRUCT_X86_THREAD_STATE64 + return (void*) uc->uc_mcontext->__ss.__rip; + #else + return (void*) uc->uc_mcontext->__ss.__eip; + #endif +#elif defined(__i386__) || defined(__X86_64__) /* Linux x86 */ + return (void*) uc->uc_mcontext.gregs[REG_EIP]; +#elif defined(__ia64__) /* Linux IA64 */ + return (void*) uc->uc_mcontext.sc_ip; +#else + return NULL; +#endif +} + +static void segvHandler(int sig, siginfo_t *info, void *secret) { + void *trace[100]; + char **messages = NULL; + int i, trace_size = 0; + unsigned long offset=0; + time_t uptime = time(NULL)-server.stat_starttime; + ucontext_t *uc = (ucontext_t*) secret; + REDIS_NOTUSED(info); + + redisLog(REDIS_WARNING, + "======= Ooops! Redis %s got signal: -%d- =======", REDIS_VERSION, sig); + redisLog(REDIS_WARNING, "%s", sdscatprintf(sdsempty(), + "redis_version:%s; " + "uptime_in_seconds:%d; " + "connected_clients:%d; " + "connected_slaves:%d; " + "used_memory:%zu; " + "changes_since_last_save:%lld; " + "bgsave_in_progress:%d; " + "last_save_time:%d; " + "total_connections_received:%lld; " + "total_commands_processed:%lld; " + "role:%s;" + ,REDIS_VERSION, + uptime, + listLength(server.clients)-listLength(server.slaves), + listLength(server.slaves), + server.usedmemory, + server.dirty, + server.bgsaveinprogress, + server.lastsave, + server.stat_numconnections, + server.stat_numcommands, + server.masterhost == NULL ? "master" : "slave" + )); + + trace_size = backtrace(trace, 100); + /* overwrite sigaction with caller's address */ + if (getMcontextEip(uc) != NULL) { + trace[1] = getMcontextEip(uc); + } + messages = backtrace_symbols(trace, trace_size); + + for (i=1; i /proc/sys/vm/overcommit_memory' in your init scripts."); + redisLog(REDIS_WARNING,"WARNING overcommit_memory is set to 0! Background save may fail under low condition memory. 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__ */ @@ -4136,10 +4448,6 @@ static void daemonize(void) { } int main(int argc, char **argv) { -#ifdef __linux__ - linuxOvercommitMemoryWarning(); -#endif - initServerConfig(); if (argc == 2) { ResetServerSaveParams(); @@ -4153,6 +4461,9 @@ int main(int argc, char **argv) { initServer(); if (server.daemonize) daemonize(); redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION); +#ifdef __linux__ + linuxOvercommitMemoryWarning(); +#endif if (rdbLoad(server.dbfilename) == REDIS_OK) redisLog(REDIS_NOTICE,"DB loaded from disk"); if (aeCreateFileEvent(server.el, server.fd, AE_READABLE,