X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/d8f8b666f451a2116c93ec4ff6207d9ca013855e..7d30035d477f5d97e2b491477f4b95c9bb140d6f:/redis.c diff --git a/redis.c b/redis.c index 177ab9ff..952f1f73 100644 --- a/redis.c +++ b/redis.c @@ -27,7 +27,7 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#define REDIS_VERSION "1.050" +#define REDIS_VERSION "1.3.2" #include "fmacros.h" #include "config.h" @@ -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% */ @@ -146,11 +152,24 @@ #define REDIS_RDB_ENC_INT32 2 /* 32 bit signed integer */ #define REDIS_RDB_ENC_LZF 3 /* string compressed with FASTLZ */ +/* Virtual memory object->where field. */ +#define REDIS_VM_MEMORY 0 /* The object is on memory */ +#define REDIS_VM_SWAPPED 1 /* The object is on disk */ +#define REDIS_VM_SWAPPING 2 /* Redis is swapping this object on disk */ +#define REDIS_VM_LOADING 3 /* Redis is loading this object from disk */ + +/* Virtual memory static configuration stuff. + * Check vmFindContiguousPages() to know more about this magic numbers. */ +#define REDIS_VM_MAX_NEAR_PAGES 65536 +#define REDIS_VM_MAX_RANDOM_JUMP 4096 + /* Client flags */ #define REDIS_CLOSE 1 /* This client connection should be closed ASAP */ #define REDIS_SLAVE 2 /* This client is a slave server */ #define REDIS_MASTER 4 /* This client is a master server */ #define REDIS_MONITOR 8 /* This client is a slave monitor, see MONITOR */ +#define REDIS_MULTI 16 /* This client is in a MULTI context */ +#define REDIS_BLOCKED 32 /* The client is waiting in a blocking operation */ /* Slave replication state - slave side */ #define REDIS_REPL_NONE 0 /* No active replication */ @@ -172,11 +191,8 @@ /* Sort operations */ #define REDIS_SORT_GET 0 -#define REDIS_SORT_DEL 1 -#define REDIS_SORT_INCR 2 -#define REDIS_SORT_DECR 3 -#define REDIS_SORT_ASC 4 -#define REDIS_SORT_DESC 5 +#define REDIS_SORT_ASC 1 +#define REDIS_SORT_DESC 2 #define REDIS_SORTKEY_MAX 1024 /* Log levels */ @@ -195,23 +211,67 @@ #define APPENDFSYNC_ALWAYS 1 #define APPENDFSYNC_EVERYSEC 2 +/* We can print the stacktrace, so our assert is defined this way: */ +#define redisAssert(_e) ((_e)?(void)0 : (_redisAssert(#_e),exit(1))) +static void _redisAssert(char *estr); + /*================================= Data types ============================== */ /* A redis object, that is a type able to hold a string / list / set */ + +/* The VM object structure */ +struct redisObjectVM { + off_t page; /* the page at witch the object is stored on disk */ + off_t usedpages; /* number of pages used on disk */ + time_t atime; /* Last access time */ +} vm; + +/* The actual Redis Object */ typedef struct redisObject { void *ptr; unsigned char type; unsigned char encoding; - unsigned char notused[2]; + unsigned char storage; /* where? REDIS_VM_MEMORY, REDIS_VM_SWAPPED, ... */ + unsigned char notused; int refcount; + /* VM fields, this are only allocated if VM is active, otherwise the + * object allocation function will just allocate + * sizeof(redisObjct) minus sizeof(redisObjectVM), so using + * Redis without VM active will not have any overhead. */ + struct redisObjectVM vm; } robj; +/* Macro used to initalize a Redis object allocated on the stack. + * Note that this macro is taken near the structure definition to make sure + * we'll update it when the structure is changed, to avoid bugs like + * bug #85 introduced exactly in this way. */ +#define initStaticStringObject(_var,_ptr) do { \ + _var.refcount = 1; \ + _var.type = REDIS_STRING; \ + _var.encoding = REDIS_ENCODING_RAW; \ + _var.ptr = _ptr; \ + if (server.vm_enabled) _var.storage = REDIS_VM_MEMORY; \ +} while(0); + typedef struct redisDb { - dict *dict; - dict *expires; + dict *dict; /* The keyspace for this DB */ + dict *expires; /* Timeout of keys with a timeout set */ + dict *blockingkeys; /* Keys with clients waiting for data (BLPOP) */ int id; } redisDb; +/* Client MULTI/EXEC state */ +typedef struct multiCmd { + robj **argv; + int argc; + struct redisCommand *cmd; +} multiCmd; + +typedef struct multiState { + multiCmd *commands; /* Array of MULTI commands */ + int count; /* Total number of MULTI commands */ +} multiState; + /* With multiplexing we need to take per-clinet state. * Clients are taken in a liked list. */ typedef struct redisClient { @@ -227,12 +287,19 @@ typedef struct redisClient { int sentlen; time_t lastinteraction; /* time of the last interaction, used for timeout */ int flags; /* REDIS_CLOSE | REDIS_SLAVE | REDIS_MONITOR */ + /* REDIS_MULTI */ int slaveseldb; /* slave selected db, if this client is a slave */ int authenticated; /* when requirepass is non-NULL */ int replstate; /* replication state if this is a slave */ int repldbfd; /* replication DB file descriptor */ - long repldboff; /* replication DB file offset */ + long repldboff; /* replication DB file offset */ off_t repldbsize; /* replication DB file size */ + multiState mstate; /* MULTI/EXEC state */ + robj **blockingkeys; /* The key we waiting to terminate a blocking + * operation such as BLPOP. Otherwise NULL. */ + int blockingkeysnum; /* Number of blocking keys */ + time_t blockingto; /* Blocking operation timeout. If UNIX current time + * is >= blockingto then the operation timed out. */ } redisClient; struct saveparam { @@ -245,7 +312,7 @@ struct redisServer { int port; int fd; redisDb *db; - dict *sharingpool; + dict *sharingpool; /* Poll used for object sharing */ unsigned int sharingpoolsize; long long dirty; /* changes to DB from the last save */ list *clients; @@ -272,8 +339,9 @@ struct redisServer { int appendfd; int appendseldb; char *pidfile; - int bgsaveinprogress; pid_t bgsavechildpid; + pid_t bgrewritechildpid; + sds bgrewritebuf; /* buffer taken by parent during oppend only rewrite */ struct saveparam *saveparams; int saveparamslen; char *logfile; @@ -282,19 +350,34 @@ struct redisServer { char *appendfilename; char *requirepass; int shareobjects; + int rdbcompression; /* Replication related */ int isslave; + char *masterauth; char *masterhost; int masterport; redisClient *master; /* client that is master for this slave */ int replstate; unsigned int maxclients; unsigned long maxmemory; + unsigned int blockedclients; /* Sort parameters - qsort_r() is only available under BSD so we * have to take this state global, in order to pass it to sortCompare() */ int sort_desc; int sort_alpha; int sort_bypattern; + /* Virtual memory configuration */ + int vm_enabled; + off_t vm_page_size; + off_t vm_pages; + long vm_max_memory; + /* Virtual memory state */ + FILE *vm_fp; + int vm_fd; + off_t vm_next_page; /* Next probably empty page */ + off_t vm_near_pages; /* Number of pages allocated sequentially */ + unsigned char *vm_bitmap; /* Bitmap of free/used pages */ + time_t unixtime; /* Unix time sampled every second. */ }; typedef void redisCommandProc(redisClient *c); @@ -347,7 +430,7 @@ typedef struct zset { struct sharedObjectsStruct { robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *pong, *space, - *colon, *nullbulk, *nullmultibulk, + *colon, *nullbulk, *nullmultibulk, *queued, *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr, *outofrangeerr, *plus, *select0, *select1, *select2, *select3, *select4, @@ -379,7 +462,7 @@ static void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv static int syncWithMaster(void); static robj *tryObjectSharing(robj *o); static int tryObjectEncoding(robj *o); -static robj *getDecodedObject(const robj *o); +static robj *getDecodedObject(robj *o); static int removeExpire(redisDb *db, robj *key); static int expireIfNeeded(redisDb *db, robj *key); static int deleteIfVolatile(redisDb *db, robj *key); @@ -391,11 +474,21 @@ static void freeMemoryIfNeeded(void); static int processCommand(redisClient *c); static void setupSigSegvAction(void); static void rdbRemoveTempFile(pid_t childpid); +static void aofRemoveTempFile(pid_t childpid); static size_t stringObjectLen(robj *o); 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 initClientMultiState(redisClient *c); +static void freeClientMultiState(redisClient *c); +static void queueMultiCommand(redisClient *c, struct redisCommand *cmd); +static void unblockClient(redisClient *c); +static int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele); +static void vmInit(void); +static void vmMarkPagesFree(off_t page, off_t count); +static robj *vmLoadObject(robj *key); static void authCommand(redisClient *c); static void pingCommand(redisClient *c); @@ -416,6 +509,7 @@ static void dbsizeCommand(redisClient *c); static void lastsaveCommand(redisClient *c); static void saveCommand(redisClient *c); static void bgsaveCommand(redisClient *c); +static void bgrewriteaofCommand(redisClient *c); static void shutdownCommand(redisClient *c); static void moveCommand(redisClient *c); static void renameCommand(redisClient *c); @@ -448,6 +542,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); @@ -460,6 +555,7 @@ static void debugCommand(redisClient *c); static void msetCommand(redisClient *c); static void msetnxCommand(redisClient *c); static void zaddCommand(redisClient *c); +static void zincrbyCommand(redisClient *c); static void zrangeCommand(redisClient *c); static void zrangebyscoreCommand(redisClient *c); static void zrevrangeCommand(redisClient *c); @@ -467,6 +563,10 @@ static void zcardCommand(redisClient *c); static void zremCommand(redisClient *c); static void zscoreCommand(redisClient *c); static void zremrangebyscoreCommand(redisClient *c); +static void multiCommand(redisClient *c); +static void execCommand(redisClient *c); +static void blpopCommand(redisClient *c); +static void brpopCommand(redisClient *c); /*================================= Globals ================================= */ @@ -485,12 +585,15 @@ static struct redisCommand cmdTable[] = { {"lpush",lpushCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM}, {"rpop",rpopCommand,2,REDIS_CMD_INLINE}, {"lpop",lpopCommand,2,REDIS_CMD_INLINE}, + {"brpop",brpopCommand,-3,REDIS_CMD_INLINE}, + {"blpop",blpopCommand,-3,REDIS_CMD_INLINE}, {"llen",llenCommand,2,REDIS_CMD_INLINE}, {"lindex",lindexCommand,3,REDIS_CMD_INLINE}, {"lset",lsetCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM}, {"lrange",lrangeCommand,4,REDIS_CMD_INLINE}, {"ltrim",ltrimCommand,4,REDIS_CMD_INLINE}, {"lrem",lremCommand,4,REDIS_CMD_BULK}, + {"rpoplpush",rpoplpushcommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM}, {"sadd",saddCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM}, {"srem",sremCommand,3,REDIS_CMD_BULK}, {"smove",smoveCommand,4,REDIS_CMD_BULK}, @@ -506,11 +609,12 @@ static struct redisCommand cmdTable[] = { {"sdiffstore",sdiffstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM}, {"smembers",sinterCommand,2,REDIS_CMD_INLINE}, {"zadd",zaddCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM}, + {"zincrby",zincrbyCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM}, {"zrem",zremCommand,3,REDIS_CMD_BULK}, {"zremrangebyscore",zremrangebyscoreCommand,4,REDIS_CMD_INLINE}, - {"zrange",zrangeCommand,4,REDIS_CMD_INLINE}, - {"zrangebyscore",zrangebyscoreCommand,4,REDIS_CMD_INLINE}, - {"zrevrange",zrevrangeCommand,4,REDIS_CMD_INLINE}, + {"zrange",zrangeCommand,-4,REDIS_CMD_INLINE}, + {"zrangebyscore",zrangebyscoreCommand,-4,REDIS_CMD_INLINE}, + {"zrevrange",zrevrangeCommand,-4,REDIS_CMD_INLINE}, {"zcard",zcardCommand,2,REDIS_CMD_INLINE}, {"zscore",zscoreCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM}, {"incrby",incrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM}, @@ -532,9 +636,12 @@ static struct redisCommand cmdTable[] = { {"echo",echoCommand,2,REDIS_CMD_BULK}, {"save",saveCommand,1,REDIS_CMD_INLINE}, {"bgsave",bgsaveCommand,1,REDIS_CMD_INLINE}, + {"bgrewriteaof",bgrewriteaofCommand,1,REDIS_CMD_INLINE}, {"shutdown",shutdownCommand,1,REDIS_CMD_INLINE}, {"lastsave",lastsaveCommand,1,REDIS_CMD_INLINE}, {"type",typeCommand,2,REDIS_CMD_INLINE}, + {"multi",multiCommand,1,REDIS_CMD_INLINE}, + {"exec",execCommand,1,REDIS_CMD_INLINE}, {"sync",syncCommand,1,REDIS_CMD_INLINE}, {"flushdb",flushdbCommand,1,REDIS_CMD_INLINE}, {"flushall",flushallCommand,1,REDIS_CMD_INLINE}, @@ -546,6 +653,7 @@ static struct redisCommand cmdTable[] = { {"debug",debugCommand,-2,REDIS_CMD_INLINE}, {NULL,NULL,0,0} }; + /*============================ Utility functions ============================ */ /* Glob-style pattern matching. */ @@ -708,6 +816,12 @@ static void dictVanillaFree(void *privdata, void *val) zfree(val); } +static void dictListDestructor(void *privdata, void *val) +{ + DICT_NOTUSED(privdata); + listRelease((list*)val); +} + static int sdsDictKeyCompare(void *privdata, const void *key1, const void *key2) { @@ -724,6 +838,7 @@ static void dictRedisObjectDestructor(void *privdata, void *val) { DICT_NOTUSED(privdata); + if (val == NULL) return; /* Values of swapped out keys as set to NULL */ decrRefCount(val); } @@ -742,37 +857,24 @@ static unsigned int dictObjHash(const void *key) { static int dictEncObjKeyCompare(void *privdata, const void *key1, const void *key2) { - const robj *o1 = key1, *o2 = key2; - - if (o1->encoding == REDIS_ENCODING_RAW && - o2->encoding == REDIS_ENCODING_RAW) - return sdsDictKeyCompare(privdata,o1->ptr,o2->ptr); - else { - robj *dec1, *dec2; - int cmp; + robj *o1 = (robj*) key1, *o2 = (robj*) key2; + int cmp; - dec1 = o1->encoding != REDIS_ENCODING_RAW ? - getDecodedObject(o1) : (robj*)o1; - dec2 = o2->encoding != REDIS_ENCODING_RAW ? - getDecodedObject(o2) : (robj*)o2; - cmp = sdsDictKeyCompare(privdata,dec1->ptr,dec2->ptr); - if (dec1 != o1) decrRefCount(dec1); - if (dec2 != o2) decrRefCount(dec2); - return cmp; - } + o1 = getDecodedObject(o1); + o2 = getDecodedObject(o2); + cmp = sdsDictKeyCompare(privdata,o1->ptr,o2->ptr); + decrRefCount(o1); + decrRefCount(o2); + return cmp; } static unsigned int dictEncObjHash(const void *key) { - const robj *o = key; + robj *o = (robj*) key; - if (o->encoding == REDIS_ENCODING_RAW) - return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr)); - else { - robj *dec = getDecodedObject(o); - unsigned int hash = dictGenHashFunction(dec->ptr, sdslen((sds)dec->ptr)); - decrRefCount(dec); - return hash; - } + o = getDecodedObject(o); + unsigned int hash = dictGenHashFunction(o->ptr, sdslen((sds)o->ptr)); + decrRefCount(o); + return hash; } static dictType setDictType = { @@ -790,7 +892,7 @@ static dictType zsetDictType = { NULL, /* val dup */ dictEncObjKeyCompare, /* key compare */ dictRedisObjectDestructor, /* key destructor */ - dictVanillaFree /* val destructor */ + dictVanillaFree /* val destructor of malloc(sizeof(double)) */ }; static dictType hashDictType = { @@ -802,6 +904,17 @@ static dictType hashDictType = { dictRedisObjectDestructor /* val destructor */ }; +/* Keylist hash table type has unencoded redis objects as keys and + * lists as values. It's used for blocking operations (BLPOP) */ +static dictType keylistDictType = { + dictObjHash, /* hash function */ + NULL, /* key dup */ + NULL, /* val dup */ + dictObjKeyCompare, /* key compare */ + dictRedisObjectDestructor, /* key destructor */ + dictListDestructor /* val destructor */ +}; + /* ========================= Random utility functions ======================= */ /* Redis generally does not try to recover from out of memory conditions @@ -810,8 +923,7 @@ static dictType hashDictType = { * is based on heap allocation for send buffers, so we simply abort. * At least the code will be simpler to read... */ static void oom(const char *msg) { - fprintf(stderr, "%s: Out of memory\n",msg); - fflush(stderr); + redisLog(REDIS_WARNING, "%s: Out of memory\n",msg); sleep(1); abort(); } @@ -825,11 +937,18 @@ static void closeTimedoutClients(void) { listRewind(server.clients); while ((ln = listYield(server.clients)) != NULL) { c = listNodeValue(ln); - if (!(c->flags & REDIS_SLAVE) && /* no timeout for slaves */ + if (server.maxidletime && + !(c->flags & REDIS_SLAVE) && /* no timeout for slaves */ !(c->flags & REDIS_MASTER) && /* no timeout for masters */ - (now - c->lastinteraction > server.maxidletime)) { + (now - c->lastinteraction > server.maxidletime)) + { redisLog(REDIS_DEBUG,"Closing idle client"); freeClient(c); + } else if (c->flags & REDIS_BLOCKED) { + if (c->blockingto != 0 && c->blockingto < now) { + addReply(c,shared.nullmultibulk); + unblockClient(c); + } } } } @@ -859,12 +978,102 @@ static void tryResizeHashTables(void) { } } +/* A background saving child (BGSAVE) terminated its work. Handle this. */ +void backgroundSaveDoneHandler(int statloc) { + int exitcode = WEXITSTATUS(statloc); + int bysignal = WIFSIGNALED(statloc); + + if (!bysignal && exitcode == 0) { + redisLog(REDIS_NOTICE, + "Background saving terminated with success"); + server.dirty = 0; + server.lastsave = time(NULL); + } else if (!bysignal && exitcode != 0) { + redisLog(REDIS_WARNING, "Background saving error"); + } else { + redisLog(REDIS_WARNING, + "Background saving terminated by signal"); + rdbRemoveTempFile(server.bgsavechildpid); + } + server.bgsavechildpid = -1; + /* Possibly there are slaves waiting for a BGSAVE in order to be served + * (the first stage of SYNC is a bulk transfer of dump.rdb) */ + updateSlavesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR); +} + +/* A background append only file rewriting (BGREWRITEAOF) terminated its work. + * Handle this. */ +void backgroundRewriteDoneHandler(int statloc) { + int exitcode = WEXITSTATUS(statloc); + int bysignal = WIFSIGNALED(statloc); + + if (!bysignal && exitcode == 0) { + int fd; + char tmpfile[256]; + + redisLog(REDIS_NOTICE, + "Background append only file rewriting terminated with success"); + /* Now it's time to flush the differences accumulated by the parent */ + snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) server.bgrewritechildpid); + fd = open(tmpfile,O_WRONLY|O_APPEND); + if (fd == -1) { + redisLog(REDIS_WARNING, "Not able to open the temp append only file produced by the child: %s", strerror(errno)); + goto cleanup; + } + /* Flush our data... */ + if (write(fd,server.bgrewritebuf,sdslen(server.bgrewritebuf)) != + (signed) sdslen(server.bgrewritebuf)) { + redisLog(REDIS_WARNING, "Error or short write trying to flush the parent diff of the append log file in the child temp file: %s", strerror(errno)); + close(fd); + goto cleanup; + } + redisLog(REDIS_NOTICE,"Parent diff flushed into the new append log file with success (%lu bytes)",sdslen(server.bgrewritebuf)); + /* Now our work is to rename the temp file into the stable file. And + * switch the file descriptor used by the server for append only. */ + if (rename(tmpfile,server.appendfilename) == -1) { + redisLog(REDIS_WARNING,"Can't rename the temp append only file into the stable one: %s", strerror(errno)); + close(fd); + goto cleanup; + } + /* Mission completed... almost */ + redisLog(REDIS_NOTICE,"Append only file successfully rewritten."); + if (server.appendfd != -1) { + /* If append only is actually enabled... */ + close(server.appendfd); + server.appendfd = fd; + fsync(fd); + server.appendseldb = -1; /* Make sure it will issue SELECT */ + redisLog(REDIS_NOTICE,"The new append only file was selected for future appends."); + } else { + /* If append only is disabled we just generate a dump in this + * format. Why not? */ + close(fd); + } + } else if (!bysignal && exitcode != 0) { + redisLog(REDIS_WARNING, "Background append only file rewriting error"); + } else { + redisLog(REDIS_WARNING, + "Background append only file rewriting terminated by signal"); + } +cleanup: + sdsfree(server.bgrewritebuf); + server.bgrewritebuf = sdsempty(); + aofRemoveTempFile(server.bgrewritechildpid); + server.bgrewritechildpid = -1; +} + static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { int j, loops = server.cronloops++; REDIS_NOTUSED(eventLoop); REDIS_NOTUSED(id); REDIS_NOTUSED(clientData); + /* 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); + /* Update the global state with the amount of used memory */ server.usedmemory = zmalloc_used_memory(); @@ -887,7 +1096,7 @@ static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientD * if we resize the HT while there is the saving child at work actually * a lot of memory movements in the parent will cause a lot of pages * copied. */ - if (!server.bgsaveinprogress) tryResizeHashTables(); + if (server.bgsavechildpid == -1) tryResizeHashTables(); /* Show information about connected clients */ if (!(loops % 5)) { @@ -899,31 +1108,20 @@ static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientD } /* Close connections of timedout clients */ - if (server.maxidletime && !(loops % 10)) + if ((server.maxidletime && !(loops % 10)) || server.blockedclients) closeTimedoutClients(); - /* Check if a background saving in progress terminated */ - if (server.bgsaveinprogress) { + /* Check if a background saving or AOF rewrite in progress terminated */ + if (server.bgsavechildpid != -1 || server.bgrewritechildpid != -1) { int statloc; - if (wait4(-1,&statloc,WNOHANG,NULL)) { - int exitcode = WEXITSTATUS(statloc); - int bysignal = WIFSIGNALED(statloc); - - if (!bysignal && exitcode == 0) { - redisLog(REDIS_NOTICE, - "Background saving terminated with success"); - server.dirty = 0; - server.lastsave = time(NULL); - } else if (!bysignal && exitcode != 0) { - redisLog(REDIS_WARNING, "Background saving error"); + pid_t pid; + + if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) { + if (pid == server.bgsavechildpid) { + backgroundSaveDoneHandler(statloc); } else { - redisLog(REDIS_WARNING, - "Background saving terminated by signal"); - rdbRemoveTempFile(server.bgsavechildpid); + backgroundRewriteDoneHandler(statloc); } - server.bgsaveinprogress = 0; - server.bgsavechildpid = -1; - updateSlavesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR); } } else { /* If there is not a background saving in progress check if @@ -942,14 +1140,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--) { @@ -960,9 +1165,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 */ @@ -985,8 +1191,8 @@ static void createSharedObjects(void) { 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")); - /* no such key */ shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n")); + shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n")); shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew( "-ERR Operation against a key holding the wrong kind of value\r\n")); shared.nokeyerr = createObject(REDIS_STRING,sdsnew( @@ -1019,7 +1225,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; @@ -1042,19 +1248,27 @@ static void initServerConfig() { server.appendseldb = -1; /* Make sure the first time will not match */ server.pidfile = "/var/run/redis.pid"; server.dbfilename = "dump.rdb"; - server.appendfilename = "appendonly.log"; + server.appendfilename = "appendonly.aof"; server.requirepass = NULL; server.shareobjects = 0; + server.rdbcompression = 1; server.sharingpoolsize = 1024; server.maxclients = 0; + server.blockedclients = 0; server.maxmemory = 0; - ResetServerSaveParams(); + server.vm_enabled = 0; + server.vm_page_size = 256; /* 256 bytes per page */ + server.vm_pages = 1024*1024*100; /* 104 millions of pages */ + server.vm_max_memory = 1024LL*1024*1024*1; /* 1 GB of RAM */ + + 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.isslave = 0; + server.masterauth = NULL; server.masterhost = NULL; server.masterport = 6379; server.master = NULL; @@ -1090,17 +1304,20 @@ static void initServer() { for (j = 0; j < server.dbnum; j++) { server.db[j].dict = dictCreate(&hashDictType,NULL); server.db[j].expires = dictCreate(&setDictType,NULL); + server.db[j].blockingkeys = dictCreate(&keylistDictType,NULL); server.db[j].id = j; } server.cronloops = 0; - server.bgsaveinprogress = 0; server.bgsavechildpid = -1; + server.bgrewritechildpid = -1; + server.bgrewritebuf = sdsempty(); server.lastsave = time(NULL); server.dirty = 0; server.usedmemory = 0; server.stat_numcommands = 0; server.stat_numconnections = 0; server.stat_starttime = time(NULL); + server.unixtime = time(NULL); aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL); if (server.appendonly) { @@ -1111,6 +1328,8 @@ static void initServer() { exit(1); } } + + if (server.vm_enabled) vmInit(); } /* Empty the whole database */ @@ -1233,6 +1452,8 @@ static void loadServerConfig(char *filename) { server.masterhost = sdsnew(argv[1]); server.masterport = atoi(argv[2]); server.replstate = REDIS_REPL_CONNECT; + } else if (!strcasecmp(argv[0],"masterauth") && argc == 2) { + server.masterauth = zstrdup(argv[1]); } else if (!strcasecmp(argv[0],"glueoutputbuf") && argc == 2) { if ((server.glueoutputbuf = yesnotoi(argv[1])) == -1) { err = "argument must be 'yes' or 'no'"; goto loaderr; @@ -1241,6 +1462,10 @@ static void loadServerConfig(char *filename) { if ((server.shareobjects = yesnotoi(argv[1])) == -1) { err = "argument must be 'yes' or 'no'"; goto loaderr; } + } else if (!strcasecmp(argv[0],"rdbcompression") && argc == 2) { + if ((server.rdbcompression = yesnotoi(argv[1])) == -1) { + err = "argument must be 'yes' or 'no'"; goto loaderr; + } } else if (!strcasecmp(argv[0],"shareobjectspoolsize") && argc == 2) { server.sharingpoolsize = atoi(argv[1]); if (server.sharingpoolsize < 1) { @@ -1271,6 +1496,10 @@ static void loadServerConfig(char *filename) { server.pidfile = zstrdup(argv[1]); } else if (!strcasecmp(argv[0],"dbfilename") && argc == 2) { server.dbfilename = zstrdup(argv[1]); + } else if (!strcasecmp(argv[0],"vm-enabled") && argc == 2) { + if ((server.vm_enabled = yesnotoi(argv[1])) == -1) { + err = "argument must be 'yes' or 'no'"; goto loaderr; + } } else { err = "Bad directive or wrong number of arguments"; goto loaderr; } @@ -1304,21 +1533,30 @@ static void freeClientArgv(redisClient *c) { static void freeClient(redisClient *c) { listNode *ln; + /* Note that if the client we are freeing is blocked into a blocking + * call, we have to set querybuf to NULL *before* to call unblockClient() + * to avoid processInputBuffer() will get called. Also it is important + * to remove the file events after this, because this call adds + * the READABLE event. */ + sdsfree(c->querybuf); + c->querybuf = NULL; + if (c->flags & REDIS_BLOCKED) + unblockClient(c); + aeDeleteFileEvent(server.el,c->fd,AE_READABLE); aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE); - sdsfree(c->querybuf); listRelease(c->reply); freeClientArgv(c); close(c->fd); ln = listSearchKey(server.clients,c); - assert(ln != NULL); + redisAssert(ln != NULL); listDelNode(server.clients,ln); if (c->flags & REDIS_SLAVE) { if (c->replstate == REDIS_REPL_SEND_BULK && c->repldbfd != -1) close(c->repldbfd); list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves; ln = listSearchKey(l,c); - assert(ln != NULL); + redisAssert(ln != NULL); listDelNode(l,ln); } if (c->flags & REDIS_MASTER) { @@ -1327,37 +1565,35 @@ static void freeClient(redisClient *c) { } zfree(c->argv); zfree(c->mbargv); + freeClientMultiState(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) { @@ -1367,9 +1603,19 @@ 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 (!server.glueoutputbuf && + listLength(c->reply) > REDIS_WRITEV_THRESHOLD && + !(c->flags & REDIS_MASTER)) + { + sendReplyToClientWritev(el, fd, privdata, mask); + return; + } + while(listLength(c->reply)) { + if (server.glueoutputbuf && listLength(c->reply) > 1) + glueReplyBuffersIfNeeded(c); + o = listNodeValue(listFirst(c->reply)); objlen = sdslen(o->ptr); @@ -1393,10 +1639,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) { @@ -1416,6 +1662,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) { @@ -1432,6 +1756,21 @@ static void resetClient(redisClient *c) { c->multibulk = 0; } +/* Call() is the core of Redis execution of a command */ +static void call(redisClient *c, struct redisCommand *cmd) { + long long dirty; + + dirty = server.dirty; + cmd->proc(c); + if (server.appendonly && server.dirty-dirty) + feedAppendOnlyFile(cmd,c->db->id,c->argv,c->argc); + if (server.dirty-dirty && listLength(server.slaves)) + replicationFeedSlaves(server.slaves,cmd,c->db->id,c->argv,c->argc); + if (listLength(server.monitors)) + replicationFeedSlaves(server.monitors,cmd,c->db->id,c->argv,c->argc); + server.stat_numcommands++; +} + /* If this function gets called we already read a whole * command, argments are in the client argv/argc fields. * processCommand() execute the command or prepare the @@ -1442,7 +1781,6 @@ static void resetClient(redisClient *c) { * if 0 is returned the client was destroied (i.e. after QUIT). */ static int processCommand(redisClient *c) { struct redisCommand *cmd; - long long dirty; /* Free some memory if needed (maxmemory setting) */ if (server.maxmemory) freeMemoryIfNeeded(); @@ -1523,12 +1861,17 @@ static int processCommand(redisClient *c) { } cmd = lookupCommand(c->argv[0]->ptr); if (!cmd) { - addReplySds(c,sdsnew("-ERR unknown command\r\n")); + addReplySds(c, + sdscatprintf(sdsempty(), "-ERR unknown command '%s'\r\n", + (char*)c->argv[0]->ptr)); resetClient(c); return 1; } else if ((cmd->arity > 0 && cmd->arity != c->argc) || (c->argc < -cmd->arity)) { - addReplySds(c,sdsnew("-ERR wrong number of arguments\r\n")); + addReplySds(c, + sdscatprintf(sdsempty(), + "-ERR wrong number of arguments for '%s' command\r\n", + cmd->name)); resetClient(c); return 1; } else if (server.maxmemory && cmd->flags & REDIS_CMD_DENYOOM && zmalloc_used_memory() > server.maxmemory) { @@ -1578,15 +1921,12 @@ static int processCommand(redisClient *c) { } /* Exec the command */ - dirty = server.dirty; - cmd->proc(c); - if (server.appendonly && server.dirty-dirty) - feedAppendOnlyFile(cmd,c->db->id,c->argv,c->argc); - if (server.dirty-dirty && listLength(server.slaves)) - replicationFeedSlaves(server.slaves,cmd,c->db->id,c->argv,c->argc); - if (listLength(server.monitors)) - replicationFeedSlaves(server.monitors,cmd,c->db->id,c->argv,c->argc); - server.stat_numcommands++; + if (c->flags & REDIS_MULTI && cmd->proc != execCommand) { + queueMultiCommand(c,cmd); + addReply(c,shared.queued); + } else { + call(c,cmd); + } /* Prepare the client for the next command */ if (c->flags & REDIS_CLOSE) { @@ -1616,8 +1956,8 @@ static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int di robj *lenobj; lenobj = createObject(REDIS_STRING, - sdscatprintf(sdsempty(),"%d\r\n", - stringObjectLen(argv[j]))); + sdscatprintf(sdsempty(),"%lu\r\n", + (unsigned long) stringObjectLen(argv[j]))); lenobj->refcount = 0; outv[outc++] = lenobj; } @@ -1668,6 +2008,13 @@ static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int di static void processInputBuffer(redisClient *c) { again: + /* Before to process the input buffer, make sure the client is not + * waitig for a blocking operation such as BLPOP. Note that the first + * iteration the client is never blocked, otherwise the processInputBuffer + * would not be called at all, but after the execution of the first commands + * in the input buffer the client may be blocked, and the "goto again" + * will try to reiterate. The following line will make it return asap. */ + if (c->flags & REDIS_BLOCKED) return; if (c->bulklen == -1) { /* Read the first line of the query */ char *p = strchr(c->querybuf,'\n'); @@ -1689,11 +2036,6 @@ again: sdsupdatelen(query); /* Now we can split the query in arguments */ - if (sdslen(query) == 0) { - /* Ignore empty query */ - sdsfree(query); - return; - } argv = sdssplitlen(query,sdslen(query)," ",1,&argc); sdsfree(query); @@ -1709,10 +2051,16 @@ again: } } zfree(argv); - /* 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 (c->argc && processCommand(c) && sdslen(c->querybuf)) goto again; + if (c->argc) { + /* 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; + } else { + /* Nothing to process, argc == 0. Just process the query + * buffer if it's not empty or return to the caller */ + if (sdslen(c->querybuf)) goto again; + } return; } else if (sdslen(c->querybuf) >= REDIS_REQUEST_MAX_SIZE) { redisLog(REDIS_DEBUG, "Client protocol error"); @@ -1803,14 +2151,17 @@ static redisClient *createClient(int fd) { c->authenticated = 0; c->replstate = REDIS_REPL_NONE; c->reply = listCreate(); + c->blockingkeys = NULL; + c->blockingkeysnum = 0; listSetFreeMethod(c->reply,decrRefCount); listSetDupMethod(c->reply,dupClientReplyValue); if (aeCreateFileEvent(server.el, c->fd, AE_READABLE, - readQueryFromClient, c, NULL) == AE_ERR) { + readQueryFromClient, c) == AE_ERR) { freeClient(c); return NULL; } listAddNodeTail(server.clients,c); + initClientMultiState(c); return c; } @@ -1819,13 +2170,8 @@ static void addReply(redisClient *c, robj *obj) { (c->replstate == REDIS_REPL_NONE || c->replstate == REDIS_REPL_ONLINE) && aeCreateFileEvent(server.el, c->fd, AE_WRITABLE, - sendReplyToClient, c, NULL) == AE_ERR) return; - if (obj->encoding != REDIS_ENCODING_RAW) { - obj = getDecodedObject(obj); - } else { - incrRefCount(obj); - } - listAddNodeTail(c->reply,obj); + sendReplyToClient, c) == AE_ERR) return; + listAddNodeTail(c->reply,getDecodedObject(obj)); } static void addReplySds(redisClient *c, sds s) { @@ -1834,6 +2180,14 @@ static void addReplySds(redisClient *c, sds s) { decrRefCount(o); } +static void addReplyDouble(redisClient *c, double d) { + char buf[128]; + + snprintf(buf,sizeof(buf),"%.17g",d); + addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n%s\r\n", + (unsigned long) strlen(buf),buf)); +} + static void addReplyBulkLen(redisClient *c, robj *obj) { size_t len; @@ -1842,6 +2196,7 @@ static void addReplyBulkLen(redisClient *c, robj *obj) { } else { long n = (long)obj->ptr; + /* Compute how many bytes will take this integer as a radix 10 string */ len = 1; if (n < 0) { len++; @@ -1851,7 +2206,7 @@ static void addReplyBulkLen(redisClient *c, robj *obj) { len++; } } - addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",len)); + addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",(unsigned long)len)); } static void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) { @@ -1881,7 +2236,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; } @@ -1898,12 +2255,20 @@ static robj *createObject(int type, void *ptr) { o = listNodeValue(head); listDelNode(server.objfreelist,head); } else { - o = zmalloc(sizeof(*o)); + if (server.vm_enabled) { + o = zmalloc(sizeof(*o)); + } else { + o = zmalloc(sizeof(*o)-sizeof(struct redisObjectVM)); + } } o->type = type; o->encoding = REDIS_ENCODING_RAW; o->ptr = ptr; o->refcount = 1; + if (server.vm_enabled) { + o->vm.atime = server.unixtime; + o->storage = REDIS_VM_MEMORY; + } return o; } @@ -1958,20 +2323,25 @@ static void freeHashObject(robj *o) { } static void incrRefCount(robj *o) { + assert(!server.vm_enabled || o->storage == REDIS_VM_MEMORY); o->refcount++; -#ifdef DEBUG_REFCOUNT - if (o->type == REDIS_STRING) - printf("Increment '%s'(%p), now is: %d\n",o->ptr,o,o->refcount); -#endif } static void decrRefCount(void *obj) { robj *o = obj; -#ifdef DEBUG_REFCOUNT - if (o->type == REDIS_STRING) - printf("Decrement '%s'(%p), now is: %d\n",o->ptr,o,o->refcount-1); -#endif + /* REDIS_VM_SWAPPED */ + if (server.vm_enabled && o->storage == REDIS_VM_SWAPPED) { + assert(o->refcount == 1); + assert(o->type == REDIS_STRING); + freeStringObject(o); + vmMarkPagesFree(o->vm.page,o->vm.usedpages); + if (listLength(server.objfreelist) > REDIS_OBJFREELIST_MAX || + !listAddNodeHead(server.objfreelist,o)) + zfree(o); + return; + } + /* REDIS_VM_MEMORY */ if (--(o->refcount) == 0) { switch(o->type) { case REDIS_STRING: freeStringObject(o); break; @@ -1979,7 +2349,7 @@ static void decrRefCount(void *obj) { case REDIS_SET: freeSetObject(o); break; case REDIS_ZSET: freeZsetObject(o); break; case REDIS_HASH: freeHashObject(o); break; - default: assert(0 != 0); break; + default: redisAssert(0 != 0); break; } if (listLength(server.objfreelist) > REDIS_OBJFREELIST_MAX || !listAddNodeHead(server.objfreelist,o)) @@ -1989,7 +2359,25 @@ static void decrRefCount(void *obj) { static robj *lookupKey(redisDb *db, robj *key) { dictEntry *de = dictFind(db->dict,key); - return de ? dictGetEntryVal(de) : NULL; + if (de) { + robj *key = dictGetEntryKey(de); + robj *val = dictGetEntryVal(de); + + if (server.vm_enabled) { + if (key->storage == REDIS_VM_MEMORY) { + /* Update the access time of the key for the aging algorithm. */ + key->vm.atime = server.unixtime; + } else { + /* Our value was swapped on disk. Bring it at home. */ + assert(val == NULL); + val = vmLoadObject(key); + dictGetEntryVal(de) = val; + } + } + return val; + } else { + return NULL; + } } static robj *lookupKeyRead(redisDb *db, robj *key) { @@ -2024,7 +2412,7 @@ static robj *tryObjectSharing(robj *o) { if (o == NULL || server.shareobjects == 0) return o; - assert(o->type == REDIS_STRING); + redisAssert(o->type == REDIS_STRING); de = dictFind(server.sharingpool,o); if (de) { robj *shared = dictGetEntryKey(de); @@ -2042,7 +2430,7 @@ static robj *tryObjectSharing(robj *o) { if (dictSize(server.sharingpool) >= server.sharingpoolsize) { de = dictGetRandomKey(server.sharingpool); - assert(de != NULL); + redisAssert(de != NULL); c = ((unsigned long) dictGetEntryVal(de))-1; dictGetEntryVal(de) = (void*) c; if (c == 0) { @@ -2055,7 +2443,7 @@ static robj *tryObjectSharing(robj *o) { int retval; retval = dictAdd(server.sharingpool,o,(void*)1); - assert(retval == DICT_OK); + redisAssert(retval == DICT_OK); incrRefCount(o); } return o; @@ -2098,7 +2486,7 @@ static int tryObjectEncoding(robj *o) { if (o->refcount > 1) return REDIS_ERR; /* Currently we try to encode only strings */ - assert(o->type == REDIS_STRING); + redisAssert(o->type == REDIS_STRING); /* Check if we can represent this string as a long integer */ if (isStringRepresentableAsLong(s,&value) == REDIS_ERR) return REDIS_ERR; @@ -2110,11 +2498,15 @@ static int tryObjectEncoding(robj *o) { return REDIS_OK; } -/* Get a decoded version of an encoded object (returned as a new object) */ -static robj *getDecodedObject(const robj *o) { +/* Get a decoded version of an encoded object (returned as a new object). + * If the object is already raw-encoded just increment the ref count. */ +static robj *getDecodedObject(robj *o) { robj *dec; - assert(o->encoding != REDIS_ENCODING_RAW); + if (o->encoding == REDIS_ENCODING_RAW) { + incrRefCount(o); + return o; + } if (o->type == REDIS_STRING && o->encoding == REDIS_ENCODING_INT) { char buf[32]; @@ -2122,16 +2514,20 @@ static robj *getDecodedObject(const robj *o) { dec = createStringObject(buf,strlen(buf)); return dec; } else { - assert(1 != 1); + redisAssert(1 != 1); } } /* Compare two string objects via strcmp() or alike. * Note that the objects may be integer-encoded. In such a case we * use snprintf() to get a string representation of the numbers on the stack - * and compare the strings, it's much faster than calling getDecodedObject(). */ + * and compare the strings, it's much faster than calling getDecodedObject(). + * + * Important note: if objects are not integer encoded, but binary-safe strings, + * sdscmp() from sds.c will apply memcmp() so this function ca be considered + * binary safe. */ static int compareStringObjects(robj *a, robj *b) { - assert(a->type == REDIS_STRING && b->type == REDIS_STRING); + redisAssert(a->type == REDIS_STRING && b->type == REDIS_STRING); char bufa[128], bufb[128], *astr, *bstr; int bothsds = 1; @@ -2154,7 +2550,7 @@ static int compareStringObjects(robj *a, robj *b) { } static size_t stringObjectLen(robj *o) { - assert(o->type == REDIS_STRING); + redisAssert(o->type == REDIS_STRING); if (o->encoding == REDIS_ENCODING_RAW) { return sdslen(o->ptr); } else { @@ -2164,7 +2560,7 @@ static size_t stringObjectLen(robj *o) { } } -/*============================ DB saving/loading ============================ */ +/*============================ RDB saving/loading =========================== */ static int rdbSaveType(FILE *fp, unsigned char type) { if (fwrite(&type,1,1,fp) == 0) return -1; @@ -2285,7 +2681,7 @@ static int rdbSaveStringObjectRaw(FILE *fp, robj *obj) { /* Try LZF compression - under 20 bytes it's unable to compress even * aaaaaaaaaaaaaaaaaa so skip it */ - if (len > 20) { + if (server.rdbcompression && len > 20) { int retval; retval = rdbSaveLzfStringObject(fp,obj); @@ -2303,16 +2699,11 @@ static int rdbSaveStringObjectRaw(FILE *fp, robj *obj) { /* Like rdbSaveStringObjectRaw() but handle encoded objects */ static int rdbSaveStringObject(FILE *fp, robj *obj) { int retval; - robj *dec; - if (obj->encoding != REDIS_ENCODING_RAW) { - dec = getDecodedObject(obj); - retval = rdbSaveStringObjectRaw(fp,dec); - decrRefCount(dec); - return retval; - } else { - return rdbSaveStringObjectRaw(fp,obj); - } + obj = getDecodedObject(obj); + retval = rdbSaveStringObjectRaw(fp,obj); + decrRefCount(obj); + return retval; } /* Save a double value. Doubles are saved as strings prefixed by an unsigned @@ -2334,14 +2725,87 @@ static int rdbSaveDoubleValue(FILE *fp, double val) { len = 1; buf[0] = (val < 0) ? 255 : 254; } else { - snprintf((char*)buf+1,sizeof(buf)-1,"%.16g",val); - buf[0] = strlen((char*)buf); + snprintf((char*)buf+1,sizeof(buf)-1,"%.17g",val); + buf[0] = strlen((char*)buf+1); len = buf[0]+1; } if (fwrite(buf,len,1,fp) == 0) return -1; return 0; } +/* Save a Redis object. */ +static int rdbSaveObject(FILE *fp, robj *o) { + if (o->type == REDIS_STRING) { + /* Save a string value */ + if (rdbSaveStringObject(fp,o) == -1) return -1; + } else if (o->type == REDIS_LIST) { + /* Save a list value */ + list *list = o->ptr; + listNode *ln; + + listRewind(list); + if (rdbSaveLen(fp,listLength(list)) == -1) return -1; + while((ln = listYield(list))) { + robj *eleobj = listNodeValue(ln); + + if (rdbSaveStringObject(fp,eleobj) == -1) return -1; + } + } else if (o->type == REDIS_SET) { + /* Save a set value */ + dict *set = o->ptr; + dictIterator *di = dictGetIterator(set); + dictEntry *de; + + if (rdbSaveLen(fp,dictSize(set)) == -1) return -1; + while((de = dictNext(di)) != NULL) { + robj *eleobj = dictGetEntryKey(de); + + if (rdbSaveStringObject(fp,eleobj) == -1) return -1; + } + dictReleaseIterator(di); + } else if (o->type == REDIS_ZSET) { + /* Save a set value */ + zset *zs = o->ptr; + dictIterator *di = dictGetIterator(zs->dict); + dictEntry *de; + + if (rdbSaveLen(fp,dictSize(zs->dict)) == -1) return -1; + while((de = dictNext(di)) != NULL) { + robj *eleobj = dictGetEntryKey(de); + double *score = dictGetEntryVal(de); + + if (rdbSaveStringObject(fp,eleobj) == -1) return -1; + if (rdbSaveDoubleValue(fp,*score) == -1) return -1; + } + dictReleaseIterator(di); + } else { + redisAssert(0 != 0); + } + return 0; +} + +/* Return the length the object will have on disk if saved with + * the rdbSaveObject() function. Currently we use a trick to get + * this length with very little changes to the code. In the future + * we could switch to a faster solution. */ +static off_t rdbSavedObjectLen(robj *o) { + static FILE *fp = NULL; + + if (fp == NULL) fp = fopen("/dev/null","w"); + assert(fp != NULL); + + rewind(fp); + assert(rdbSaveObject(fp,o) != 1); + return ftello(fp); +} + +/* Return the number of pages required to save this object in the swap file */ +static off_t rdbSavedObjectPages(robj *o) { + off_t bytes = rdbSavedObjectLen(o); + + return (bytes+(server.vm_page_size-1))/server.vm_page_size; +} + /* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */ static int rdbSave(char *filename) { dictIterator *di = NULL; @@ -2388,52 +2852,8 @@ static int rdbSave(char *filename) { /* Save the key and associated value */ if (rdbSaveType(fp,o->type) == -1) goto werr; if (rdbSaveStringObject(fp,key) == -1) goto werr; - if (o->type == REDIS_STRING) { - /* Save a string value */ - if (rdbSaveStringObject(fp,o) == -1) goto werr; - } else if (o->type == REDIS_LIST) { - /* Save a list value */ - list *list = o->ptr; - listNode *ln; - - listRewind(list); - if (rdbSaveLen(fp,listLength(list)) == -1) goto werr; - while((ln = listYield(list))) { - robj *eleobj = listNodeValue(ln); - - if (rdbSaveStringObject(fp,eleobj) == -1) goto werr; - } - } else if (o->type == REDIS_SET) { - /* Save a set value */ - dict *set = o->ptr; - dictIterator *di = dictGetIterator(set); - dictEntry *de; - - if (rdbSaveLen(fp,dictSize(set)) == -1) goto werr; - while((de = dictNext(di)) != NULL) { - robj *eleobj = dictGetEntryKey(de); - - if (rdbSaveStringObject(fp,eleobj) == -1) goto werr; - } - dictReleaseIterator(di); - } else if (o->type == REDIS_ZSET) { - /* Save a set value */ - zset *zs = o->ptr; - dictIterator *di = dictGetIterator(zs->dict); - dictEntry *de; - - if (rdbSaveLen(fp,dictSize(zs->dict)) == -1) goto werr; - while((de = dictNext(di)) != NULL) { - robj *eleobj = dictGetEntryKey(de); - double *score = dictGetEntryVal(de); - - if (rdbSaveStringObject(fp,eleobj) == -1) goto werr; - if (rdbSaveDoubleValue(fp,*score) == -1) goto werr; - } - dictReleaseIterator(di); - } else { - assert(0 != 0); - } + /* Save the actual value */ + if (rdbSaveObject(fp,o) == -1) goto werr; } dictReleaseIterator(di); } @@ -2468,7 +2888,7 @@ werr: static int rdbSaveBackground(char *filename) { pid_t childpid; - if (server.bgsaveinprogress) return REDIS_ERR; + if (server.bgsavechildpid != -1) return REDIS_ERR; if ((childpid = fork()) == 0) { /* Child */ close(server.fd); @@ -2485,7 +2905,6 @@ static int rdbSaveBackground(char *filename) { return REDIS_ERR; } redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid); - server.bgsaveinprogress = 1; server.bgsavechildpid = childpid; return REDIS_OK; } @@ -2516,35 +2935,29 @@ static time_t rdbLoadTime(FILE *fp) { * * isencoded is set to 1 if the readed length is not actually a length but * an "encoding type", check the above comments for more info */ -static uint32_t rdbLoadLen(FILE *fp, int rdbver, int *isencoded) { +static uint32_t rdbLoadLen(FILE *fp, int *isencoded) { unsigned char buf[2]; uint32_t len; + int type; if (isencoded) *isencoded = 0; - if (rdbver == 0) { + if (fread(buf,1,1,fp) == 0) return REDIS_RDB_LENERR; + type = (buf[0]&0xC0)>>6; + if (type == REDIS_RDB_6BITLEN) { + /* Read a 6 bit len */ + return buf[0]&0x3F; + } else if (type == REDIS_RDB_ENCVAL) { + /* Read a 6 bit len encoding type */ + if (isencoded) *isencoded = 1; + return buf[0]&0x3F; + } else if (type == REDIS_RDB_14BITLEN) { + /* Read a 14 bit len */ + if (fread(buf+1,1,1,fp) == 0) return REDIS_RDB_LENERR; + return ((buf[0]&0x3F)<<8)|buf[1]; + } else { + /* Read a 32 bit len */ if (fread(&len,4,1,fp) == 0) return REDIS_RDB_LENERR; return ntohl(len); - } else { - int type; - - if (fread(buf,1,1,fp) == 0) return REDIS_RDB_LENERR; - type = (buf[0]&0xC0)>>6; - if (type == REDIS_RDB_6BITLEN) { - /* Read a 6 bit len */ - return buf[0]&0x3F; - } else if (type == REDIS_RDB_ENCVAL) { - /* Read a 6 bit len encoding type */ - if (isencoded) *isencoded = 1; - return buf[0]&0x3F; - } else if (type == REDIS_RDB_14BITLEN) { - /* Read a 14 bit len */ - if (fread(buf+1,1,1,fp) == 0) return REDIS_RDB_LENERR; - return ((buf[0]&0x3F)<<8)|buf[1]; - } else { - /* Read a 32 bit len */ - if (fread(&len,4,1,fp) == 0) return REDIS_RDB_LENERR; - return ntohl(len); - } } } @@ -2567,18 +2980,18 @@ static robj *rdbLoadIntegerObject(FILE *fp, int enctype) { val = (int32_t)v; } else { val = 0; /* anti-warning */ - assert(0!=0); + redisAssert(0!=0); } return createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%lld",val)); } -static robj *rdbLoadLzfStringObject(FILE*fp, int rdbver) { +static robj *rdbLoadLzfStringObject(FILE*fp) { unsigned int len, clen; unsigned char *c = NULL; sds val = NULL; - if ((clen = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) return NULL; - if ((len = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) return NULL; + if ((clen = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL; + if ((len = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL; if ((c = zmalloc(clen)) == NULL) goto err; if ((val = sdsnewlen(NULL,len)) == NULL) goto err; if (fread(c,clen,1,fp) == 0) goto err; @@ -2591,12 +3004,12 @@ err: return NULL; } -static robj *rdbLoadStringObject(FILE*fp, int rdbver) { +static robj *rdbLoadStringObject(FILE*fp) { int isencoded; uint32_t len; sds val; - len = rdbLoadLen(fp,rdbver,&isencoded); + len = rdbLoadLen(fp,&isencoded); if (isencoded) { switch(len) { case REDIS_RDB_ENC_INT8: @@ -2604,9 +3017,9 @@ static robj *rdbLoadStringObject(FILE*fp, int rdbver) { case REDIS_RDB_ENC_INT32: return tryObjectSharing(rdbLoadIntegerObject(fp,len)); case REDIS_RDB_ENC_LZF: - return tryObjectSharing(rdbLoadLzfStringObject(fp,rdbver)); + return tryObjectSharing(rdbLoadLzfStringObject(fp)); default: - assert(0!=0); + redisAssert(0!=0); } } @@ -2631,11 +3044,65 @@ static int rdbLoadDoubleValue(FILE *fp, double *val) { case 253: *val = R_Nan; return 0; default: if (fread(buf,len,1,fp) == 0) return -1; + buf[len] = '\0'; sscanf(buf, "%lg", val); return 0; } } +/* Load a Redis object of the specified type from the specified file. + * On success a newly allocated object is returned, otherwise NULL. */ +static robj *rdbLoadObject(int type, FILE *fp) { + robj *o; + + if (type == REDIS_STRING) { + /* Read string value */ + if ((o = rdbLoadStringObject(fp)) == NULL) return NULL; + tryObjectEncoding(o); + } else if (type == REDIS_LIST || type == REDIS_SET) { + /* Read list/set value */ + uint32_t listlen; + + if ((listlen = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL; + o = (type == REDIS_LIST) ? createListObject() : createSetObject(); + /* Load every single element of the list/set */ + while(listlen--) { + robj *ele; + + if ((ele = rdbLoadStringObject(fp)) == NULL) return NULL; + tryObjectEncoding(ele); + if (type == REDIS_LIST) { + listAddNodeTail((list*)o->ptr,ele); + } else { + dictAdd((dict*)o->ptr,ele,NULL); + } + } + } else if (type == REDIS_ZSET) { + /* Read list/set value */ + uint32_t zsetlen; + zset *zs; + + if ((zsetlen = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) return NULL; + o = createZsetObject(); + zs = o->ptr; + /* Load every single element of the list/set */ + while(zsetlen--) { + robj *ele; + double *score = zmalloc(sizeof(double)); + + if ((ele = rdbLoadStringObject(fp)) == NULL) return NULL; + tryObjectEncoding(ele); + if (rdbLoadDoubleValue(fp,score) == -1) return NULL; + dictAdd(zs->dict,ele,score); + zslInsert(zs->zsl,*score,ele); + incrRefCount(ele); /* added to skiplist */ + } + } else { + redisAssert(0 != 0); + } + return o; +} + static int rdbLoad(char *filename) { FILE *fp; robj *keyobj = NULL; @@ -2656,7 +3123,7 @@ static int rdbLoad(char *filename) { return REDIS_ERR; } rdbver = atoi(buf+5); - if (rdbver > 1) { + if (rdbver != 1) { fclose(fp); redisLog(REDIS_WARNING,"Can't handle RDB format version %d",rdbver); return REDIS_ERR; @@ -2674,7 +3141,7 @@ static int rdbLoad(char *filename) { if (type == REDIS_EOF) break; /* Handle SELECT DB opcode as a special case */ if (type == REDIS_SELECTDB) { - if ((dbid = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) + if ((dbid = rdbLoadLen(fp,NULL)) == REDIS_RDB_LENERR) goto eoferr; if (dbid >= (unsigned)server.dbnum) { redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server.dbnum); @@ -2685,55 +3152,9 @@ static int rdbLoad(char *filename) { continue; } /* Read key */ - if ((keyobj = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr; - - if (type == REDIS_STRING) { - /* Read string value */ - if ((o = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr; - tryObjectEncoding(o); - } else if (type == REDIS_LIST || type == REDIS_SET) { - /* Read list/set value */ - uint32_t listlen; - - if ((listlen = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) - goto eoferr; - o = (type == REDIS_LIST) ? createListObject() : createSetObject(); - /* Load every single element of the list/set */ - while(listlen--) { - robj *ele; - - if ((ele = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr; - tryObjectEncoding(ele); - if (type == REDIS_LIST) { - listAddNodeTail((list*)o->ptr,ele); - } else { - dictAdd((dict*)o->ptr,ele,NULL); - } - } - } else if (type == REDIS_ZSET) { - /* Read list/set value */ - uint32_t zsetlen; - zset *zs; - - if ((zsetlen = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) - goto eoferr; - o = createZsetObject(); - zs = o->ptr; - /* Load every single element of the list/set */ - while(zsetlen--) { - robj *ele; - double *score = zmalloc(sizeof(double)); - - if ((ele = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr; - tryObjectEncoding(ele); - if (rdbLoadDoubleValue(fp,score) == -1) goto eoferr; - dictAdd(zs->dict,ele,score); - zslInsert(zs->zsl,*score,ele); - incrRefCount(ele); /* added to skiplist */ - } - } else { - assert(0 != 0); - } + if ((keyobj = rdbLoadStringObject(fp)) == NULL) goto eoferr; + /* Read value */ + if ((o = rdbLoadObject(type,fp)) == NULL) goto eoferr; /* Add the new object in the hash table */ retval = dictAdd(d,keyobj,o); if (retval == DICT_ERR) { @@ -2786,6 +3207,7 @@ static void echoCommand(redisClient *c) { static void setGenericCommand(redisClient *c, int nx) { int retval; + if (nx) deleteIfVolatile(c->db,c->argv[1]); retval = dictAdd(c->db->dict,c->argv[1],c->argv[2]); if (retval == DICT_ERR) { if (!nx) { @@ -2812,24 +3234,31 @@ static void setnxCommand(redisClient *c) { setGenericCommand(c,1); } -static void getCommand(redisClient *c) { +static int getGenericCommand(redisClient *c) { robj *o = lookupKeyRead(c->db,c->argv[1]); if (o == NULL) { addReply(c,shared.nullbulk); + return REDIS_OK; } else { if (o->type != REDIS_STRING) { addReply(c,shared.wrongtypeerr); + return REDIS_ERR; } else { addReplyBulkLen(c,o); addReply(c,o); addReply(c,shared.crlf); + return REDIS_OK; } } } +static void getCommand(redisClient *c) { + getGenericCommand(c); +} + static void getsetCommand(redisClient *c) { - getCommand(c); + if (getGenericCommand(c) == REDIS_ERR) return; if (dictAdd(c->db->dict,c->argv[1],c->argv[2]) == DICT_ERR) { dictReplace(c->db->dict,c->argv[1],c->argv[2]); } else { @@ -2860,6 +3289,53 @@ static void mgetCommand(redisClient *c) { } } +static void msetGenericCommand(redisClient *c, int nx) { + int j, busykeys = 0; + + if ((c->argc % 2) == 0) { + addReplySds(c,sdsnew("-ERR wrong number of arguments for MSET\r\n")); + return; + } + /* Handle the NX flag. The MSETNX semantic is to return zero and don't + * set nothing at all if at least one already key exists. */ + if (nx) { + for (j = 1; j < c->argc; j += 2) { + if (lookupKeyWrite(c->db,c->argv[j]) != NULL) { + busykeys++; + } + } + } + if (busykeys) { + addReply(c, shared.czero); + return; + } + + for (j = 1; j < c->argc; j += 2) { + int retval; + + tryObjectEncoding(c->argv[j+1]); + retval = dictAdd(c->db->dict,c->argv[j],c->argv[j+1]); + if (retval == DICT_ERR) { + dictReplace(c->db->dict,c->argv[j],c->argv[j+1]); + incrRefCount(c->argv[j+1]); + } else { + incrRefCount(c->argv[j]); + incrRefCount(c->argv[j+1]); + } + removeExpire(c->db,c->argv[j]); + } + server.dirty += (c->argc-1)/2; + addReply(c, nx ? shared.cone : shared.ok); +} + +static void msetCommand(redisClient *c) { + msetGenericCommand(c,0); +} + +static void msetnxCommand(redisClient *c) { + msetGenericCommand(c,1); +} + static void incrDecrCommand(redisClient *c, long long incr) { long long value; int retval; @@ -2879,7 +3355,7 @@ static void incrDecrCommand(redisClient *c, long long incr) { else if (o->encoding == REDIS_ENCODING_INT) value = (long)o->ptr; else - assert(1 != 1); + redisAssert(1 != 1); } } @@ -2977,7 +3453,7 @@ static void keysCommand(redisClient *c) { dictEntry *de; sds pattern = c->argv[1]->ptr; int plen = sdslen(pattern); - int numkeys = 0, keyslen = 0; + unsigned long numkeys = 0, keyslen = 0; robj *lenobj = createObject(REDIS_STRING,NULL); di = dictGetIterator(c->db->dict); @@ -3034,7 +3510,7 @@ static void typeCommand(redisClient *c) { } static void saveCommand(redisClient *c) { - if (server.bgsaveinprogress) { + if (server.bgsavechildpid != -1) { addReplySds(c,sdsnew("-ERR background save in progress\r\n")); return; } @@ -3046,12 +3522,13 @@ static void saveCommand(redisClient *c) { } static void bgsaveCommand(redisClient *c) { - if (server.bgsaveinprogress) { + if (server.bgsavechildpid != -1) { addReplySds(c,sdsnew("-ERR background save already in progress\r\n")); return; } if (rdbSaveBackground(server.dbfilename) == REDIS_OK) { - addReply(c,shared.ok); + char *status = "+Background saving started\r\n"; + addReplySds(c,sdsnew(status)); } else { addReply(c,shared.err); } @@ -3062,25 +3539,31 @@ static void shutdownCommand(redisClient *c) { /* 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) { + if (server.bgsavechildpid != -1) { 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); - redisLog(REDIS_WARNING,"%zu bytes used at exit",zmalloc_used_memory()); - redisLog(REDIS_WARNING,"Server exit now, bye bye..."); - exit(1); + if (server.appendonly) { + /* Append only file: fsync() the AOF and exit */ + fsync(server.appendfd); + exit(0); } 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")); + /* Snapshotting. Perform a SYNC SAVE and exit */ + if (rdbSave(server.dbfilename) == REDIS_OK) { + if (server.daemonize) + unlink(server.pidfile); + redisLog(REDIS_WARNING,"%zu bytes used at exit",zmalloc_used_memory()); + redisLog(REDIS_WARNING,"Server exit now, bye bye..."); + exit(0); + } 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")); + } } } @@ -3174,6 +3657,10 @@ static void pushGenericCommand(redisClient *c, int where) { lobj = lookupKeyWrite(c->db,c->argv[1]); if (lobj == NULL) { + if (handleClientsWaitingListPush(c,c->argv[1],c->argv[2])) { + addReply(c,shared.ok); + return; + } lobj = createListObject(); list = lobj->ptr; if (where == REDIS_HEAD) { @@ -3189,6 +3676,10 @@ static void pushGenericCommand(redisClient *c, int where) { addReply(c,shared.wrongtypeerr); return; } + if (handleClientsWaitingListPush(c,c->argv[1],c->argv[2])) { + addReply(c,shared.ok); + return; + } list = lobj->ptr; if (where == REDIS_HEAD) { listAddNodeHead(list,c->argv[2]); @@ -3378,7 +3869,7 @@ static void ltrimCommand(redisClient *c) { o = lookupKeyWrite(c->db,c->argv[1]); if (o == NULL) { - addReply(c,shared.nokeyerr); + addReply(c,shared.ok); } else { if (o->type != REDIS_LIST) { addReply(c,shared.wrongtypeerr); @@ -3458,6 +3949,74 @@ 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 && dobj->type != REDIS_LIST) { + addReply(c,shared.wrongtypeerr); + return; + } + + /* Add the element to the target list (unless it's directly + * passed to some BLPOP-ing client */ + if (!handleClientsWaitingListPush(c,c->argv[2],ele)) { + 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]); + } + 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) { @@ -3570,7 +4129,7 @@ static void scardCommand(redisClient *c) { addReply(c,shared.wrongtypeerr); } else { s = o->ptr; - addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n", + addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n", dictSize(s))); } } @@ -3635,12 +4194,12 @@ static int qsortCompareSetsByCardinality(const void *s1, const void *s2) { return dictSize(*d1)-dictSize(*d2); } -static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, robj *dstkey) { +static void sinterGenericCommand(redisClient *c, robj **setskeys, unsigned long setsnum, robj *dstkey) { dict **dv = zmalloc(sizeof(dict*)*setsnum); dictIterator *di; dictEntry *de; robj *lenobj = NULL, *dstset = NULL; - int j, cardinality = 0; + unsigned long j, cardinality = 0; for (j = 0; j < setsnum; j++) { robj *setobj; @@ -3651,8 +4210,9 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r if (!setobj) { zfree(dv); if (dstkey) { - deleteKey(c->db,dstkey); - addReply(c,shared.ok); + if (deleteKey(c->db,dstkey)) + server.dirty++; + addReply(c,shared.czero); } else { addReply(c,shared.nullmultibulk); } @@ -3717,9 +4277,9 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r } if (!dstkey) { - lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality); + lenobj->ptr = sdscatprintf(sdsempty(),"*%lu\r\n",cardinality); } else { - addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n", + addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n", dictSize((dict*)dstset->ptr))); server.dirty++; } @@ -3821,7 +4381,7 @@ static void sunionDiffGenericCommand(redisClient *c, robj **setskeys, int setsnu if (!dstkey) { decrRefCount(dstset); } else { - addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n", + addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n", dictSize((dict*)dstset->ptr))); server.dirty++; } @@ -4049,56 +4609,101 @@ static zskiplistNode *zslFirstWithScore(zskiplist *zsl, double score) { /* The actual Z-commands implementations */ -static void zaddCommand(redisClient *c) { +/* This generic command implements both ZADD and ZINCRBY. + * scoreval is the score if the operation is a ZADD (doincrement == 0) or + * the increment if the operation is a ZINCRBY (doincrement == 1). */ +static void zaddGenericCommand(redisClient *c, robj *key, robj *ele, double scoreval, int doincrement) { robj *zsetobj; zset *zs; double *score; - zsetobj = lookupKeyWrite(c->db,c->argv[1]); + zsetobj = lookupKeyWrite(c->db,key); if (zsetobj == NULL) { zsetobj = createZsetObject(); - dictAdd(c->db->dict,c->argv[1],zsetobj); - incrRefCount(c->argv[1]); + dictAdd(c->db->dict,key,zsetobj); + incrRefCount(key); } else { if (zsetobj->type != REDIS_ZSET) { addReply(c,shared.wrongtypeerr); return; } } - score = zmalloc(sizeof(double)); - *score = strtod(c->argv[2]->ptr,NULL); zs = zsetobj->ptr; - if (dictAdd(zs->dict,c->argv[3],score) == DICT_OK) { + + /* Ok now since we implement both ZADD and ZINCRBY here the code + * needs to handle the two different conditions. It's all about setting + * '*score', that is, the new score to set, to the right value. */ + score = zmalloc(sizeof(double)); + if (doincrement) { + dictEntry *de; + + /* Read the old score. If the element was not present starts from 0 */ + de = dictFind(zs->dict,ele); + if (de) { + double *oldscore = dictGetEntryVal(de); + *score = *oldscore + scoreval; + } else { + *score = scoreval; + } + } else { + *score = scoreval; + } + + /* What follows is a simple remove and re-insert operation that is common + * to both ZADD and ZINCRBY... */ + if (dictAdd(zs->dict,ele,score) == DICT_OK) { /* case 1: New element */ - incrRefCount(c->argv[3]); /* added to hash */ - zslInsert(zs->zsl,*score,c->argv[3]); - incrRefCount(c->argv[3]); /* added to skiplist */ + incrRefCount(ele); /* added to hash */ + zslInsert(zs->zsl,*score,ele); + incrRefCount(ele); /* added to skiplist */ server.dirty++; - addReply(c,shared.cone); + if (doincrement) + addReplyDouble(c,*score); + else + addReply(c,shared.cone); } else { dictEntry *de; double *oldscore; /* case 2: Score update operation */ - de = dictFind(zs->dict,c->argv[3]); - assert(de != NULL); + de = dictFind(zs->dict,ele); + redisAssert(de != NULL); oldscore = dictGetEntryVal(de); if (*score != *oldscore) { int deleted; - deleted = zslDelete(zs->zsl,*oldscore,c->argv[3]); - assert(deleted != 0); - zslInsert(zs->zsl,*score,c->argv[3]); - incrRefCount(c->argv[3]); - dictReplace(zs->dict,c->argv[3],score); + /* Remove and insert the element in the skip list with new score */ + deleted = zslDelete(zs->zsl,*oldscore,ele); + redisAssert(deleted != 0); + zslInsert(zs->zsl,*score,ele); + incrRefCount(ele); + /* Update the score in the hash table */ + dictReplace(zs->dict,ele,score); server.dirty++; } else { zfree(score); } - addReply(c,shared.czero); + if (doincrement) + addReplyDouble(c,*score); + else + addReply(c,shared.czero); } } +static void zaddCommand(redisClient *c) { + double scoreval; + + scoreval = strtod(c->argv[2]->ptr,NULL); + zaddGenericCommand(c,c->argv[1],c->argv[3],scoreval,0); +} + +static void zincrbyCommand(redisClient *c) { + double scoreval; + + scoreval = strtod(c->argv[2]->ptr,NULL); + zaddGenericCommand(c,c->argv[1],c->argv[3],scoreval,1); +} + static void zremCommand(redisClient *c) { robj *zsetobj; zset *zs; @@ -4124,7 +4729,7 @@ static void zremCommand(redisClient *c) { /* Delete from the skiplist */ oldscore = dictGetEntryVal(de); deleted = zslDelete(zs->zsl,*oldscore,c->argv[2]); - assert(deleted != 0); + redisAssert(deleted != 0); /* Delete from the hash table */ dictDelete(zs->dict,c->argv[2]); @@ -4162,6 +4767,14 @@ static void zrangeGenericCommand(redisClient *c, int reverse) { robj *o; int start = atoi(c->argv[2]->ptr); int end = atoi(c->argv[3]->ptr); + int withscores = 0; + + if (c->argc == 5 && !strcasecmp(c->argv[4]->ptr,"withscores")) { + withscores = 1; + } else if (c->argc >= 5) { + addReply(c,shared.syntaxerr); + return; + } o = lookupKeyRead(c->db,c->argv[1]); if (o == NULL) { @@ -4204,12 +4817,15 @@ static void zrangeGenericCommand(redisClient *c, int reverse) { ln = ln->forward[0]; } - addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",rangelen)); + addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n", + withscores ? (rangelen*2) : rangelen)); for (j = 0; j < rangelen; j++) { ele = ln->obj; addReplyBulkLen(c,ele); addReply(c,ele); addReply(c,shared.crlf); + if (withscores) + addReplyDouble(c,ln->score); ln = reverse ? ln->backward : ln->forward[0]; } } @@ -4228,6 +4844,20 @@ static void zrangebyscoreCommand(redisClient *c) { robj *o; double min = strtod(c->argv[2]->ptr,NULL); double max = strtod(c->argv[3]->ptr,NULL); + int offset = 0, limit = -1; + + if (c->argc != 4 && c->argc != 7) { + addReplySds(c, + sdsnew("-ERR wrong number of arguments for ZRANGEBYSCORE\r\n")); + return; + } else if (c->argc == 7 && strcasecmp(c->argv[4]->ptr,"limit")) { + addReply(c,shared.syntaxerr); + return; + } else if (c->argc == 7) { + offset = atoi(c->argv[5]->ptr); + limit = atoi(c->argv[6]->ptr); + if (offset < 0) offset = 0; + } o = lookupKeyRead(c->db,c->argv[1]); if (o == NULL) { @@ -4256,14 +4886,22 @@ static void zrangebyscoreCommand(redisClient *c) { * it later */ lenobj = createObject(REDIS_STRING,NULL); addReply(c,lenobj); + decrRefCount(lenobj); while(ln && ln->score <= max) { + if (offset) { + offset--; + ln = ln->forward[0]; + continue; + } + if (limit == 0) break; ele = ln->obj; addReplyBulkLen(c,ele); addReply(c,ele); addReply(c,shared.crlf); ln = ln->forward[0]; rangelen++; + if (limit > 0) limit--; } lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",rangelen); } @@ -4283,7 +4921,7 @@ static void zcardCommand(redisClient *c) { addReply(c,shared.wrongtypeerr); } else { zs = o->ptr; - addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",zs->zsl->length)); + addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n",zs->zsl->length)); } } } @@ -4294,7 +4932,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) { @@ -4307,12 +4945,9 @@ static void zscoreCommand(redisClient *c) { if (!de) { addReply(c,shared.nullbulk); } else { - char buf[128]; double *score = dictGetEntryVal(de); - snprintf(buf,sizeof(buf),"%.16g",*score); - addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n%s\r\n", - strlen(buf),buf)); + addReplyDouble(c,*score); } } } @@ -4355,17 +4990,25 @@ static robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) { char buf[REDIS_SORTKEY_MAX+1]; } keyname; - if (subst->encoding == REDIS_ENCODING_RAW) - incrRefCount(subst); - else { - subst = getDecodedObject(subst); + /* If the pattern is "#" return the substitution object itself in order + * to implement the "SORT ... GET #" feature. */ + spat = pattern->ptr; + if (spat[0] == '#' && spat[1] == '\0') { + return subst; } - spat = pattern->ptr; + /* The substitution object may be specially encoded. If so we create + * a decoded object on the fly. Otherwise getDecodedObject will just + * increment the ref count, that we'll decrement later. */ + subst = getDecodedObject(subst); + ssub = subst->ptr; if (sdslen(spat)+sdslen(ssub)-1 > REDIS_SORTKEY_MAX) return NULL; p = strchr(spat,'*'); - if (!p) return NULL; + if (!p) { + decrRefCount(subst); + return NULL; + } prefixlen = p-spat; sublen = sdslen(ssub); @@ -4376,10 +5019,7 @@ static robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) { keyname.buf[prefixlen+sublen+postfixlen] = '\0'; keyname.len = prefixlen+sublen+postfixlen; - keyobj.refcount = 1; - keyobj.type = REDIS_STRING; - keyobj.ptr = ((char*)&keyname)+(sizeof(long)*2); - + initStaticStringObject(keyobj,((char*)&keyname)+(sizeof(long)*2)) decrRefCount(subst); /* printf("lookup '%s' => %p\n", keyname.buf,de); */ @@ -4419,20 +5059,13 @@ static int sortCompare(const void *s1, const void *s2) { } } else { /* Compare elements directly */ - if (so1->obj->encoding == REDIS_ENCODING_RAW && - so2->obj->encoding == REDIS_ENCODING_RAW) { - cmp = strcoll(so1->obj->ptr,so2->obj->ptr); - } else { - robj *dec1, *dec2; - - dec1 = so1->obj->encoding == REDIS_ENCODING_RAW ? - so1->obj : getDecodedObject(so1->obj); - dec2 = so2->obj->encoding == REDIS_ENCODING_RAW ? - so2->obj : getDecodedObject(so2->obj); - cmp = strcoll(dec1->ptr,dec2->ptr); - if (dec1 != so1->obj) decrRefCount(dec1); - if (dec2 != so2->obj) decrRefCount(dec2); - } + robj *dec1, *dec2; + + dec1 = getDecodedObject(so1->obj); + dec2 = getDecodedObject(so2->obj); + cmp = strcoll(dec1->ptr,dec2->ptr); + decrRefCount(dec1); + decrRefCount(dec2); } } return server.sort_desc ? -cmp : cmp; @@ -4447,16 +5080,18 @@ static void sortCommand(redisClient *c) { int limit_start = 0, limit_count = -1, start, end; int j, dontsort = 0, vectorlen; int getop = 0; /* GET operation counter */ - robj *sortval, *sortby = NULL; + robj *sortval, *sortby = NULL, *storekey = NULL; redisSortObject *vector; /* Resulting vector to sort */ /* Lookup the key to sort. It must be of the right types */ sortval = lookupKeyRead(c->db,c->argv[1]); if (sortval == NULL) { - addReply(c,shared.nokeyerr); + addReply(c,shared.nullmultibulk); return; } - if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST) { + if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST && + sortval->type != REDIS_ZSET) + { addReply(c,shared.wrongtypeerr); return; } @@ -4485,6 +5120,9 @@ static void sortCommand(redisClient *c) { limit_start = atoi(c->argv[j+1]->ptr); limit_count = atoi(c->argv[j+2]->ptr); j+=2; + } else if (!strcasecmp(c->argv[j]->ptr,"store") && leftargs >= 1) { + storekey = c->argv[j+1]; + j++; } else if (!strcasecmp(c->argv[j]->ptr,"by") && leftargs >= 1) { sortby = c->argv[j+1]; /* If the BY pattern does not contain '*', i.e. it is constant, @@ -4496,18 +5134,6 @@ static void sortCommand(redisClient *c) { REDIS_SORT_GET,c->argv[j+1])); getop++; j++; - } else if (!strcasecmp(c->argv[j]->ptr,"del") && leftargs >= 1) { - listAddNodeTail(operations,createSortOperation( - REDIS_SORT_DEL,c->argv[j+1])); - j++; - } else if (!strcasecmp(c->argv[j]->ptr,"incr") && leftargs >= 1) { - listAddNodeTail(operations,createSortOperation( - REDIS_SORT_INCR,c->argv[j+1])); - j++; - } else if (!strcasecmp(c->argv[j]->ptr,"get") && leftargs >= 1) { - listAddNodeTail(operations,createSortOperation( - REDIS_SORT_DECR,c->argv[j+1])); - j++; } else { decrRefCount(sortval); listRelease(operations); @@ -4518,11 +5144,15 @@ static void sortCommand(redisClient *c) { } /* Load the sorting vector with all the objects to sort */ - vectorlen = (sortval->type == REDIS_LIST) ? - listLength((list*)sortval->ptr) : - dictSize((dict*)sortval->ptr); + switch(sortval->type) { + case REDIS_LIST: vectorlen = listLength((list*)sortval->ptr); break; + case REDIS_SET: vectorlen = dictSize((dict*)sortval->ptr); break; + case REDIS_ZSET: vectorlen = dictSize(((zset*)sortval->ptr)->dict); break; + default: vectorlen = 0; redisAssert(0); /* Avoid GCC warning */ + } vector = zmalloc(sizeof(redisSortObject)*vectorlen); j = 0; + if (sortval->type == REDIS_LIST) { list *list = sortval->ptr; listNode *ln; @@ -4536,10 +5166,17 @@ static void sortCommand(redisClient *c) { j++; } } else { - dict *set = sortval->ptr; + dict *set; dictIterator *di; dictEntry *setele; + if (sortval->type == REDIS_SET) { + set = sortval->ptr; + } else { + zset *zs = sortval->ptr; + set = zs->dict; + } + di = dictGetIterator(set); while((setele = dictNext(di)) != NULL) { vector[j].obj = dictGetEntryKey(setele); @@ -4549,7 +5186,7 @@ static void sortCommand(redisClient *c) { } dictReleaseIterator(di); } - assert(j == vectorlen); + redisAssert(j == vectorlen); /* Now it's time to load the right scores in the sorting vector */ if (dontsort == 0) { @@ -4560,20 +5197,18 @@ static void sortCommand(redisClient *c) { byval = lookupKeyByPattern(c->db,sortby,vector[j].obj); if (!byval || byval->type != REDIS_STRING) continue; if (alpha) { - if (byval->encoding == REDIS_ENCODING_RAW) { - vector[j].u.cmpobj = byval; - incrRefCount(byval); - } else { - vector[j].u.cmpobj = getDecodedObject(byval); - } + vector[j].u.cmpobj = getDecodedObject(byval); } else { if (byval->encoding == REDIS_ENCODING_RAW) { vector[j].u.score = strtod(byval->ptr,NULL); } else { + /* Don't need to decode the object if it's + * integer-encoded (the only encoding supported) so + * far. We can just cast it */ if (byval->encoding == REDIS_ENCODING_INT) { vector[j].u.score = (long)byval->ptr; } else - assert(1 != 1); + redisAssert(1 != 1); } } } else { @@ -4584,7 +5219,7 @@ static void sortCommand(redisClient *c) { if (vector[j].obj->encoding == REDIS_ENCODING_INT) vector[j].u.score = (long) vector[j].obj->ptr; else - assert(1 != 1); + redisAssert(1 != 1); } } } @@ -4614,32 +5249,72 @@ static void sortCommand(redisClient *c) { /* Send command output to the output buffer, performing the specified * GET/DEL/INCR/DECR operations if any. */ outputlen = getop ? getop*(end-start+1) : end-start+1; - addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen)); - for (j = start; j <= end; j++) { - listNode *ln; - if (!getop) { - addReplyBulkLen(c,vector[j].obj); - addReply(c,vector[j].obj); - addReply(c,shared.crlf); + if (storekey == NULL) { + /* STORE option not specified, sent the sorting result to client */ + addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen)); + for (j = start; j <= end; j++) { + listNode *ln; + if (!getop) { + addReplyBulkLen(c,vector[j].obj); + addReply(c,vector[j].obj); + addReply(c,shared.crlf); + } + listRewind(operations); + while((ln = listYield(operations))) { + redisSortOperation *sop = ln->value; + robj *val = lookupKeyByPattern(c->db,sop->pattern, + vector[j].obj); + + if (sop->type == REDIS_SORT_GET) { + if (!val || val->type != REDIS_STRING) { + addReply(c,shared.nullbulk); + } else { + addReplyBulkLen(c,val); + addReply(c,val); + addReply(c,shared.crlf); + } + } else { + redisAssert(sop->type == REDIS_SORT_GET); /* always fails */ + } + } } - listRewind(operations); - while((ln = listYield(operations))) { - redisSortOperation *sop = ln->value; - robj *val = lookupKeyByPattern(c->db,sop->pattern, - vector[j].obj); + } else { + robj *listObject = createListObject(); + list *listPtr = (list*) listObject->ptr; - if (sop->type == REDIS_SORT_GET) { - if (!val || val->type != REDIS_STRING) { - addReply(c,shared.nullbulk); + /* STORE option specified, set the sorting result as a List object */ + for (j = start; j <= end; j++) { + listNode *ln; + if (!getop) { + listAddNodeTail(listPtr,vector[j].obj); + incrRefCount(vector[j].obj); + } + listRewind(operations); + while((ln = listYield(operations))) { + redisSortOperation *sop = ln->value; + robj *val = lookupKeyByPattern(c->db,sop->pattern, + vector[j].obj); + + if (sop->type == REDIS_SORT_GET) { + if (!val || val->type != REDIS_STRING) { + listAddNodeTail(listPtr,createStringObject("",0)); + } else { + listAddNodeTail(listPtr,val); + incrRefCount(val); + } } else { - addReplyBulkLen(c,val); - addReply(c,val); - addReply(c,shared.crlf); + redisAssert(sop->type == REDIS_SORT_GET); /* always fails */ } - } else if (sop->type == REDIS_SORT_DEL) { - /* TODO */ } } + if (dictReplace(c->db->dict,storekey,listObject)) { + incrRefCount(storekey); + } + /* Note: we add 1 because the DB is dirty anyway since even if the + * SORT result is empty a new key is set and maybe the old content + * replaced. */ + server.dirty += 1+outputlen; + addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",outputlen)); } /* Cleanup */ @@ -4652,7 +5327,10 @@ static void sortCommand(redisClient *c) { zfree(vector); } -static void infoCommand(redisClient *c) { +/* 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. */ +static sds genRedisInfoString(void) { sds info; time_t uptime = time(NULL)-server.stat_starttime; int j; @@ -4660,27 +5338,33 @@ static void infoCommand(redisClient *c) { info = sdscatprintf(sdsempty(), "redis_version:%s\r\n" "arch_bits:%s\r\n" - "uptime_in_seconds:%d\r\n" - "uptime_in_days:%d\r\n" + "multiplexing_api:%s\r\n" + "uptime_in_seconds:%ld\r\n" + "uptime_in_days:%ld\r\n" "connected_clients:%d\r\n" "connected_slaves:%d\r\n" + "blocked_clients:%d\r\n" "used_memory:%zu\r\n" "changes_since_last_save:%lld\r\n" "bgsave_in_progress:%d\r\n" - "last_save_time:%d\r\n" + "last_save_time:%ld\r\n" + "bgrewriteaof_in_progress:%d\r\n" "total_connections_received:%lld\r\n" "total_commands_processed:%lld\r\n" "role:%s\r\n" ,REDIS_VERSION, (sizeof(long) == 8) ? "64" : "32", + aeGetApiName(), uptime, uptime/(3600*24), listLength(server.clients)-listLength(server.slaves), listLength(server.slaves), + server.blockedclients, server.usedmemory, server.dirty, - server.bgsaveinprogress, + server.bgsavechildpid != -1, server.lastsave, + server.bgrewritechildpid != -1, server.stat_numconnections, server.stat_numcommands, server.masterhost == NULL ? "master" : "slave" @@ -4704,11 +5388,17 @@ static void infoCommand(redisClient *c) { 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", + info = sdscatprintf(info, "db%d:keys=%lld,expires=%lld\r\n", j, keys, vkeys); } } - addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(info))); + return info; +} + +static void infoCommand(redisClient *c) { + sds info = genRedisInfoString(); + addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n", + (unsigned long)sdslen(info))); addReplySds(c,info); addReply(c,shared.crlf); } @@ -4827,74 +5517,301 @@ static void ttlCommand(redisClient *c) { addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",ttl)); } -static void msetGenericCommand(redisClient *c, int nx) { - int j; +/* ================================ MULTI/EXEC ============================== */ - if ((c->argc % 2) == 0) { - addReplySds(c,sdsnew("-ERR wrong number of arguments\r\n")); - return; - } - /* Handle the NX flag. The MSETNX semantic is to return zero and don't - * set nothing at all if at least one already key exists. */ - if (nx) { - for (j = 1; j < c->argc; j += 2) { - if (dictFind(c->db->dict,c->argv[j]) != NULL) { - addReply(c, shared.czero); - return; - } - } - } +/* Client state initialization for MULTI/EXEC */ +static void initClientMultiState(redisClient *c) { + c->mstate.commands = NULL; + c->mstate.count = 0; +} - for (j = 1; j < c->argc; j += 2) { - int retval; +/* Release all the resources associated with MULTI/EXEC state */ +static void freeClientMultiState(redisClient *c) { + int j; - retval = dictAdd(c->db->dict,c->argv[j],c->argv[j+1]); - if (retval == DICT_ERR) { - dictReplace(c->db->dict,c->argv[j],c->argv[j+1]); - incrRefCount(c->argv[j+1]); - } else { - incrRefCount(c->argv[j]); - incrRefCount(c->argv[j+1]); - } - removeExpire(c->db,c->argv[j]); + for (j = 0; j < c->mstate.count; j++) { + int i; + multiCmd *mc = c->mstate.commands+j; + + for (i = 0; i < mc->argc; i++) + decrRefCount(mc->argv[i]); + zfree(mc->argv); } - server.dirty += (c->argc-1)/2; - addReply(c, nx ? shared.cone : shared.ok); + zfree(c->mstate.commands); } -static void msetCommand(redisClient *c) { - msetGenericCommand(c,0); +/* Add a new command into the MULTI commands queue */ +static void queueMultiCommand(redisClient *c, struct redisCommand *cmd) { + multiCmd *mc; + int j; + + c->mstate.commands = zrealloc(c->mstate.commands, + sizeof(multiCmd)*(c->mstate.count+1)); + mc = c->mstate.commands+c->mstate.count; + mc->cmd = cmd; + mc->argc = c->argc; + mc->argv = zmalloc(sizeof(robj*)*c->argc); + memcpy(mc->argv,c->argv,sizeof(robj*)*c->argc); + for (j = 0; j < c->argc; j++) + incrRefCount(mc->argv[j]); + c->mstate.count++; } -static void msetnxCommand(redisClient *c) { - msetGenericCommand(c,1); +static void multiCommand(redisClient *c) { + c->flags |= REDIS_MULTI; + addReply(c,shared.ok); } -/* =============================== Replication ============================= */ +static void execCommand(redisClient *c) { + int j; + robj **orig_argv; + int orig_argc; -static int syncWrite(int fd, char *ptr, ssize_t size, int timeout) { - ssize_t nwritten, ret = size; - time_t start = time(NULL); + if (!(c->flags & REDIS_MULTI)) { + addReplySds(c,sdsnew("-ERR EXEC without MULTI\r\n")); + return; + } - timeout++; - while(size) { - if (aeWait(fd,AE_WRITABLE,1000) & AE_WRITABLE) { - nwritten = write(fd,ptr,size); - if (nwritten == -1) return -1; - ptr += nwritten; - size -= nwritten; - } - if ((time(NULL)-start) > timeout) { - errno = ETIMEDOUT; - return -1; - } + orig_argv = c->argv; + orig_argc = c->argc; + addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->mstate.count)); + for (j = 0; j < c->mstate.count; j++) { + c->argc = c->mstate.commands[j].argc; + c->argv = c->mstate.commands[j].argv; + call(c,c->mstate.commands[j].cmd); } - return ret; + c->argv = orig_argv; + c->argc = orig_argc; + freeClientMultiState(c); + initClientMultiState(c); + c->flags &= (~REDIS_MULTI); } -static int syncRead(int fd, char *ptr, ssize_t size, int timeout) { - ssize_t nread, totread = 0; - time_t start = time(NULL); +/* =========================== Blocking Operations ========================= */ + +/* Currently Redis blocking operations support is limited to list POP ops, + * so the current implementation is not fully generic, but it is also not + * completely specific so it will not require a rewrite to support new + * kind of blocking operations in the future. + * + * Still it's important to note that list blocking operations can be already + * used as a notification mechanism in order to implement other blocking + * operations at application level, so there must be a very strong evidence + * of usefulness and generality before new blocking operations are implemented. + * + * This is how the current blocking POP works, we use BLPOP as example: + * - If the user calls BLPOP and the key exists and contains a non empty list + * then LPOP is called instead. So BLPOP is semantically the same as LPOP + * if there is not to block. + * - If instead BLPOP is called and the key does not exists or the list is + * empty we need to block. In order to do so we remove the notification for + * new data to read in the client socket (so that we'll not serve new + * requests if the blocking request is not served). Also we put the client + * in a dictionary (db->blockingkeys) mapping keys to a list of clients + * blocking for this keys. + * - If a PUSH operation against a key with blocked clients waiting is + * performed, we serve the first in the list: basically instead to push + * the new element inside the list we return it to the (first / oldest) + * blocking client, unblock the client, and remove it form the list. + * + * The above comment and the source code should be enough in order to understand + * the implementation and modify / fix it later. + */ + +/* Set a client in blocking mode for the specified key, with the specified + * timeout */ +static void blockForKeys(redisClient *c, robj **keys, int numkeys, time_t timeout) { + dictEntry *de; + list *l; + int j; + + c->blockingkeys = zmalloc(sizeof(robj*)*numkeys); + c->blockingkeysnum = numkeys; + c->blockingto = timeout; + for (j = 0; j < numkeys; j++) { + /* Add the key in the client structure, to map clients -> keys */ + c->blockingkeys[j] = keys[j]; + incrRefCount(keys[j]); + + /* And in the other "side", to map keys -> clients */ + de = dictFind(c->db->blockingkeys,keys[j]); + if (de == NULL) { + int retval; + + /* For every key we take a list of clients blocked for it */ + l = listCreate(); + retval = dictAdd(c->db->blockingkeys,keys[j],l); + incrRefCount(keys[j]); + assert(retval == DICT_OK); + } else { + l = dictGetEntryVal(de); + } + listAddNodeTail(l,c); + } + /* Mark the client as a blocked client */ + c->flags |= REDIS_BLOCKED; + aeDeleteFileEvent(server.el,c->fd,AE_READABLE); + server.blockedclients++; +} + +/* Unblock a client that's waiting in a blocking operation such as BLPOP */ +static void unblockClient(redisClient *c) { + dictEntry *de; + list *l; + int j; + + assert(c->blockingkeys != NULL); + /* The client may wait for multiple keys, so unblock it for every key. */ + for (j = 0; j < c->blockingkeysnum; j++) { + /* Remove this client from the list of clients waiting for this key. */ + de = dictFind(c->db->blockingkeys,c->blockingkeys[j]); + assert(de != NULL); + l = dictGetEntryVal(de); + listDelNode(l,listSearchKey(l,c)); + /* If the list is empty we need to remove it to avoid wasting memory */ + if (listLength(l) == 0) + dictDelete(c->db->blockingkeys,c->blockingkeys[j]); + decrRefCount(c->blockingkeys[j]); + } + /* Cleanup the client structure */ + zfree(c->blockingkeys); + c->blockingkeys = NULL; + c->flags &= (~REDIS_BLOCKED); + server.blockedclients--; + /* Ok now we are ready to get read events from socket, note that we + * can't trap errors here as it's possible that unblockClients() is + * called from freeClient() itself, and the only thing we can do + * if we failed to register the READABLE event is to kill the client. + * Still the following function should never fail in the real world as + * we are sure the file descriptor is sane, and we exit on out of mem. */ + aeCreateFileEvent(server.el, c->fd, AE_READABLE, readQueryFromClient, c); + /* As a final step we want to process data if there is some command waiting + * in the input buffer. Note that this is safe even if unblockClient() + * gets called from freeClient() because freeClient() will be smart + * enough to call this function *after* c->querybuf was set to NULL. */ + if (c->querybuf && sdslen(c->querybuf) > 0) processInputBuffer(c); +} + +/* This should be called from any function PUSHing into lists. + * 'c' is the "pushing client", 'key' is the key it is pushing data against, + * 'ele' is the element pushed. + * + * If the function returns 0 there was no client waiting for a list push + * against this key. + * + * If the function returns 1 there was a client waiting for a list push + * against this key, the element was passed to this client thus it's not + * needed to actually add it to the list and the caller should return asap. */ +static int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele) { + struct dictEntry *de; + redisClient *receiver; + list *l; + listNode *ln; + + de = dictFind(c->db->blockingkeys,key); + if (de == NULL) return 0; + l = dictGetEntryVal(de); + ln = listFirst(l); + assert(ln != NULL); + receiver = ln->value; + + addReplySds(receiver,sdsnew("*2\r\n")); + addReplyBulkLen(receiver,key); + addReply(receiver,key); + addReply(receiver,shared.crlf); + addReplyBulkLen(receiver,ele); + addReply(receiver,ele); + addReply(receiver,shared.crlf); + unblockClient(receiver); + return 1; +} + +/* Blocking RPOP/LPOP */ +static void blockingPopGenericCommand(redisClient *c, int where) { + robj *o; + time_t timeout; + int j; + + for (j = 1; j < c->argc-1; j++) { + o = lookupKeyWrite(c->db,c->argv[j]); + if (o != NULL) { + if (o->type != REDIS_LIST) { + addReply(c,shared.wrongtypeerr); + return; + } else { + list *list = o->ptr; + if (listLength(list) != 0) { + /* If the list contains elements fall back to the usual + * non-blocking POP operation */ + robj *argv[2], **orig_argv; + int orig_argc; + + /* We need to alter the command arguments before to call + * popGenericCommand() as the command takes a single key. */ + orig_argv = c->argv; + orig_argc = c->argc; + argv[1] = c->argv[j]; + c->argv = argv; + c->argc = 2; + + /* Also the return value is different, we need to output + * the multi bulk reply header and the key name. The + * "real" command will add the last element (the value) + * for us. If this souds like an hack to you it's just + * because it is... */ + addReplySds(c,sdsnew("*2\r\n")); + addReplyBulkLen(c,argv[1]); + addReply(c,argv[1]); + addReply(c,shared.crlf); + popGenericCommand(c,where); + + /* Fix the client structure with the original stuff */ + c->argv = orig_argv; + c->argc = orig_argc; + return; + } + } + } + } + /* If the list is empty or the key does not exists we must block */ + timeout = strtol(c->argv[c->argc-1]->ptr,NULL,10); + if (timeout > 0) timeout += time(NULL); + blockForKeys(c,c->argv+1,c->argc-2,timeout); +} + +static void blpopCommand(redisClient *c) { + blockingPopGenericCommand(c,REDIS_HEAD); +} + +static void brpopCommand(redisClient *c) { + blockingPopGenericCommand(c,REDIS_TAIL); +} + +/* =============================== Replication ============================= */ + +static int syncWrite(int fd, char *ptr, ssize_t size, int timeout) { + ssize_t nwritten, ret = size; + time_t start = time(NULL); + + timeout++; + while(size) { + if (aeWait(fd,AE_WRITABLE,1000) & AE_WRITABLE) { + nwritten = write(fd,ptr,size); + if (nwritten == -1) return -1; + ptr += nwritten; + size -= nwritten; + } + if ((time(NULL)-start) > timeout) { + errno = ETIMEDOUT; + return -1; + } + } + return ret; +} + +static int syncRead(int fd, char *ptr, ssize_t size, int timeout) { + ssize_t nread, totread = 0; + time_t start = time(NULL); timeout++; while(size) { @@ -4950,7 +5867,7 @@ static void syncCommand(redisClient *c) { redisLog(REDIS_NOTICE,"Slave ask for synchronization"); /* Here we need to check if there is a background saving operation * in progress, or if it is required to start one */ - if (server.bgsaveinprogress) { + if (server.bgsavechildpid != -1) { /* Ok a background save is in progress. Let's check if it is a good * one for replication, i.e. if there is another slave that is * registering differences since the server forked to save */ @@ -5037,7 +5954,7 @@ static void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) { aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE); slave->replstate = REDIS_REPL_ONLINE; if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, - sendReplyToClient, slave, NULL) == AE_ERR) { + sendReplyToClient, slave) == AE_ERR) { freeClient(slave); return; } @@ -5081,7 +5998,7 @@ static void updateSlavesWaitingBgsave(int bgsaveerr) { slave->repldbsize = buf.st_size; slave->replstate = REDIS_REPL_SEND_BULK; aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE); - if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, sendBulkToSlave, slave, NULL) == AE_ERR) { + if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, sendBulkToSlave, slave) == AE_ERR) { freeClient(slave); continue; } @@ -5102,7 +6019,7 @@ static void updateSlavesWaitingBgsave(int bgsaveerr) { } static int syncWithMaster(void) { - char buf[1024], tmpfile[256]; + char buf[1024], tmpfile[256], authcmd[1024]; int dumpsize; int fd = anetTcpConnect(NULL,server.masterhost,server.masterport); int dfd; @@ -5112,6 +6029,30 @@ static int syncWithMaster(void) { strerror(errno)); return REDIS_ERR; } + + /* AUTH with the master if required. */ + if(server.masterauth) { + snprintf(authcmd, 1024, "AUTH %s\r\n", server.masterauth); + if (syncWrite(fd, authcmd, strlen(server.masterauth)+7, 5) == -1) { + close(fd); + redisLog(REDIS_WARNING,"Unable to AUTH to MASTER: %s", + strerror(errno)); + return REDIS_ERR; + } + /* Read the AUTH result. */ + if (syncReadLine(fd,buf,1024,3600) == -1) { + close(fd); + redisLog(REDIS_WARNING,"I/O error reading auth result from MASTER: %s", + strerror(errno)); + return REDIS_ERR; + } + if (buf[0] != '+') { + close(fd); + redisLog(REDIS_WARNING,"Cannot AUTH to MASTER, is the masterauth password correct?"); + return REDIS_ERR; + } + } + /* Issue the SYNC command */ if (syncWrite(fd,"SYNC \r\n",7,5) == -1) { close(fd); @@ -5176,6 +6117,7 @@ static int syncWithMaster(void) { } server.master = createClient(fd); server.master->flags |= REDIS_MASTER; + server.master->authenticated = 1; server.replstate = REDIS_REPL_CONNECTED; return REDIS_OK; } @@ -5269,8 +6211,8 @@ static void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv char seldb[64]; snprintf(seldb,sizeof(seldb),"%d",dictid); - buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n", - strlen(seldb),seldb); + buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n", + (unsigned long)strlen(seldb),seldb); server.appendseldb = dictid; } @@ -5293,13 +6235,11 @@ static void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv for (j = 0; j < argc; j++) { robj *o = argv[j]; - if (o->encoding != REDIS_ENCODING_RAW) - o = getDecodedObject(o); - buf = sdscatprintf(buf,"$%d\r\n",sdslen(o->ptr)); + o = getDecodedObject(o); + buf = sdscatprintf(buf,"$%lu\r\n",(unsigned long)sdslen(o->ptr)); buf = sdscatlen(buf,o->ptr,sdslen(o->ptr)); buf = sdscatlen(buf,"\r\n",2); - if (o != argv[j]) - decrRefCount(o); + decrRefCount(o); } /* Free the objects from the modified argv for EXPIREAT */ @@ -5325,6 +6265,14 @@ static void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv } exit(1); } + /* If a background append only file rewriting is in progress we want to + * accumulate the differences between the child DB and the current one + * in a buffer, so that when the child process will do its work we + * can append the differences to the new append only file. */ + if (server.bgrewritechildpid != -1) + server.bgrewritebuf = sdscatlen(server.bgrewritebuf,buf,sdslen(buf)); + + sdsfree(buf); now = time(NULL); if (server.appendfsync == APPENDFSYNC_ALWAYS || (server.appendfsync == APPENDFSYNC_EVERYSEC && @@ -5400,7 +6348,7 @@ int loadAppendOnlyFile(char *filename) { if (buf[0] != '$') goto fmterr; len = strtol(buf+1,NULL,10); argsds = sdsnewlen(NULL,len); - if (fread(argsds,len,1,fp) == 0) goto fmterr; + if (len && fread(argsds,len,1,fp) == 0) goto fmterr; argv[j] = createObject(REDIS_STRING,argsds); if (fread(buf,2,1,fp) == 0) goto fmterr; /* discard CRLF */ } @@ -5446,282 +6394,521 @@ fmterr: exit(1); } -/* ================================= Debugging ============================== */ - -static void debugCommand(redisClient *c) { - if (!strcasecmp(c->argv[1]->ptr,"segfault")) { - *((char*)-1) = 'x'; - } else if (!strcasecmp(c->argv[1]->ptr,"object") && c->argc == 3) { - dictEntry *de = dictFind(c->db->dict,c->argv[2]); - robj *key, *val; - - if (!de) { - addReply(c,shared.nokeyerr); - return; - } - key = dictGetEntryKey(de); - val = dictGetEntryVal(de); - addReplySds(c,sdscatprintf(sdsempty(), - "+Key at:%p refcount:%d, value at:%p refcount:%d encoding:%d\r\n", - key, key->refcount, val, val->refcount, val->encoding)); - } else { - addReplySds(c,sdsnew( - "-ERR Syntax error, try DEBUG [SEGFAULT|OBJECT ]\r\n")); - } +/* Write an object into a file in the bulk format $\r\n\r\n */ +static int fwriteBulk(FILE *fp, robj *obj) { + char buf[128]; + obj = getDecodedObject(obj); + snprintf(buf,sizeof(buf),"$%ld\r\n",(long)sdslen(obj->ptr)); + if (fwrite(buf,strlen(buf),1,fp) == 0) goto err; + if (sdslen(obj->ptr) && fwrite(obj->ptr,sdslen(obj->ptr),1,fp) == 0) + goto err; + if (fwrite("\r\n",2,1,fp) == 0) goto err; + decrRefCount(obj); + return 1; +err: + decrRefCount(obj); + return 0; } -#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} -}; - -/* 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; +/* Write a double value in bulk format $\r\n\r\n */ +static int fwriteBulkDouble(FILE *fp, double d) { + char buf[128], dbuf[128]; - 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; + snprintf(dbuf,sizeof(dbuf),"%.17g\r\n",d); + snprintf(buf,sizeof(buf),"$%lu\r\n",(unsigned long)strlen(dbuf)-2); + if (fwrite(buf,strlen(buf),1,fp) == 0) return 0; + if (fwrite(dbuf,strlen(dbuf),1,fp) == 0) return 0; + return 1; } -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) - #if defined(_STRUCT_X86_THREAD_STATE64) && !defined(__i386__) - 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 +/* Write a long value in bulk format $\r\n\r\n */ +static int fwriteBulkLong(FILE *fp, long l) { + char buf[128], lbuf[128]; + + snprintf(lbuf,sizeof(lbuf),"%ld\r\n",l); + snprintf(buf,sizeof(buf),"$%lu\r\n",(unsigned long)strlen(lbuf)-2); + if (fwrite(buf,strlen(buf),1,fp) == 0) return 0; + if (fwrite(lbuf,strlen(lbuf),1,fp) == 0) return 0; + return 1; } -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); +/* Write a sequence of commands able to fully rebuild the dataset into + * "filename". Used both by REWRITEAOF and BGREWRITEAOF. */ +static int rewriteAppendOnlyFile(char *filename) { + dictIterator *di = NULL; + dictEntry *de; + FILE *fp; + char tmpfile[256]; + int j; + time_t now = time(NULL); - 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); + /* Note that we have to use a different temp name here compared to the + * one used by rewriteAppendOnlyFileBackground() function. */ + snprintf(tmpfile,256,"temp-rewriteaof-%d.aof", (int) getpid()); + fp = fopen(tmpfile,"w"); + if (!fp) { + redisLog(REDIS_WARNING, "Failed rewriting the append only file: %s", strerror(errno)); + return REDIS_ERR; } - messages = backtrace_symbols(trace, trace_size); - - for (i=1; idict; + if (dictSize(d) == 0) continue; + di = dictGetIterator(d); + if (!di) { + fclose(fp); + return REDIS_ERR; } - } - free(messages); - exit(0); -} -static void setupSigSegvAction(void) { - struct sigaction act; + /* SELECT the new DB */ + if (fwrite(selectcmd,sizeof(selectcmd)-1,1,fp) == 0) goto werr; + if (fwriteBulkLong(fp,j) == 0) goto werr; - sigemptyset (&act.sa_mask); - /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction - * is used. Otherwise, sa_handler is used */ - act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO; - act.sa_sigaction = segvHandler; - sigaction (SIGSEGV, &act, NULL); - sigaction (SIGBUS, &act, NULL); - sigaction (SIGFPE, &act, NULL); - sigaction (SIGILL, &act, NULL); - sigaction (SIGBUS, &act, NULL); - return; -} -#else /* HAVE_BACKTRACE */ -static void setupSigSegvAction(void) { -} -#endif /* HAVE_BACKTRACE */ + /* Iterate this DB writing every entry */ + while((de = dictNext(di)) != NULL) { + robj *key = dictGetEntryKey(de); + robj *o = dictGetEntryVal(de); + time_t expiretime = getExpire(db,key); -/* =================================== Main! ================================ */ + /* Save the key and associated value */ + if (o->type == REDIS_STRING) { + /* Emit a SET command */ + char cmd[]="*3\r\n$3\r\nSET\r\n"; + if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr; + /* Key and value */ + if (fwriteBulk(fp,key) == 0) goto werr; + if (fwriteBulk(fp,o) == 0) goto werr; + } else if (o->type == REDIS_LIST) { + /* Emit the RPUSHes needed to rebuild the list */ + list *list = o->ptr; + listNode *ln; -#ifdef __linux__ -int linuxOvercommitMemoryValue(void) { - FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r"); - char buf[64]; + listRewind(list); + while((ln = listYield(list))) { + char cmd[]="*3\r\n$5\r\nRPUSH\r\n"; + robj *eleobj = listNodeValue(ln); - if (!fp) return -1; - if (fgets(buf,64,fp) == NULL) { + if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr; + if (fwriteBulk(fp,key) == 0) goto werr; + if (fwriteBulk(fp,eleobj) == 0) goto werr; + } + } else if (o->type == REDIS_SET) { + /* Emit the SADDs needed to rebuild the set */ + dict *set = o->ptr; + dictIterator *di = dictGetIterator(set); + dictEntry *de; + + while((de = dictNext(di)) != NULL) { + char cmd[]="*3\r\n$4\r\nSADD\r\n"; + robj *eleobj = dictGetEntryKey(de); + + if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr; + if (fwriteBulk(fp,key) == 0) goto werr; + if (fwriteBulk(fp,eleobj) == 0) goto werr; + } + dictReleaseIterator(di); + } else if (o->type == REDIS_ZSET) { + /* Emit the ZADDs needed to rebuild the sorted set */ + zset *zs = o->ptr; + dictIterator *di = dictGetIterator(zs->dict); + dictEntry *de; + + while((de = dictNext(di)) != NULL) { + char cmd[]="*4\r\n$4\r\nZADD\r\n"; + robj *eleobj = dictGetEntryKey(de); + double *score = dictGetEntryVal(de); + + if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr; + if (fwriteBulk(fp,key) == 0) goto werr; + if (fwriteBulkDouble(fp,*score) == 0) goto werr; + if (fwriteBulk(fp,eleobj) == 0) goto werr; + } + dictReleaseIterator(di); + } else { + redisAssert(0 != 0); + } + /* Save the expire time */ + if (expiretime != -1) { + char cmd[]="*3\r\n$8\r\nEXPIREAT\r\n"; + /* If this key is already expired skip it */ + if (expiretime < now) continue; + if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr; + if (fwriteBulk(fp,key) == 0) goto werr; + if (fwriteBulkLong(fp,expiretime) == 0) goto werr; + } + } + dictReleaseIterator(di); + } + + /* Make sure data will not remain on the OS's output buffers */ + fflush(fp); + fsync(fileno(fp)); + fclose(fp); + + /* Use RENAME to make sure the DB file is changed atomically only + * if the generate DB file is ok. */ + if (rename(tmpfile,filename) == -1) { + redisLog(REDIS_WARNING,"Error moving temp append only file on the final destination: %s", strerror(errno)); + unlink(tmpfile); + return REDIS_ERR; + } + redisLog(REDIS_NOTICE,"SYNC append only file rewrite performed"); + return REDIS_OK; + +werr: + fclose(fp); + unlink(tmpfile); + redisLog(REDIS_WARNING,"Write error writing append only file on disk: %s", strerror(errno)); + if (di) dictReleaseIterator(di); + return REDIS_ERR; +} + +/* This is how rewriting of the append only file in background works: + * + * 1) The user calls BGREWRITEAOF + * 2) Redis calls this function, that forks(): + * 2a) the child rewrite the append only file in a temp file. + * 2b) the parent accumulates differences in server.bgrewritebuf. + * 3) When the child finished '2a' exists. + * 4) The parent will trap the exit code, if it's OK, will append the + * data accumulated into server.bgrewritebuf into the temp file, and + * finally will rename(2) the temp file in the actual file name. + * The the new file is reopened as the new append only file. Profit! + */ +static int rewriteAppendOnlyFileBackground(void) { + pid_t childpid; + + if (server.bgrewritechildpid != -1) return REDIS_ERR; + if ((childpid = fork()) == 0) { + /* Child */ + char tmpfile[256]; + close(server.fd); + + snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) getpid()); + if (rewriteAppendOnlyFile(tmpfile) == REDIS_OK) { + exit(0); + } else { + exit(1); + } + } else { + /* Parent */ + if (childpid == -1) { + redisLog(REDIS_WARNING, + "Can't rewrite append only file in background: fork: %s", + strerror(errno)); + return REDIS_ERR; + } + redisLog(REDIS_NOTICE, + "Background append only file rewriting started by pid %d",childpid); + server.bgrewritechildpid = childpid; + /* We set appendseldb to -1 in order to force the next call to the + * feedAppendOnlyFile() to issue a SELECT command, so the differences + * accumulated by the parent into server.bgrewritebuf will start + * with a SELECT statement and it will be safe to merge. */ + server.appendseldb = -1; + return REDIS_OK; + } + return REDIS_OK; /* unreached */ +} + +static void bgrewriteaofCommand(redisClient *c) { + if (server.bgrewritechildpid != -1) { + addReplySds(c,sdsnew("-ERR background append only file rewriting already in progress\r\n")); + return; + } + if (rewriteAppendOnlyFileBackground() == REDIS_OK) { + char *status = "+Background append only file rewriting started\r\n"; + addReplySds(c,sdsnew(status)); + } else { + addReply(c,shared.err); + } +} + +static void aofRemoveTempFile(pid_t childpid) { + char tmpfile[256]; + + snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) childpid); + unlink(tmpfile); +} + +/* =============================== Virtual Memory =========================== */ +static void vmInit(void) { + off_t totsize; + + server.vm_fp = fopen("/tmp/redisvm","w+b"); + if (server.vm_fp == NULL) { + redisLog(REDIS_WARNING,"Impossible to open the swap file. Exiting."); + exit(1); + } + server.vm_fd = fileno(server.vm_fp); + server.vm_next_page = 0; + server.vm_near_pages = 0; + totsize = server.vm_pages*server.vm_page_size; + redisLog(REDIS_NOTICE,"Allocating %lld bytes of swap file",totsize); + if (ftruncate(server.vm_fd,totsize) == -1) { + redisLog(REDIS_WARNING,"Can't ftruncate swap file: %s. Exiting.", + strerror(errno)); + exit(1); + } else { + redisLog(REDIS_NOTICE,"Swap file allocated with success"); + } + server.vm_bitmap = zmalloc((server.vm_pages+7)/8); + memset(server.vm_bitmap,0,(server.vm_pages+7)/8); + /* Try to remove the swap file, so the OS will really delete it from the + * file system when Redis exists. */ + unlink("/tmp/redisvm"); +} + +/* Mark the page as used */ +static void vmMarkPageUsed(off_t page) { + off_t byte = page/8; + int bit = page&7; + server.vm_bitmap[byte] |= 1<= server.vm_pages) { + this -= server.vm_pages; + if (this == 0) { + /* Just overflowed, what we found on tail is no longer + * interesting, as it's no longer contiguous. */ + numfree = 0; + } + } + if (vmFreePage(this)) { + /* This is a free page */ + numfree++; + /* Already got N free pages? Return to the caller, with success */ + if (numfree == n) { + *first = this-(n-1); + server.vm_next_page = this+1; + return REDIS_OK; + } + } else { + /* The current one is not a free page */ + numfree = 0; + } + + /* Fast-forward if the current page is not free and we already + * searched enough near this place. */ + since_jump++; + if (!numfree && since_jump >= REDIS_VM_MAX_RANDOM_JUMP/4) { + offset += random() % REDIS_VM_MAX_RANDOM_JUMP; + since_jump = 0; + /* Note that even if we rewind after the jump, we are don't need + * to make sure numfree is set to zero as we only jump *if* it + * is set to zero. */ + } else { + /* Otherwise just check the next page */ + offset++; + } + } + return REDIS_ERR; +} + +/* Swap the 'val' object relative to 'key' into disk. Store all the information + * needed to later retrieve the object into the key object. + * If we can't find enough contiguous empty pages to swap the object on disk + * REDIS_ERR is returned. */ +static int vmSwapObject(robj *key, robj *val) { + off_t pages = rdbSavedObjectPages(val); + off_t page; + + assert(key->storage == REDIS_VM_MEMORY); + if (vmFindContiguousPages(&page,pages) == REDIS_ERR) return REDIS_ERR; + if (fseeko(server.vm_fp,page*server.vm_page_size,SEEK_SET) == -1) { + redisLog(REDIS_WARNING, + "Critical VM problem in vmSwapObject(): can't seek: %s", + strerror(errno)); + return REDIS_ERR; + } + rdbSaveObject(server.vm_fp,val); + key->vm.page = page; + key->vm.usedpages = pages; + key->storage = REDIS_VM_SWAPPED; + decrRefCount(val); /* Deallocate the object from memory. */ + vmMarkPagesUsed(page,pages); + redisLog(REDIS_DEBUG,"VM: object %s swapped out at %lld (%lld pages)", + (unsigned char*) key->ptr, + (unsigned long long) page, (unsigned long long) pages); + return REDIS_OK; +} + +/* Load the value object relative to the 'key' object from swap to memory. + * The newly allocated object is returned. */ +static robj *vmLoadObject(robj *key) { + robj *val; + + assert(key->storage == REDIS_VM_SWAPPED); + if (fseeko(server.vm_fp,key->vm.page*server.vm_page_size,SEEK_SET) == -1) { + redisLog(REDIS_WARNING, + "Unrecoverable VM problem in vmLoadObject(): can't seek: %s", + strerror(errno)); + exit(1); + } + val = rdbLoadObject(key->type,server.vm_fp); + if (val == NULL) { + redisLog(REDIS_WARNING, "Unrecoverable VM problem in vmLoadObject(): can't load object from swap file: %s", strerror(errno)); + exit(1); + } + key->storage = REDIS_VM_MEMORY; + key->vm.atime = server.unixtime; + vmMarkPagesFree(key->vm.page,key->vm.usedpages); + redisLog(REDIS_DEBUG, "VM: object %s loaded from disk", + (unsigned char*) key->ptr); + return val; +} + +/* ================================= Debugging ============================== */ + +static void debugCommand(redisClient *c) { + if (!strcasecmp(c->argv[1]->ptr,"segfault")) { + *((char*)-1) = 'x'; + } else if (!strcasecmp(c->argv[1]->ptr,"reload")) { + if (rdbSave(server.dbfilename) != REDIS_OK) { + addReply(c,shared.err); + return; + } + emptyDb(); + if (rdbLoad(server.dbfilename) != REDIS_OK) { + addReply(c,shared.err); + return; + } + redisLog(REDIS_WARNING,"DB reloaded by DEBUG RELOAD"); + addReply(c,shared.ok); + } else if (!strcasecmp(c->argv[1]->ptr,"loadaof")) { + emptyDb(); + if (loadAppendOnlyFile(server.appendfilename) != REDIS_OK) { + addReply(c,shared.err); + return; + } + redisLog(REDIS_WARNING,"Append Only File loaded by DEBUG LOADAOF"); + addReply(c,shared.ok); + } else if (!strcasecmp(c->argv[1]->ptr,"object") && c->argc == 3) { + dictEntry *de = dictFind(c->db->dict,c->argv[2]); + robj *key, *val; + + if (!de) { + addReply(c,shared.nokeyerr); + return; + } + key = dictGetEntryKey(de); + val = dictGetEntryVal(de); + addReplySds(c,sdscatprintf(sdsempty(), + "+Key at:%p refcount:%d, value at:%p refcount:%d encoding:%d serializedlength:%lld\r\n", + (void*)key, key->refcount, (void*)val, val->refcount, + val->encoding, rdbSavedObjectLen(val))); + } else if (!strcasecmp(c->argv[1]->ptr,"swapout") && c->argc == 3) { + dictEntry *de = dictFind(c->db->dict,c->argv[2]); + robj *key, *val; + + if (!server.vm_enabled) { + addReplySds(c,sdsnew("-ERR Virtual Memory is disabled\r\n")); + return; + } + if (!de) { + addReply(c,shared.nokeyerr); + return; + } + key = dictGetEntryKey(de); + val = dictGetEntryVal(de); + if (key->storage != REDIS_VM_MEMORY) { + addReplySds(c,sdsnew("-ERR This key is not in memory\r\n")); + } else if (vmSwapObject(key,val) == REDIS_OK) { + dictGetEntryVal(de) = NULL; + addReply(c,shared.ok); + } else { + addReply(c,shared.err); + } + } else { + addReplySds(c,sdsnew( + "-ERR Syntax error, try DEBUG [SEGFAULT|OBJECT |SWAPOUT |RELOAD]\r\n")); + } +} + +static void _redisAssert(char *estr) { + redisLog(REDIS_WARNING,"=== ASSERTION FAILED ==="); + redisLog(REDIS_WARNING,"==> %s\n",estr); +#ifdef HAVE_BACKTRACE + redisLog(REDIS_WARNING,"(forcing SIGSEGV in order to print the stack trace)"); + *((char*)-1) = 'x'; +#endif +} + +/* =================================== 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; } @@ -5742,6 +6929,7 @@ static void daemonize(void) { FILE *fp; if (fork() != 0) exit(0); /* parent exits */ + printf("New pid: %d\n", getpid()); setsid(); /* create a new session */ /* Every output goes to /dev/null. If Redis is daemonized but @@ -5764,7 +6952,7 @@ static void daemonize(void) { int main(int argc, char **argv) { initServerConfig(); if (argc == 2) { - ResetServerSaveParams(); + resetServerSaveParams(); loadServerConfig(argv[1]); } else if (argc > 2) { fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n"); @@ -5772,8 +6960,8 @@ int main(int argc, char **argv) { } 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(); + initServer(); redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION); #ifdef __linux__ linuxOvercommitMemoryWarning(); @@ -5786,9 +6974,129 @@ int main(int argc, char **argv) { redisLog(REDIS_NOTICE,"DB loaded from disk"); } if (aeCreateFileEvent(server.el, server.fd, AE_READABLE, - acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event"); + acceptHandler, 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; +#elif defined(__dietlibc__) + return (void*) uc->uc_mcontext.eip; +#elif defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6) + #if __x86_64__ + return (void*) uc->uc_mcontext->__ss.__rip; + #else + return (void*) uc->uc_mcontext->__ss.__eip; + #endif +#elif defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6) + #if defined(_STRUCT_X86_THREAD_STATE64) && !defined(__i386__) + return (void*) uc->uc_mcontext->__ss.__rip; + #else + return (void*) uc->uc_mcontext->__ss.__eip; + #endif +#elif defined(__i386__) || defined(__X86_64__) || defined(__x86_64__) + return (void*) uc->uc_mcontext.gregs[REG_EIP]; /* Linux 32/64 bit */ +#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; + ucontext_t *uc = (ucontext_t*) secret; + sds infostring; + REDIS_NOTUSED(info); + + redisLog(REDIS_WARNING, + "======= Ooops! Redis %s got signal: -%d- =======", REDIS_VERSION, sig); + infostring = genRedisInfoString(); + redisLog(REDIS_WARNING, "%s",infostring); + /* It's not safe to sdsfree() the returned string under memory + * corruption conditions. Let it leak as we are going to abort */ + + 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= 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; +} +#else /* HAVE_BACKTRACE */ +static void setupSigSegvAction(void) { +} +#endif /* HAVE_BACKTRACE */ + + + +/* The End */ + + +