X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/121796f792c4d8fdc06fe664d675ec16791f6818..b892cabed4079de8a1c6ac18041e3ea835c80300:/redis.c diff --git a/redis.c b/redis.c index 48ad6287..df3b4131 100644 --- a/redis.c +++ b/redis.c @@ -56,6 +56,7 @@ #include #include #include +#include #include #include @@ -89,7 +90,12 @@ #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 */ +#define REDIS_REQUEST_MAX_SIZE (1024*1024*256) /* max bytes in inline command */ + +/* If more then REDIS_WRITEV_THRESHOLD write packets are pending use writev */ +#define REDIS_WRITEV_THRESHOLD 3 +/* Max number of iovecs used for each writev call */ +#define REDIS_WRITEV_IOVEC_COUNT 256 /* Hash table parameters */ #define REDIS_HT_MINFILL 10 /* Minimal hash table fill 10% */ @@ -394,6 +400,7 @@ static void processInputBuffer(redisClient *c); static zskiplist *zslCreate(void); static void zslFree(zskiplist *zsl); static void zslInsert(zskiplist *zsl, double score, robj *obj); +static void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask); static void authCommand(redisClient *c); static void pingCommand(redisClient *c); @@ -446,6 +453,7 @@ static void flushdbCommand(redisClient *c); static void flushallCommand(redisClient *c); static void sortCommand(redisClient *c); static void lremCommand(redisClient *c); +static void rpoplpushcommand(redisClient *c); static void infoCommand(redisClient *c); static void mgetCommand(redisClient *c); static void monitorCommand(redisClient *c); @@ -489,6 +497,7 @@ static struct redisCommand cmdTable[] = { {"lrange",lrangeCommand,4,REDIS_CMD_INLINE}, {"ltrim",ltrimCommand,4,REDIS_CMD_INLINE}, {"lrem",lremCommand,4,REDIS_CMD_BULK}, + {"rpoplpush",rpoplpushcommand,3,REDIS_CMD_BULK}, {"sadd",saddCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM}, {"srem",sremCommand,3,REDIS_CMD_BULK}, {"smove",smoveCommand,4,REDIS_CMD_BULK}, @@ -544,6 +553,7 @@ static struct redisCommand cmdTable[] = { {"debug",debugCommand,-2,REDIS_CMD_INLINE}, {NULL,NULL,0,0} }; + /*============================ Utility functions ============================ */ /* Glob-style pattern matching. */ @@ -903,7 +913,7 @@ static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientD /* Check if a background saving in progress terminated */ if (server.bgsaveinprogress) { int statloc; - if (wait4(-1,&statloc,WNOHANG,NULL)) { + if (wait3(&statloc,WNOHANG,NULL)) { int exitcode = WEXITSTATUS(statloc); int bysignal = WIFSIGNALED(statloc); @@ -940,14 +950,21 @@ static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientD } } - /* Try to expire a few timed out keys */ + /* 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 + * keys that can be removed from the keyspace. */ for (j = 0; j < server.dbnum; j++) { + int expired; redisDb *db = server.db+j; - int num = dictSize(db->expires); - if (num) { + /* Continue to expire if at the end of the cycle more than 25% + * of the keys were expired. */ + do { + int num = dictSize(db->expires); time_t now = time(NULL); + expired = 0; if (num > REDIS_EXPIRELOOKUPS_PER_CRON) num = REDIS_EXPIRELOOKUPS_PER_CRON; while (num--) { @@ -958,9 +975,10 @@ static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientD t = (time_t) dictGetEntryVal(de); if (now > t) { deleteKey(db,dictGetEntryKey(de)); + expired++; } } - } + } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4); } /* Check if we should connect to a MASTER */ @@ -1017,7 +1035,7 @@ static void appendServerSaveParams(time_t seconds, int changes) { server.saveparamslen++; } -static void ResetServerSaveParams() { +static void resetServerSaveParams() { zfree(server.saveparams); server.saveparams = NULL; server.saveparamslen = 0; @@ -1046,7 +1064,7 @@ static void initServerConfig() { server.sharingpoolsize = 1024; server.maxclients = 0; server.maxmemory = 0; - ResetServerSaveParams(); + resetServerSaveParams(); appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */ appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */ @@ -1331,34 +1349,31 @@ static void freeClient(redisClient *c) { zfree(c); } +#define GLUEREPLY_UP_TO (1024) static void glueReplyBuffersIfNeeded(redisClient *c) { - int totlen = 0; + int copylen = 0; + char buf[GLUEREPLY_UP_TO]; listNode *ln; robj *o; listRewind(c->reply); while((ln = listYield(c->reply))) { + int objlen; + o = ln->value; - totlen += sdslen(o->ptr); - /* This optimization makes more sense if we don't have to copy - * too much data */ - if (totlen > 1024) return; - } - if (totlen > 0) { - char buf[1024]; - int copylen = 0; - - listRewind(c->reply); - while((ln = listYield(c->reply))) { - o = ln->value; - memcpy(buf+copylen,o->ptr,sdslen(o->ptr)); - copylen += sdslen(o->ptr); + objlen = sdslen(o->ptr); + if (copylen + objlen <= GLUEREPLY_UP_TO) { + memcpy(buf+copylen,o->ptr,objlen); + copylen += objlen; listDelNode(c->reply,ln); + } else { + if (copylen == 0) return; + break; } - /* Now the output buffer is empty, add the new single element */ - o = createObject(REDIS_STRING,sdsnewlen(buf,totlen)); - listAddNodeTail(c->reply,o); } + /* Now the output buffer is empty, add the new single element */ + o = createObject(REDIS_STRING,sdsnewlen(buf,copylen)); + listAddNodeHead(c->reply,o); } static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) { @@ -1368,9 +1383,22 @@ static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) REDIS_NOTUSED(el); REDIS_NOTUSED(mask); - if (server.glueoutputbuf && listLength(c->reply) > 1) - glueReplyBuffersIfNeeded(c); + + /* Use writev() if we have enough buffers to send */ + #if 0 + if (!server.glueoutputbuf && + listLength(c->reply) > REDIS_WRITEV_THRESHOLD && + !(c->flags & REDIS_MASTER)) + { + sendReplyToClientWritev(el, fd, privdata, mask); + return; + } + #endif + while(listLength(c->reply)) { + if (server.glueoutputbuf && listLength(c->reply) > 1) + glueReplyBuffersIfNeeded(c); + o = listNodeValue(listFirst(c->reply)); objlen = sdslen(o->ptr); @@ -1394,10 +1422,10 @@ static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) 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 + * bytes, in a single threaded server it's a good idea to serve * 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) */ + * scenario think about 'KEYS *' against the loopback interfae) */ if (totwritten > REDIS_MAX_WRITE_PER_EVENT) break; } if (nwritten == -1) { @@ -1417,6 +1445,84 @@ static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) } } +static void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask) +{ + redisClient *c = privdata; + int nwritten = 0, totwritten = 0, objlen, willwrite; + robj *o; + struct iovec iov[REDIS_WRITEV_IOVEC_COUNT]; + int offset, ion = 0; + REDIS_NOTUSED(el); + REDIS_NOTUSED(mask); + + listNode *node; + while (listLength(c->reply)) { + offset = c->sentlen; + ion = 0; + willwrite = 0; + + /* fill-in the iov[] array */ + for(node = listFirst(c->reply); node; node = listNextNode(node)) { + o = listNodeValue(node); + objlen = sdslen(o->ptr); + + if (totwritten + objlen - offset > REDIS_MAX_WRITE_PER_EVENT) + break; + + if(ion == REDIS_WRITEV_IOVEC_COUNT) + break; /* no more iovecs */ + + iov[ion].iov_base = ((char*)o->ptr) + offset; + iov[ion].iov_len = objlen - offset; + willwrite += objlen - offset; + offset = 0; /* just for the first item */ + ion++; + } + + if(willwrite == 0) + break; + + /* write all collected blocks at once */ + if((nwritten = writev(fd, iov, ion)) < 0) { + if (errno != EAGAIN) { + redisLog(REDIS_DEBUG, + "Error writing to client: %s", strerror(errno)); + freeClient(c); + return; + } + break; + } + + totwritten += nwritten; + offset = c->sentlen; + + /* remove written robjs from c->reply */ + while (nwritten && listLength(c->reply)) { + o = listNodeValue(listFirst(c->reply)); + objlen = sdslen(o->ptr); + + if(nwritten >= objlen - offset) { + listDelNode(c->reply, listFirst(c->reply)); + nwritten -= objlen - offset; + c->sentlen = 0; + } else { + /* partial write */ + c->sentlen += nwritten; + break; + } + offset = 0; + } + } + + if (totwritten > 0) + c->lastinteraction = time(NULL); + + if (listLength(c->reply) == 0) { + c->sentlen = 0; + aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE); + } +} + static struct redisCommand *lookupCommand(char *name) { int j = 0; while(cmdTable[j].name != NULL) { @@ -1882,7 +1988,9 @@ static void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) { char *err = "-ERR max number of clients reached\r\n"; /* That's a best effort error message, don't check write errors */ - (void) write(c->fd,err,strlen(err)); + if (write(c->fd,err,strlen(err)) == -1) { + /* Nothing to do, Just to avoid the warning... */ + } freeClient(c); return; } @@ -3459,6 +3567,70 @@ static void lremCommand(redisClient *c) { } } +/* This is the semantic of this command: + * RPOPLPUSH srclist dstlist: + * IF LLEN(srclist) > 0 + * element = RPOP srclist + * LPUSH dstlist element + * RETURN element + * ELSE + * RETURN nil + * END + * END + * + * The idea is to be able to get an element from a list in a reliable way + * since the element is not just returned but pushed against another list + * as well. This command was originally proposed by Ezra Zygmuntowicz. + */ +static void rpoplpushcommand(redisClient *c) { + robj *sobj; + + sobj = lookupKeyWrite(c->db,c->argv[1]); + if (sobj == NULL) { + addReply(c,shared.nullbulk); + } else { + if (sobj->type != REDIS_LIST) { + addReply(c,shared.wrongtypeerr); + } else { + list *srclist = sobj->ptr; + listNode *ln = listLast(srclist); + + if (ln == NULL) { + addReply(c,shared.nullbulk); + } else { + robj *dobj = lookupKeyWrite(c->db,c->argv[2]); + robj *ele = listNodeValue(ln); + list *dstlist; + + if (dobj == NULL) { + + /* Create the list if the key does not exist */ + dobj = createListObject(); + dictAdd(c->db->dict,c->argv[2],dobj); + incrRefCount(c->argv[2]); + } else if (dobj->type != REDIS_LIST) { + addReply(c,shared.wrongtypeerr); + return; + } + /* Add the element to the target list */ + dstlist = dobj->ptr; + listAddNodeHead(dstlist,ele); + incrRefCount(ele); + + /* Send the element to the client as reply as well */ + addReplyBulkLen(c,ele); + addReply(c,ele); + addReply(c,shared.crlf); + + /* Finally remove the element from the source list */ + listDelNode(srclist,ln); + server.dirty++; + } + } + } +} + + /* ==================================== Sets ================================ */ static void saddCommand(redisClient *c) { @@ -4295,7 +4467,7 @@ static void zscoreCommand(redisClient *c) { o = lookupKeyRead(c->db,c->argv[1]); if (o == NULL) { - addReply(c,shared.czero); + addReply(c,shared.nullbulk); return; } else { if (o->type != REDIS_ZSET) { @@ -5526,150 +5698,91 @@ static void debugCommand(redisClient *c) { } } -#ifdef HAVE_BACKTRACE -static struct redisFunctionSym symsTable[] = { -{"compareStringObjects", (unsigned long)compareStringObjects}, -{"isStringRepresentableAsLong", (unsigned long)isStringRepresentableAsLong}, -{"dictEncObjKeyCompare", (unsigned long)dictEncObjKeyCompare}, -{"dictEncObjHash", (unsigned long)dictEncObjHash}, -{"incrDecrCommand", (unsigned long)incrDecrCommand}, -{"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}, -{"rdbSaveStringObject", (unsigned long)rdbSaveStringObject}, -{"rdbSaveStringObjectRaw", (unsigned long)rdbSaveStringObjectRaw}, -{"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}, -{"tryObjectEncoding", (unsigned long)tryObjectEncoding}, -{"getDecodedObject", (unsigned long)getDecodedObject}, -{"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}, -{"srandmemberCommand", (unsigned long)srandmemberCommand}, -{"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}, -{"expireatCommand", (unsigned long)expireatCommand}, -{"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}, -{"msetGenericCommand", (unsigned long)msetGenericCommand}, -{"msetCommand", (unsigned long)msetCommand}, -{"msetnxCommand", (unsigned long)msetnxCommand}, -{"zslCreateNode", (unsigned long)zslCreateNode}, -{"zslCreate", (unsigned long)zslCreate}, -{"zslFreeNode",(unsigned long)zslFreeNode}, -{"zslFree",(unsigned long)zslFree}, -{"zslRandomLevel",(unsigned long)zslRandomLevel}, -{"zslInsert",(unsigned long)zslInsert}, -{"zslDelete",(unsigned long)zslDelete}, -{"createZsetObject",(unsigned long)createZsetObject}, -{"zaddCommand",(unsigned long)zaddCommand}, -{"zrangeGenericCommand",(unsigned long)zrangeGenericCommand}, -{"zrangeCommand",(unsigned long)zrangeCommand}, -{"zrevrangeCommand",(unsigned long)zrevrangeCommand}, -{"zremCommand",(unsigned long)zremCommand}, -{"rdbSaveDoubleValue",(unsigned long)rdbSaveDoubleValue}, -{"rdbLoadDoubleValue",(unsigned long)rdbLoadDoubleValue}, -{"feedAppendOnlyFile",(unsigned long)feedAppendOnlyFile}, -{NULL,0} -}; +/* =================================== Main! ================================ */ -/* 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; +#ifdef __linux__ +int linuxOvercommitMemoryValue(void) { + FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r"); + char buf[64]; - /* Try to match against the Symbol with the smallest offset */ - for (i=0; symsTable[i].pointer; i++) { - unsigned long lp = (unsigned long) pointer; + if (!fp) return -1; + if (fgets(buf,64,fp) == NULL) { + fclose(fp); + return -1; + } + fclose(fp); - if (lp != (unsigned long)-1 && lp >= symsTable[i].pointer) { - off=lp-symsTable[i].pointer; - if (ret < 0 || off < minoff) { - minoff=off; - ret=i; - } - } + 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 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__ */ + +static void daemonize(void) { + int fd; + FILE *fp; + + 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); + } + /* Try to write the pid file */ + fp = fopen(server.pidfile,"w"); + if (fp) { + fprintf(fp,"%d\n",getpid()); + fclose(fp); } - if (ret == -1) return NULL; - *offset = minoff; - return symsTable[ret].name; } +int main(int argc, char **argv) { + initServerConfig(); + if (argc == 2) { + resetServerSaveParams(); + loadServerConfig(argv[1]); + } else if (argc > 2) { + fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n"); + exit(1); + } else { + redisLog(REDIS_WARNING,"Warning: no config file specified, using the default config. In order to specify a config file use 'redis-server /path/to/redis.conf'"); + } + initServer(); + if (server.daemonize) daemonize(); + redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION); +#ifdef __linux__ + linuxOvercommitMemoryWarning(); +#endif + if (server.appendonly) { + if (loadAppendOnlyFile(server.appendfilename) == REDIS_OK) + redisLog(REDIS_NOTICE,"DB loaded from append only file"); + } else { + if (rdbLoad(server.dbfilename) == REDIS_OK) + redisLog(REDIS_NOTICE,"DB loaded from disk"); + } + if (aeCreateFileEvent(server.el, server.fd, AE_READABLE, + acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event"); + redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port); + aeMain(server.el); + aeDeleteEventLoop(server.el); + return 0; +} + +/* ============================= Backtrace support ========================= */ + +#ifdef HAVE_BACKTRACE +static char *findFuncName(void *pointer, unsigned long *offset); + static void *getMcontextEip(ucontext_t *uc) { #if defined(__FreeBSD__) return (void*) uc->uc_mcontext.mc_eip; @@ -5764,87 +5877,39 @@ static void setupSigSegvAction(void) { sigaction (SIGBUS, &act, NULL); return; } -#else /* HAVE_BACKTRACE */ -static void setupSigSegvAction(void) { -} -#endif /* HAVE_BACKTRACE */ -/* =================================== Main! ================================ */ +#include "staticsymbols.h" +/* 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; -#ifdef __linux__ -int linuxOvercommitMemoryValue(void) { - FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r"); - char buf[64]; + /* Try to match against the Symbol with the smallest offset */ + for (i=0; symsTable[i].pointer; i++) { + unsigned long lp = (unsigned long) pointer; - if (!fp) return -1; - if (fgets(buf,64,fp) == NULL) { - fclose(fp); - return -1; + if (lp != (unsigned long)-1 && lp >= symsTable[i].pointer) { + off=lp-symsTable[i].pointer; + if (ret < 0 || off < minoff) { + minoff=off; + ret=i; + } + } } - fclose(fp); - - return atoi(buf); + if (ret == -1) return NULL; + *offset = minoff; + return symsTable[ret].name; } - -void linuxOvercommitMemoryWarning(void) { - if (linuxOvercommitMemoryValue() == 0) { - 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."); - } +#else /* HAVE_BACKTRACE */ +static void setupSigSegvAction(void) { } -#endif /* __linux__ */ +#endif /* HAVE_BACKTRACE */ -static void daemonize(void) { - int fd; - FILE *fp; - 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); - } - /* Try to write the pid file */ - fp = fopen(server.pidfile,"w"); - if (fp) { - fprintf(fp,"%d\n",getpid()); - fclose(fp); - } -} +/* The End */ + + -int main(int argc, char **argv) { - initServerConfig(); - if (argc == 2) { - ResetServerSaveParams(); - loadServerConfig(argv[1]); - } else if (argc > 2) { - fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n"); - exit(1); - } else { - redisLog(REDIS_WARNING,"Warning: no config file specified, using the default config. In order to specify a config file use 'redis-server /path/to/redis.conf'"); - } - initServer(); - if (server.daemonize) daemonize(); - redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION); -#ifdef __linux__ - linuxOvercommitMemoryWarning(); -#endif - if (server.appendonly) { - if (loadAppendOnlyFile(server.appendfilename) == REDIS_OK) - redisLog(REDIS_NOTICE,"DB loaded from append only file"); - } else { - if (rdbLoad(server.dbfilename) == REDIS_OK) - redisLog(REDIS_NOTICE,"DB loaded from disk"); - } - if (aeCreateFileEvent(server.el, server.fd, AE_READABLE, - acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event"); - redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port); - aeMain(server.el); - aeDeleteEventLoop(server.el); - return 0; -}