Transactions: Use CMD_CLAL_NOQUEUE now that call() handles +QUEUED.

As a side effect this makes things like #5201 fixed automatically.
The problem with handling it in ProcessQueryBuffer() or similar is that
a client that is handled just via the call() interface will misbehave,
and call()-ing MULTI and later some command will see just the other
command executed like if the client was not in a transaction.

For now this has worked well enough but probably it makes more sense if
we can handle that case on call().

WARNING: this comment is not enough and will introduce bugs. It's a WIP.

CONTRIBUTING

@@ -14,7 +14,9 @@ each source file that you contribute.
 
   PLEASE DO NOT POST GENERAL QUESTIONS that are not about bugs or suspected
   bugs in the Github issues system. We'll be very happy to help you and provide
-  all the support in the mailing list.
+  all the support at the Reddit sub:
+
+      http://reddit.com/r/redis
 
   There is also an active community of Redis users at Stack Overflow:
 
@@ -22,12 +24,7 @@ each source file that you contribute.
 
 # How to provide a patch for a new feature
 
-1. If it is a major feature or a semantical change, please don't start coding
-straight away: if your feature is not a conceptual fit you'll lose a lot of
-time writing the code without any reason. Start by posting in the mailing list
-and creating an issue at Github with the description of, exactly, what you want
-to accomplish and why. Use cases are important for features to be accepted.
-Here you'll see if there is consensus about your idea.
+1. If it is a major feature or a semantical change, please post it as a new submission in r/redis on Reddit at http://reddit.com/r/redis. Try to be passionate about why the feature is needed, make users upvote your proposal to gain traction and so forth. Read feedbacks about the community. But in this first step **please don't write code yet**.
 
 2. If in step 1 you get an acknowledgment from the project leaders, use the
    following procedure to submit a patch:
@@ -38,13 +35,6 @@ Here you'll see if there is consensus about your idea.
     d. Initiate a pull request on github ( https://help.github.com/articles/creating-a-pull-request/ )
     e. Done :)
 
-3. Keep in mind that we are very overloaded, so issues and PRs sometimes wait
-for a *very* long time. However this is not lack of interest, as the project
-gets more and more users, we find ourselves in a constant need to prioritize
-certain issues/PRs over others. If you think your issue/PR is very important
-try to popularize it, have other users commenting and sharing their point of
-view and so forth. This helps.
-
-4. For minor fixes just open a pull request on Github.
+For minor fixes just open a pull request on Github.
 
 Thanks!

MANIFESTO

@@ -34,21 +34,7 @@ Redis Manifesto
     so that the complexity is obvious and more complex operations can be
     performed as the sum of the basic operations.
 
-4 - We believe in code efficiency. Computers get faster and faster, yet we
-    believe that abusing computing capabilities is not wise: the amount of
-    operations you can do for a given amount of energy remains anyway a
-    significant parameter: it allows to do more with less computers and, at
-    the same time, having a smaller environmental impact. Similarly Redis is
-    able to "scale down" to smaller devices. It is perfectly usable in a
-    Raspberry Pi and other small ARM based computers. Faster code having
-    just the layers of abstractions that are really needed will also result,
-    often, in more predictable performances. We think likewise about memory
-    usage, one of the fundamental goals of the Redis project is to
-    incrementally build more and more memory efficient data structures, so that
-    problems that were not approachable in RAM in the past will be perfectly
-    fine to handle in the future.
-
-5 - Code is like a poem; it's not just something we write to reach some
+4 - Code is like a poem; it's not just something we write to reach some
     practical result. Sometimes people that are far from the Redis philosophy
     suggest using other code written by other authors (frequently in other
     languages) in order to implement something Redis currently lacks. But to us
@@ -59,48 +45,23 @@ Redis Manifesto
     when needed. At the same time, when writing the Redis story we're trying to
     write smaller stories that will fit in to other code.
 
-6 - We're against complexity. We believe designing systems is a fight against
+5 - We're against complexity. We believe designing systems is a fight against
     complexity. We'll accept to fight the complexity when it's worthwhile but
     we'll try hard to recognize when a small feature is not worth 1000s of lines
     of code. Most of the time the best way to fight complexity is by not
-    creating it at all. Complexity is also a form of lock-in: code that is
-    very hard to understand cannot be modified by users in an independent way
-    regardless of the license. One of the main Redis goals is to remain
-    understandable, enough for a single programmer to have a clear idea of how
-    it works in detail just reading the source code for a couple of weeks.
+    creating it at all.
 
-7 - Threading is not a silver bullet. Instead of making Redis threaded we
-    believe on the idea of an efficient (mostly) single threaded Redis core.
-    Multiple of such cores, that may run in the same computer or may run
-    in multiple computers, are abstracted away as a single big system by
-    higher order protocols and features: Redis Cluster and the upcoming
-    Redis Proxy are our main goals. A shared nothing approach is not just
-    much simpler (see the previous point in this document), is also optimal
-    in NUMA systems. In the specific case of Redis it allows for each instance
-    to have a more limited amount of data, making the Redis persist-by-fork
-    approach more sounding. In the future we may explore parallelism only for
-    I/O, which is the low hanging fruit: minimal complexity could provide an
-    improved single process experience.
-
-8 - Two levels of API. The Redis API has two levels: 1) a subset of the API fits
+6 - Two levels of API. The Redis API has two levels: 1) a subset of the API fits
     naturally into a distributed version of Redis and 2) a more complex API that
     supports multi-key operations. Both are useful if used judiciously but
     there's no way to make the more complex multi-keys API distributed in an
     opaque way without violating our other principles. We don't want to provide
     the illusion of something that will work magically when actually it can't in
     all cases. Instead we'll provide commands to quickly migrate keys from one
-    instance to another to perform multi-key operations and expose the
-    trade-offs to the user.
+    instance to another to perform multi-key operations and expose the tradeoffs
+    to the user.
 
-9 - We optimize for joy. We believe writing code is a lot of hard work, and the
+7 - We optimize for joy. We believe writing code is a lot of hard work, and the
     only way it can be worth is by enjoying it. When there is no longer joy in
     writing code, the best thing to do is stop. To prevent this, we'll avoid
     taking paths that will make Redis less of a joy to develop.
-
-10 - All the above points are put together in what we call opportunistic
-     programming: trying to get the most for the user with minimal increases
-     in complexity (hanging fruits). Solve 95% of the problem with 5% of the
-     code when it is acceptable. Avoid a fixed schedule but follow the flow of
-     user requests, inspiration, Redis internal readiness for certain features
-     (sometimes many past changes reach a critical point making a previously
-     complex feature very easy to obtain).

README.md

@@ -216,7 +216,7 @@ Inside the root are the following important directories:
 
 * `src`: contains the Redis implementation, written in C.
 * `tests`: contains the unit tests, implemented in Tcl.
-* `deps`: contains libraries Redis uses. Everything needed to compile Redis is inside this directory; your system just needs to provide `libc`, a POSIX compatible interface and a C compiler. Notably `deps` contains a copy of `jemalloc`, which is the default allocator of Redis under Linux. Note that under `deps` there are also things which started with the Redis project, but for which the main repository is not `antirez/redis`. An exception to this rule is `deps/geohash-int` which is the low level geocoding library used by Redis: it originated from a different project, but at this point it diverged so much that it is developed as a separated entity directly inside the Redis repository.
+* `deps`: contains libraries Redis uses. Everything needed to compile Redis is inside this directory; your system just needs to provide `libc`, a POSIX compatible interface and a C compiler. Notably `deps` contains a copy of `jemalloc`, which is the default allocator of Redis under Linux. Note that under `deps` there are also things which started with the Redis project, but for which the main repository is not `anitrez/redis`. An exception to this rule is `deps/geohash-int` which is the low level geocoding library used by Redis: it originated from a different project, but at this point it diverged so much that it is developed as a separated entity directly inside the Redis repository.
 
 There are a few more directories but they are not very important for our goals
 here. We'll focus mostly on `src`, where the Redis implementation is contained,
@@ -227,7 +227,7 @@ of complexity incrementally.
 Note: lately Redis was refactored quite a bit. Function names and file
 names have been changed, so you may find that this documentation reflects the
 `unstable` branch more closely. For instance in Redis 3.0 the `server.c`
-and `server.h` files were named `redis.c` and `redis.h`. However the overall
+and `server.h` files were named to `redis.c` and `redis.h`. However the overall
 structure is the same. Keep in mind that all the new developments and pull
 requests should be performed against the `unstable` branch.
 

deps/lua/src/lua_struct.c

@@ -89,14 +89,12 @@ typedef struct Header {
 } Header;
 
 
-static int getnum (lua_State *L, const char **fmt, int df) {
+static int getnum (const char **fmt, int df) {
   if (!isdigit(**fmt))  /* no number? */
     return df;  /* return default value */
   else {
     int a = 0;
     do {
-      if (a > (INT_MAX / 10) || a * 10 > (INT_MAX - (**fmt - '0')))
-        luaL_error(L, "integral size overflow");
       a = a*10 + *((*fmt)++) - '0';
     } while (isdigit(**fmt));
     return a;
@@ -117,9 +115,9 @@ static size_t optsize (lua_State *L, char opt, const char **fmt) {
     case 'f':  return sizeof(float);
     case 'd':  return sizeof(double);
     case 'x': return 1;
-    case 'c': return getnum(L, fmt, 1);
+    case 'c': return getnum(fmt, 1);
     case 'i': case 'I': {
-      int sz = getnum(L, fmt, sizeof(int));
+      int sz = getnum(fmt, sizeof(int));
       if (sz > MAXINTSIZE)
         luaL_error(L, "integral size %d is larger than limit of %d",
                        sz, MAXINTSIZE);
@@ -152,7 +150,7 @@ static void controloptions (lua_State *L, int opt, const char **fmt,
     case '>': h->endian = BIG; return;
     case '<': h->endian = LITTLE; return;
     case '!': {
-      int a = getnum(L, fmt, MAXALIGN);
+      int a = getnum(fmt, MAXALIGN);
       if (!isp2(a))
         luaL_error(L, "alignment %d is not a power of 2", a);
       h->align = a;

redis.conf

@@ -625,7 +625,7 @@ replica-priority 100
 # memory to never hit a real out-of-memory condition before the master hits
 # the configured maxmemory setting.
 #
-# replica-ignore-maxmemory yes
+# replica-ingore-maxmemory yes
 
 ############################# LAZY FREEING ####################################
 
@@ -824,7 +824,13 @@ aof-use-rdb-preamble yes
 lua-time-limit 5000
 
 ################################ REDIS CLUSTER  ###############################
-
+#
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+# WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however
+# in order to mark it as "mature" we need to wait for a non trivial percentage
+# of users to deploy it in production.
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#
 # Normal Redis instances can't be part of a Redis Cluster; only nodes that are
 # started as cluster nodes can. In order to start a Redis instance as a
 # cluster node enable the cluster support uncommenting the following:

runtest-moduleapi

@@ -1,16 +0,0 @@
-#!/bin/sh
-TCL_VERSIONS="8.5 8.6"
-TCLSH=""
-
-for VERSION in $TCL_VERSIONS; do
-	TCL=`which tclsh$VERSION 2>/dev/null` && TCLSH=$TCL
-done
-
-if [ -z $TCLSH ]
-then
-    echo "You need tcl 8.5 or newer in order to run the Redis test"
-    exit 1
-fi
-
-make -C tests/modules && \
-$TCLSH tests/test_helper.tcl --single unit/moduleapi/commandfilter --single unit/moduleapi/testrdb "${@}"

src/Makefile

@@ -21,11 +21,6 @@ NODEPS:=clean distclean
 
 # Default settings
 STD=-std=c99 -pedantic -DREDIS_STATIC=''
-ifneq (,$(findstring clang,$(CC)))
-ifneq (,$(findstring FreeBSD,$(uname_S)))
-  STD+=-Wno-c11-extensions
-endif
-endif
 WARN=-Wall -W -Wno-missing-field-initializers
 OPT=$(OPTIMIZATION)
 
@@ -46,10 +41,6 @@ endif
 # To get ARM stack traces if Redis crashes we need a special C flag.
 ifneq (,$(filter aarch64 armv,$(uname_M)))
         CFLAGS+=-funwind-tables
-else
-ifneq (,$(findstring armv,$(uname_M)))
-        CFLAGS+=-funwind-tables
-endif
 endif
 
 # Backwards compatibility for selecting an allocator
@@ -77,15 +68,6 @@ FINAL_LDFLAGS=$(LDFLAGS) $(REDIS_LDFLAGS) $(DEBUG)
 FINAL_LIBS=-lm
 DEBUG=-g -ggdb
 
-# Linux ARM needs -latomic at linking time
-ifneq (,$(filter aarch64 armv,$(uname_M)))
-        FINAL_LIBS+=-latomic
-else
-ifneq (,$(findstring armv,$(uname_M)))
-        FINAL_LIBS+=-latomic
-endif
-endif
-
 ifeq ($(uname_S),SunOS)
 	# SunOS
         ifneq ($(@@),32bit)
@@ -111,20 +93,10 @@ else
 ifeq ($(uname_S),OpenBSD)
 	# OpenBSD
 	FINAL_LIBS+= -lpthread
-	ifeq ($(USE_BACKTRACE),yes)
-	    FINAL_CFLAGS+= -DUSE_BACKTRACE -I/usr/local/include
-	    FINAL_LDFLAGS+= -L/usr/local/lib
-	    FINAL_LIBS+= -lexecinfo
-    	endif
-
 else
 ifeq ($(uname_S),FreeBSD)
 	# FreeBSD
-	FINAL_LIBS+= -lpthread -lexecinfo
-else
-ifeq ($(uname_S),DragonFly)
-	# FreeBSD
-	FINAL_LIBS+= -lpthread -lexecinfo
+	FINAL_LIBS+= -lpthread
 else
 	# All the other OSes (notably Linux)
 	FINAL_LDFLAGS+= -rdynamic
@@ -134,7 +106,6 @@ endif
 endif
 endif
 endif
-endif
 # Include paths to dependencies
 FINAL_CFLAGS+= -I../deps/hiredis -I../deps/linenoise -I../deps/lua/src
 
@@ -319,6 +290,3 @@ install: all
 	$(REDIS_INSTALL) $(REDIS_CHECK_RDB_NAME) $(INSTALL_BIN)
 	$(REDIS_INSTALL) $(REDIS_CHECK_AOF_NAME) $(INSTALL_BIN)
 	@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_SENTINEL_NAME)
-
-uninstall:
-	rm -f $(INSTALL_BIN)/{$(REDIS_SERVER_NAME),$(REDIS_BENCHMARK_NAME),$(REDIS_CLI_NAME),$(REDIS_CHECK_RDB_NAME),$(REDIS_CHECK_AOF_NAME),$(REDIS_SENTINEL_NAME)}

src/adlist.c

@@ -327,11 +327,12 @@ listNode *listIndex(list *list, long index) {
 }
 
 /* Rotate the list removing the tail node and inserting it to the head. */
-void listRotateTailToHead(list *list) {
+void listRotate(list *list) {
+    listNode *tail = list->tail;
+
     if (listLength(list) <= 1) return;
 
     /* Detach current tail */
-    listNode *tail = list->tail;
     list->tail = tail->prev;
     list->tail->next = NULL;
     /* Move it as head */
@@ -341,21 +342,6 @@ void listRotateTailToHead(list *list) {
     list->head = tail;
 }
 
-/* Rotate the list removing the head node and inserting it to the tail. */
-void listRotateHeadToTail(list *list) {
-    if (listLength(list) <= 1) return;
-
-    listNode *head = list->head;
-    /* Detach current head */
-    list->head = head->next;
-    list->head->prev = NULL;
-    /* Move it as tail */
-    list->tail->next = head;
-    head->next = NULL;
-    head->prev = list->tail;
-    list->tail = head;
-}
-
 /* Add all the elements of the list 'o' at the end of the
  * list 'l'. The list 'other' remains empty but otherwise valid. */
 void listJoin(list *l, list *o) {

src/adlist.h

@@ -85,8 +85,7 @@ listNode *listSearchKey(list *list, void *key);
 listNode *listIndex(list *list, long index);
 void listRewind(list *list, listIter *li);
 void listRewindTail(list *list, listIter *li);
-void listRotateTailToHead(list *list);
-void listRotateHeadToTail(list *list);
+void listRotate(list *list);
 void listJoin(list *l, list *o);
 
 /* Directions for iterators */

src/aof.c

@@ -197,12 +197,6 @@ ssize_t aofRewriteBufferWrite(int fd) {
  * AOF file implementation
  * ------------------------------------------------------------------------- */
 
-/* Return true if an AOf fsync is currently already in progress in a
- * BIO thread. */
-int aofFsyncInProgress(void) {
-    return bioPendingJobsOfType(BIO_AOF_FSYNC) != 0;
-}
-
 /* Starts a background task that performs fsync() against the specified
  * file descriptor (the one of the AOF file) in another thread. */
 void aof_background_fsync(int fd) {
@@ -339,24 +333,10 @@ void flushAppendOnlyFile(int force) {
     int sync_in_progress = 0;
     mstime_t latency;
 
-    if (sdslen(server.aof_buf) == 0) {
-        /* Check if we need to do fsync even the aof buffer is empty,
-         * because previously in AOF_FSYNC_EVERYSEC mode, fsync is
-         * called only when aof buffer is not empty, so if users
-         * stop write commands before fsync called in one second,
-         * the data in page cache cannot be flushed in time. */
-        if (server.aof_fsync == AOF_FSYNC_EVERYSEC &&
-            server.aof_fsync_offset != server.aof_current_size &&
-            server.unixtime > server.aof_last_fsync &&
-            !(sync_in_progress = aofFsyncInProgress())) {
-            goto try_fsync;
-        } else {
-            return;
-        }
-    }
+    if (sdslen(server.aof_buf) == 0) return;
 
     if (server.aof_fsync == AOF_FSYNC_EVERYSEC)
-        sync_in_progress = aofFsyncInProgress();
+        sync_in_progress = bioPendingJobsOfType(BIO_AOF_FSYNC) != 0;
 
     if (server.aof_fsync == AOF_FSYNC_EVERYSEC && !force) {
         /* With this append fsync policy we do background fsyncing.
@@ -488,7 +468,6 @@ void flushAppendOnlyFile(int force) {
         server.aof_buf = sdsempty();
     }
 
-try_fsync:
     /* Don't fsync if no-appendfsync-on-rewrite is set to yes and there are
      * children doing I/O in the background. */
     if (server.aof_no_fsync_on_rewrite &&
@@ -503,14 +482,10 @@ try_fsync:
         redis_fsync(server.aof_fd); /* Let's try to get this data on the disk */
         latencyEndMonitor(latency);
         latencyAddSampleIfNeeded("aof-fsync-always",latency);
-        server.aof_fsync_offset = server.aof_current_size;
         server.aof_last_fsync = server.unixtime;
     } else if ((server.aof_fsync == AOF_FSYNC_EVERYSEC &&
                 server.unixtime > server.aof_last_fsync)) {
-        if (!sync_in_progress) {
-            aof_background_fsync(server.aof_fd);
-            server.aof_fsync_offset = server.aof_current_size;
-        }
+        if (!sync_in_progress) aof_background_fsync(server.aof_fd);
         server.aof_last_fsync = server.unixtime;
     }
 }
@@ -702,7 +677,6 @@ int loadAppendOnlyFile(char *filename) {
     int old_aof_state = server.aof_state;
     long loops = 0;
     off_t valid_up_to = 0; /* Offset of latest well-formed command loaded. */
-    off_t valid_before_multi = 0; /* Offset before MULTI command loaded. */
 
     if (fp == NULL) {
         serverLog(LL_WARNING,"Fatal error: can't open the append log file for reading: %s",strerror(errno));
@@ -715,7 +689,6 @@ int loadAppendOnlyFile(char *filename) {
      * operation is received. */
     if (fp && redis_fstat(fileno(fp),&sb) != -1 && sb.st_size == 0) {
         server.aof_current_size = 0;
-        server.aof_fsync_offset = server.aof_current_size;
         fclose(fp);
         return C_ERR;
     }
@@ -774,26 +747,18 @@ int loadAppendOnlyFile(char *filename) {
         argc = atoi(buf+1);
         if (argc < 1) goto fmterr;
 
-        /* Load the next command in the AOF as our fake client
-         * argv. */
         argv = zmalloc(sizeof(robj*)*argc);
         fakeClient->argc = argc;
         fakeClient->argv = argv;
 
         for (j = 0; j < argc; j++) {
-            /* Parse the argument len. */
-            char *readres = fgets(buf,sizeof(buf),fp);
-            if (readres == NULL || buf[0] != '$') {
+            if (fgets(buf,sizeof(buf),fp) == NULL) {
                 fakeClient->argc = j; /* Free up to j-1. */
                 freeFakeClientArgv(fakeClient);
-                if (readres == NULL)
-                    goto readerr;
-                else
-                    goto fmterr;
+                goto readerr;
             }
+            if (buf[0] != '$') goto fmterr;
             len = strtol(buf+1,NULL,10);
-
-            /* Read it into a string object. */
             argsds = sdsnewlen(SDS_NOINIT,len);
             if (len && fread(argsds,len,1,fp) == 0) {
                 sdsfree(argsds);
@@ -802,40 +767,26 @@ int loadAppendOnlyFile(char *filename) {
                 goto readerr;
             }
             argv[j] = createObject(OBJ_STRING,argsds);
-
-            /* Discard CRLF. */
             if (fread(buf,2,1,fp) == 0) {
                 fakeClient->argc = j+1; /* Free up to j. */
                 freeFakeClientArgv(fakeClient);
-                goto readerr;
+                goto readerr; /* discard CRLF */
             }
         }
 
         /* Command lookup */
         cmd = lookupCommand(argv[0]->ptr);
         if (!cmd) {
-            serverLog(LL_WARNING,
-                "Unknown command '%s' reading the append only file",
-                (char*)argv[0]->ptr);
+            serverLog(LL_WARNING,"Unknown command '%s' reading the append only file", (char*)argv[0]->ptr);
             exit(1);
         }
 
-        if (cmd == server.multiCommand) valid_before_multi = valid_up_to;
-
         /* Run the command in the context of a fake client */
         fakeClient->cmd = cmd;
-        if (fakeClient->flags & CLIENT_MULTI &&
-            fakeClient->cmd->proc != execCommand)
-        {
-            queueMultiCommand(fakeClient);
-        } else {
-            cmd->proc(fakeClient);
-        }
+        cmd->proc(fakeClient);
 
         /* The fake client should not have a reply */
-        serverAssert(fakeClient->bufpos == 0 &&
-                     listLength(fakeClient->reply) == 0);
-
+        serverAssert(fakeClient->bufpos == 0 && listLength(fakeClient->reply) == 0);
         /* The fake client should never get blocked */
         serverAssert((fakeClient->flags & CLIENT_BLOCKED) == 0);
 
@@ -850,12 +801,7 @@ int loadAppendOnlyFile(char *filename) {
      * If the client is in the middle of a MULTI/EXEC, handle it as it was
      * a short read, even if technically the protocol is correct: we want
      * to remove the unprocessed tail and continue. */
-    if (fakeClient->flags & CLIENT_MULTI) {
-        serverLog(LL_WARNING,
-            "Revert incomplete MULTI/EXEC transaction in AOF file");
-        valid_up_to = valid_before_multi;
-        goto uxeof;
-    }
+    if (fakeClient->flags & CLIENT_MULTI) goto uxeof;
 
 loaded_ok: /* DB loaded, cleanup and return C_OK to the caller. */
     fclose(fp);
@@ -864,7 +810,6 @@ loaded_ok: /* DB loaded, cleanup and return C_OK to the caller. */
     stopLoading();
     aofUpdateCurrentSize();
     server.aof_rewrite_base_size = server.aof_current_size;
-    server.aof_fsync_offset = server.aof_current_size;
     return C_OK;
 
 readerr: /* Read error. If feof(fp) is true, fall through to unexpected EOF. */
@@ -1137,7 +1082,7 @@ int rioWriteBulkStreamID(rio *r,streamID *id) {
     int retval;
 
     sds replyid = sdscatfmt(sdsempty(),"%U-%U",id->ms,id->seq);
-    retval = rioWriteBulkString(r,replyid,sdslen(replyid));
+    if ((retval = rioWriteBulkString(r,replyid,sdslen(replyid))) == 0) return 0;
     sdsfree(replyid);
     return retval;
 }
@@ -1176,47 +1121,25 @@ int rewriteStreamObject(rio *r, robj *key, robj *o) {
     streamID id;
     int64_t numfields;
 
-    if (s->length) {
-        /* Reconstruct the stream data using XADD commands. */
-        while(streamIteratorGetID(&si,&id,&numfields)) {
-            /* Emit a two elements array for each item. The first is
-             * the ID, the second is an array of field-value pairs. */
+    /* Reconstruct the stream data using XADD commands. */
+    while(streamIteratorGetID(&si,&id,&numfields)) {
+        /* Emit a two elements array for each item. The first is
+         * the ID, the second is an array of field-value pairs. */
 
-            /* Emit the XADD <key> <id> ...fields... command. */
-            if (rioWriteBulkCount(r,'*',3+numfields*2) == 0) return 0;
-            if (rioWriteBulkString(r,"XADD",4) == 0) return 0;
-            if (rioWriteBulkObject(r,key) == 0) return 0;
-            if (rioWriteBulkStreamID(r,&id) == 0) return 0;
-            while(numfields--) {
-                unsigned char *field, *value;
-                int64_t field_len, value_len;
-                streamIteratorGetField(&si,&field,&value,&field_len,&value_len);
-                if (rioWriteBulkString(r,(char*)field,field_len) == 0) return 0;
-                if (rioWriteBulkString(r,(char*)value,value_len) == 0) return 0;
-            }
-        }
-    } else {
-        /* Use the XADD MAXLEN 0 trick to generate an empty stream if
-         * the key we are serializing is an empty string, which is possible
-         * for the Stream type. */
-        if (rioWriteBulkCount(r,'*',7) == 0) return 0;
+        /* Emit the XADD <key> <id> ...fields... command. */
+        if (rioWriteBulkCount(r,'*',3+numfields*2) == 0) return 0;
         if (rioWriteBulkString(r,"XADD",4) == 0) return 0;
         if (rioWriteBulkObject(r,key) == 0) return 0;
-        if (rioWriteBulkString(r,"MAXLEN",6) == 0) return 0;
-        if (rioWriteBulkString(r,"0",1) == 0) return 0;
-        if (rioWriteBulkStreamID(r,&s->last_id) == 0) return 0;
-        if (rioWriteBulkString(r,"x",1) == 0) return 0;
-        if (rioWriteBulkString(r,"y",1) == 0) return 0;
+        if (rioWriteBulkStreamID(r,&id) == 0) return 0;
+        while(numfields--) {
+            unsigned char *field, *value;
+            int64_t field_len, value_len;
+            streamIteratorGetField(&si,&field,&value,&field_len,&value_len);
+            if (rioWriteBulkString(r,(char*)field,field_len) == 0) return 0;
+            if (rioWriteBulkString(r,(char*)value,value_len) == 0) return 0;
+        }
     }
 
-    /* Append XSETID after XADD, make sure lastid is correct,
-     * in case of XDEL lastid. */
-    if (rioWriteBulkCount(r,'*',3) == 0) return 0;
-    if (rioWriteBulkString(r,"XSETID",6) == 0) return 0;
-    if (rioWriteBulkObject(r,key) == 0) return 0;
-    if (rioWriteBulkStreamID(r,&s->last_id) == 0) return 0;
-
-
     /* Create all the stream consumer groups. */
     if (s->cgroups) {
         raxIterator ri;
@@ -1272,7 +1195,7 @@ int rewriteModuleObject(rio *r, robj *key, robj *o) {
     RedisModuleIO io;
     moduleValue *mv = o->ptr;
     moduleType *mt = mv->type;
-    moduleInitIOContext(io,mt,r,key);
+    moduleInitIOContext(io,mt,r);
     mt->aof_rewrite(&io,key,mv->value);
     if (io.ctx) {
         moduleFreeContext(io.ctx);
@@ -1771,7 +1694,6 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
             server.aof_selected_db = -1; /* Make sure SELECT is re-issued */
             aofUpdateCurrentSize();
             server.aof_rewrite_base_size = server.aof_current_size;
-            server.aof_fsync_offset = server.aof_current_size;
 
             /* Clear regular AOF buffer since its contents was just written to
              * the new AOF from the background rewrite buffer. */
@@ -1792,15 +1714,14 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
         serverLog(LL_VERBOSE,
             "Background AOF rewrite signal handler took %lldus", ustime()-now);
     } else if (!bysignal && exitcode != 0) {
-        server.aof_lastbgrewrite_status = C_ERR;
-
-        serverLog(LL_WARNING,
-            "Background AOF rewrite terminated with error");
-    } else {
         /* SIGUSR1 is whitelisted, so we have a way to kill a child without
          * tirggering an error condition. */
         if (bysignal != SIGUSR1)
             server.aof_lastbgrewrite_status = C_ERR;
+        serverLog(LL_WARNING,
+            "Background AOF rewrite terminated with error");
+    } else {
+        server.aof_lastbgrewrite_status = C_ERR;
 
         serverLog(LL_WARNING,
             "Background AOF rewrite terminated by signal %d", bysignal);

src/atomicvar.h

@@ -1,7 +1,7 @@
 /* This file implements atomic counters using __atomic or __sync macros if
  * available, otherwise synchronizing different threads using a mutex.
  *
- * The exported interface is composed of three macros:
+ * The exported interaface is composed of three macros:
  *
  * atomicIncr(var,count) -- Increment the atomic counter
  * atomicGetIncr(var,oldvalue_var,count) -- Get and increment the atomic counter

src/bitops.c

@@ -994,18 +994,12 @@ void bitfieldCommand(client *c) {
         /* Lookup for read is ok if key doesn't exit, but errors
          * if it's not a string. */
         o = lookupKeyRead(c->db,c->argv[1]);
-        if (o != NULL && checkType(c,o,OBJ_STRING)) {
-            zfree(ops);
-            return;
-        }
+        if (o != NULL && checkType(c,o,OBJ_STRING)) return;
     } else {
         /* Lookup by making room up to the farest bit reached by
          * this operation. */
         if ((o = lookupStringForBitCommand(c,
-            highest_write_offset)) == NULL) {
-            zfree(ops);
-            return;
-        }
+            highest_write_offset)) == NULL) return;
     }
 
     addReplyMultiBulkLen(c,numops);

src/blocked.c

@@ -67,21 +67,6 @@
 
 int serveClientBlockedOnList(client *receiver, robj *key, robj *dstkey, redisDb *db, robj *value, int where);
 
-/* This structure represents the blocked key information that we store
- * in the client structure. Each client blocked on keys, has a
- * client->bpop.keys hash table. The keys of the hash table are Redis
- * keys pointers to 'robj' structures. The value is this structure.
- * The structure has two goals: firstly we store the list node that this
- * client uses to be listed in the database "blocked clients for this key"
- * list, so we can later unblock in O(1) without a list scan.
- * Secondly for certain blocking types, we have additional info. Right now
- * the only use for additional info we have is when clients are blocked
- * on streams, as we have to remember the ID it blocked for. */
-typedef struct bkinfo {
-    listNode *listnode;     /* List node for db->blocking_keys[key] list. */
-    streamID stream_id;     /* Stream ID if we blocked in a stream. */
-} bkinfo;
-
 /* Get a timeout value from an object and store it into 'timeout'.
  * The final timeout is always stored as milliseconds as a time where the
  * timeout will expire, however the parsing is performed according to
@@ -277,16 +262,6 @@ void handleClientsBlockedOnKeys(void) {
              * we can safely call signalKeyAsReady() against this key. */
             dictDelete(rl->db->ready_keys,rl->key);
 
-            /* Even if we are not inside call(), increment the call depth
-             * in order to make sure that keys are expired against a fixed
-             * reference time, and not against the wallclock time. This
-             * way we can lookup an object multiple times (BRPOPLPUSH does
-             * that) without the risk of it being freed in the second
-             * lookup, invalidating the first one.
-             * See https://github.com/antirez/redis/pull/6554. */
-            server.fixed_time_expire++;
-            updateCachedTime(0);
-
             /* Serve clients blocked on list key. */
             robj *o = lookupKeyWrite(rl->db,rl->key);
             if (o != NULL && o->type == OBJ_LIST) {
@@ -306,7 +281,8 @@ void handleClientsBlockedOnKeys(void) {
                         if (receiver->btype != BLOCKED_LIST) {
                             /* Put at the tail, so that at the next call
                              * we'll not run into it again. */
-                            listRotateHeadToTail(clients);
+                            listDelNode(clients,clientnode);
+                            listAddNodeTail(clients,receiver);
                             continue;
                         }
 
@@ -367,7 +343,8 @@ void handleClientsBlockedOnKeys(void) {
                         if (receiver->btype != BLOCKED_ZSET) {
                             /* Put at the tail, so that at the next call
                              * we'll not run into it again. */
-                            listRotateHeadToTail(clients);
+                            listDelNode(clients,clientnode);
+                            listAddNodeTail(clients,receiver);
                             continue;
                         }
 
@@ -411,9 +388,8 @@ void handleClientsBlockedOnKeys(void) {
                     while((ln = listNext(&li))) {
                         client *receiver = listNodeValue(ln);
                         if (receiver->btype != BLOCKED_STREAM) continue;
-                        bkinfo *bki = dictFetchValue(receiver->bpop.keys,
-                                                     rl->key);
-                        streamID *gt = &bki->stream_id;
+                        streamID *gt = dictFetchValue(receiver->bpop.keys,
+                                                      rl->key);
 
                         /* If we blocked in the context of a consumer
                          * group, we need to resolve the group and update the
@@ -443,7 +419,7 @@ void handleClientsBlockedOnKeys(void) {
 
                         if (streamCompareID(&s->last_id, gt) > 0) {
                             streamID start = *gt;
-                            streamIncrID(&start);
+                            start.seq++; /* Can't overflow, it's an uint64_t */
 
                             /* Lookup the consumer for the group, if any. */
                             streamConsumer *consumer = NULL;
@@ -481,7 +457,6 @@ void handleClientsBlockedOnKeys(void) {
                     }
                 }
             }
-            server.fixed_time_expire--;
 
             /* Free this item. */
             decrRefCount(rl->key);
@@ -530,15 +505,17 @@ void blockForKeys(client *c, int btype, robj **keys, int numkeys, mstime_t timeo
     if (target != NULL) incrRefCount(target);
 
     for (j = 0; j < numkeys; j++) {
-        /* Allocate our bkinfo structure, associated to each key the client
-         * is blocked for. */
-        bkinfo *bki = zmalloc(sizeof(*bki));
-        if (btype == BLOCKED_STREAM)
-            bki->stream_id = ids[j];
+        /* The value associated with the key name in the bpop.keys dictionary
+         * is NULL for lists and sorted sets, or the stream ID for streams. */
+        void *key_data = NULL;
+        if (btype == BLOCKED_STREAM) {
+            key_data = zmalloc(sizeof(streamID));
+            memcpy(key_data,ids+j,sizeof(streamID));
+        }
 
         /* If the key already exists in the dictionary ignore it. */
-        if (dictAdd(c->bpop.keys,keys[j],bki) != DICT_OK) {
-            zfree(bki);
+        if (dictAdd(c->bpop.keys,keys[j],key_data) != DICT_OK) {
+            zfree(key_data);
             continue;
         }
         incrRefCount(keys[j]);
@@ -557,7 +534,6 @@ void blockForKeys(client *c, int btype, robj **keys, int numkeys, mstime_t timeo
             l = dictGetVal(de);
         }
         listAddNodeTail(l,c);
-        bki->listnode = listLast(l);
     }
     blockClient(c,btype);
 }
@@ -574,12 +550,11 @@ void unblockClientWaitingData(client *c) {
     /* The client may wait for multiple keys, so unblock it for every key. */
     while((de = dictNext(di)) != NULL) {
         robj *key = dictGetKey(de);
-        bkinfo *bki = dictGetVal(de);
 
         /* Remove this client from the list of clients waiting for this key. */
         l = dictFetchValue(c->db->blocking_keys,key);
         serverAssertWithInfo(c,key,l != NULL);
-        listDelNode(l,bki->listnode);
+        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->blocking_keys,key);

src/cluster.c

@@ -138,7 +138,6 @@ int clusterLoadConfig(char *filename) {
         /* Handle the special "vars" line. Don't pretend it is the last
          * line even if it actually is when generated by Redis. */
         if (strcasecmp(argv[0],"vars") == 0) {
-            if (!(argc % 2)) goto fmterr;
             for (j = 1; j < argc; j += 2) {
                 if (strcasecmp(argv[j],"currentEpoch") == 0) {
                     server.cluster->currentEpoch =
@@ -157,10 +156,7 @@ int clusterLoadConfig(char *filename) {
         }
 
         /* Regular config lines have at least eight fields */
-        if (argc < 8) {
-            sdsfreesplitres(argv,argc);
-            goto fmterr;
-        }
+        if (argc < 8) goto fmterr;
 
         /* Create this node if it does not exist */
         n = clusterLookupNode(argv[0]);
@@ -169,10 +165,7 @@ int clusterLoadConfig(char *filename) {
             clusterAddNode(n);
         }
         /* Address and port */
-        if ((p = strrchr(argv[1],':')) == NULL) {
-            sdsfreesplitres(argv,argc);
-            goto fmterr;
-        }
+        if ((p = strrchr(argv[1],':')) == NULL) goto fmterr;
         *p = '\0';
         memcpy(n->ip,argv[1],strlen(argv[1])+1);
         char *port = p+1;
@@ -253,10 +246,7 @@ int clusterLoadConfig(char *filename) {
                 *p = '\0';
                 direction = p[1]; /* Either '>' or '<' */
                 slot = atoi(argv[j]+1);
-                if (slot < 0 || slot >= CLUSTER_SLOTS) {
-                    sdsfreesplitres(argv,argc);
-                    goto fmterr;
-                }
+                if (slot < 0 || slot >= CLUSTER_SLOTS) goto fmterr;
                 p += 3;
                 cn = clusterLookupNode(p);
                 if (!cn) {
@@ -276,12 +266,8 @@ int clusterLoadConfig(char *filename) {
             } else {
                 start = stop = atoi(argv[j]);
             }
-            if (start < 0 || start >= CLUSTER_SLOTS ||
-                stop < 0 || stop >= CLUSTER_SLOTS)
-            {
-                sdsfreesplitres(argv,argc);
-                goto fmterr;
-            }
+            if (start < 0 || start >= CLUSTER_SLOTS) goto fmterr;
+            if (stop < 0 || stop >= CLUSTER_SLOTS) goto fmterr;
             while(start <= stop) clusterAddSlot(n, start++);
         }
 
@@ -3045,7 +3031,6 @@ void clusterHandleSlaveFailover(void) {
         if (server.cluster->mf_end) {
             server.cluster->failover_auth_time = mstime();
             server.cluster->failover_auth_rank = 0;
-	    clusterDoBeforeSleep(CLUSTER_TODO_HANDLE_FAILOVER);
         }
         serverLog(LL_WARNING,
             "Start of election delayed for %lld milliseconds "
@@ -4790,7 +4775,7 @@ NULL
 
 /* Generates a DUMP-format representation of the object 'o', adding it to the
  * io stream pointed by 'rio'. This function can't fail. */
-void createDumpPayload(rio *payload, robj *o, robj *key) {
+void createDumpPayload(rio *payload, robj *o) {
     unsigned char buf[2];
     uint64_t crc;
 
@@ -4798,7 +4783,7 @@ void createDumpPayload(rio *payload, robj *o, robj *key) {
      * byte followed by the serialized object. This is understood by RESTORE. */
     rioInitWithBuffer(payload,sdsempty());
     serverAssert(rdbSaveObjectType(payload,o));
-    serverAssert(rdbSaveObject(payload,o,key));
+    serverAssert(rdbSaveObject(payload,o));
 
     /* Write the footer, this is how it looks like:
      * ----------------+---------------------+---------------+
@@ -4856,7 +4841,7 @@ void dumpCommand(client *c) {
     }
 
     /* Create the DUMP encoded representation. */
-    createDumpPayload(&payload,o,c->argv[1]);
+    createDumpPayload(&payload,o);
 
     /* Transfer to the client */
     dumpobj = createObject(OBJ_STRING,payload.io.buffer.ptr);
@@ -4929,7 +4914,7 @@ void restoreCommand(client *c) {
 
     rioInitWithBuffer(&payload,c->argv[3]->ptr);
     if (((type = rdbLoadObjectType(&payload)) == -1) ||
-        ((obj = rdbLoadObject(type,&payload,c->argv[1])) == NULL))
+        ((obj = rdbLoadObject(type,&payload)) == NULL))
     {
         addReplyError(c,"Bad data format");
         return;
@@ -5179,10 +5164,10 @@ try_again:
         serverAssertWithInfo(c,NULL,rioWriteBulkLongLong(&cmd,dbid));
     }
 
-    int non_expired = 0; /* Number of keys that we'll find non expired.
-                            Note that serializing large keys may take some time
-                            so certain keys that were found non expired by the
-                            lookupKey() function, may be expired later. */
+    int expired = 0; /* Number of keys that we'll find already expired.
+                        Note that serializing large keys may take some time
+                        so certain keys that were found non expired by the
+                        lookupKey() function, may be expired later. */
 
     /* Create RESTORE payload and generate the protocol to call the command. */
     for (j = 0; j < num_keys; j++) {
@@ -5192,16 +5177,11 @@ try_again:
         if (expireat != -1) {
             ttl = expireat-mstime();
             if (ttl < 0) {
+                expired++;
                 continue;
             }
             if (ttl < 1) ttl = 1;
         }
-
-        /* Relocate valid (non expired) keys into the array in successive
-         * positions to remove holes created by the keys that were present
-         * in the first lookup but are now expired after the second lookup. */
-        kv[non_expired++] = kv[j];
-
         serverAssertWithInfo(c,NULL,
             rioWriteBulkCount(&cmd,'*',replace ? 5 : 4));
 
@@ -5217,7 +5197,7 @@ try_again:
 
         /* Emit the payload argument, that is the serialized object using
          * the DUMP format. */
-        createDumpPayload(&payload,ov[j],kv[j]);
+        createDumpPayload(&payload,ov[j]);
         serverAssertWithInfo(c,NULL,
             rioWriteBulkString(&cmd,payload.io.buffer.ptr,
                                sdslen(payload.io.buffer.ptr)));
@@ -5229,9 +5209,6 @@ try_again:
             serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,"REPLACE",7));
     }
 
-    /* Fix the actual number of keys we are migrating. */
-    num_keys = non_expired;
-
     /* Transfer the query to the other node in 64K chunks. */
     errno = 0;
     {
@@ -5273,7 +5250,7 @@ try_again:
      * command name itself. */
     if (!copy) newargv = zmalloc(sizeof(robj*)*(num_keys+1));
 
-    for (j = 0; j < num_keys; j++) {
+    for (j = 0; j < num_keys-expired; j++) {
         if (syncReadLine(cs->fd, buf2, sizeof(buf2), timeout) <= 0) {
             socket_error = 1;
             break;

src/config.c

@@ -120,7 +120,7 @@ const char *configEnumGetName(configEnum *ce, int val) {
     return NULL;
 }
 
-/* Wrapper for configEnumGetName() returning "unknown" instead of NULL if
+/* Wrapper for configEnumGetName() returning "unknown" insetad of NULL if
  * there is no match. */
 const char *configEnumGetNameOrUnknown(configEnum *ce, int val) {
     const char *name = configEnumGetName(ce,val);
@@ -684,7 +684,7 @@ void loadServerConfigFromString(char *config) {
                 goto loaderr;
             }
         } else if ((!strcasecmp(argv[0],"cluster-slave-no-failover") ||
-                    !strcasecmp(argv[0],"cluster-replica-no-failover")) &&
+                    !strcasecmp(argv[0],"cluster-replica-no-failiver")) &&
                    argc == 2)
         {
             server.cluster_slave_no_failover = yesnotoi(argv[1]);
@@ -1042,8 +1042,8 @@ void configSetCommand(client *c) {
             int soft_seconds;
 
             class = getClientTypeByName(v[j]);
-            hard = memtoll(v[j+1],NULL);
-            soft = memtoll(v[j+2],NULL);
+            hard = strtoll(v[j+1],NULL,10);
+            soft = strtoll(v[j+2],NULL,10);
             soft_seconds = strtoll(v[j+3],NULL,10);
 
             server.client_obuf_limits[class].hard_limit_bytes = hard;
@@ -1248,7 +1248,7 @@ void configSetCommand(client *c) {
             if (server.maxmemory < zmalloc_used_memory()) {
                 serverLog(LL_WARNING,"WARNING: the new maxmemory value set via CONFIG SET is smaller than the current memory usage. This will result in key eviction and/or the inability to accept new write commands depending on the maxmemory-policy.");
             }
-            freeMemoryIfNeededAndSafe();
+            freeMemoryIfNeeded();
         }
     } config_set_memory_field(
       "proto-max-bulk-len",server.proto_max_bulk_len) {
@@ -1654,11 +1654,12 @@ void rewriteConfigMarkAsProcessed(struct rewriteConfigState *state, const char *
  * If the old file does not exist at all, an empty state is returned. */
 struct rewriteConfigState *rewriteConfigReadOldFile(char *path) {
     FILE *fp = fopen(path,"r");
-    if (fp == NULL && errno != ENOENT) return NULL;
-
+    struct rewriteConfigState *state = zmalloc(sizeof(*state));
     char buf[CONFIG_MAX_LINE+1];
     int linenum = -1;
-    struct rewriteConfigState *state = zmalloc(sizeof(*state));
+
+    if (fp == NULL && errno != ENOENT) return NULL;
+
     state->option_to_line = dictCreate(&optionToLineDictType,NULL);
     state->rewritten = dictCreate(&optionSetDictType,NULL);
     state->numlines = 0;

src/config.h

@@ -62,9 +62,7 @@
 #endif
 
 /* Test for backtrace() */
-#if defined(__APPLE__) || (defined(__linux__) && defined(__GLIBC__)) || \
-    defined(__FreeBSD__) || (defined(__OpenBSD__) && defined(USE_BACKTRACE))\
- || defined(__DragonFly__)
+#if defined(__APPLE__) || (defined(__linux__) && defined(__GLIBC__))
 #define HAVE_BACKTRACE 1
 #endif
 

src/db.c

@@ -38,8 +38,6 @@
  * C-level DB API
  *----------------------------------------------------------------------------*/
 
-int keyIsExpired(redisDb *db, robj *key);
-
 /* Update LFU when an object is accessed.
  * Firstly, decrement the counter if the decrement time is reached.
  * Then logarithmically increment the counter, and update the access time. */
@@ -104,10 +102,7 @@ robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {
         /* Key expired. If we are in the context of a master, expireIfNeeded()
          * returns 0 only when the key does not exist at all, so it's safe
          * to return NULL ASAP. */
-        if (server.masterhost == NULL) {
-            server.stat_keyspace_misses++;
-            return NULL;
-        }
+        if (server.masterhost == NULL) return NULL;
 
         /* However if we are in the context of a slave, expireIfNeeded() will
          * not really try to expire the key, it only returns information
@@ -126,7 +121,6 @@ robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {
             server.current_client->cmd &&
             server.current_client->cmd->flags & CMD_READONLY)
         {
-            server.stat_keyspace_misses++;
             return NULL;
         }
     }
@@ -212,7 +206,7 @@ void dbOverwrite(redisDb *db, robj *key, robj *val) {
  * 2) clients WATCHing for the destination key notified.
  * 3) The expire time of the key is reset (the key is made persistent).
  *
- * All the new keys in the database should be created via this interface. */
+ * All the new keys in the database should be craeted via this interface. */
 void setKey(redisDb *db, robj *key, robj *val) {
     if (lookupKeyWrite(db,key) == NULL) {
         dbAdd(db,key,val);
@@ -542,14 +536,14 @@ void keysCommand(client *c) {
     void *replylen = addDeferredMultiBulkLength(c);
 
     di = dictGetSafeIterator(c->db->dict);
-    allkeys = (pattern[0] == '*' && plen == 1);
+    allkeys = (pattern[0] == '*' && pattern[1] == '\0');
     while((de = dictNext(di)) != NULL) {
         sds key = dictGetKey(de);
         robj *keyobj;
 
         if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) {
             keyobj = createStringObject(key,sdslen(key));
-            if (!keyIsExpired(c->db,keyobj)) {
+            if (expireIfNeeded(c->db,keyobj) == 0) {
                 addReplyBulk(c,keyobj);
                 numkeys++;
             }
@@ -1126,44 +1120,6 @@ void propagateExpire(redisDb *db, robj *key, int lazy) {
     decrRefCount(argv[1]);
 }
 
-/* Check if the key is expired. */
-int keyIsExpired(redisDb *db, robj *key) {
-    mstime_t when = getExpire(db,key);
-    mstime_t now;
-
-    if (when < 0) return 0; /* No expire for this key */
-
-    /* Don't expire anything while loading. It will be done later. */
-    if (server.loading) return 0;
-
-    /* If we are in the context of a Lua script, we pretend that time is
-     * blocked to when the Lua script started. This way a key can expire
-     * only the first time it is accessed and not in the middle of the
-     * script execution, making propagation to slaves / AOF consistent.
-     * See issue #1525 on Github for more information. */
-    if (server.lua_caller) {
-        now = server.lua_time_start;
-    }
-    /* If we are in the middle of a command execution, we still want to use
-     * a reference time that does not change: in that case we just use the
-     * cached time, that we update before each call in the call() function.
-     * This way we avoid that commands such as RPOPLPUSH or similar, that
-     * may re-open the same key multiple times, can invalidate an already
-     * open object in a next call, if the next call will see the key expired,
-     * while the first did not. */
-    else if (server.fixed_time_expire > 0) {
-        now = server.mstime;
-    }
-    /* For the other cases, we want to use the most fresh time we have. */
-    else {
-        now = mstime();
-    }
-
-    /* The key expired if the current (virtual or real) time is greater
-     * than the expire time of the key. */
-    return now > when;
-}
-
 /* This function is called when we are going to perform some operation
  * in a given key, but such key may be already logically expired even if
  * it still exists in the database. The main way this function is called
@@ -1184,17 +1140,32 @@ int keyIsExpired(redisDb *db, robj *key) {
  * The return value of the function is 0 if the key is still valid,
  * otherwise the function returns 1 if the key is expired. */
 int expireIfNeeded(redisDb *db, robj *key) {
-    if (!keyIsExpired(db,key)) return 0;
+    mstime_t when = getExpire(db,key);
+    mstime_t now;
 
-    /* If we are running in the context of a slave, instead of
-     * evicting the expired key from the database, we return ASAP:
+    if (when < 0) return 0; /* No expire for this key */
+
+    /* Don't expire anything while loading. It will be done later. */
+    if (server.loading) return 0;
+
+    /* If we are in the context of a Lua script, we pretend that time is
+     * blocked to when the Lua script started. This way a key can expire
+     * only the first time it is accessed and not in the middle of the
+     * script execution, making propagation to slaves / AOF consistent.
+     * See issue #1525 on Github for more information. */
+    now = server.lua_caller ? server.lua_time_start : mstime();
+
+    /* If we are running in the context of a slave, return ASAP:
      * the slave key expiration is controlled by the master that will
      * send us synthesized DEL operations for expired keys.
      *
      * Still we try to return the right information to the caller,
      * that is, 0 if we think the key should be still valid, 1 if
      * we think the key is expired at this time. */
-    if (server.masterhost != NULL) return 1;
+    if (server.masterhost != NULL) return now > when;
+
+    /* Return when this key has not expired */
+    if (now <= when) return 0;
 
     /* Delete the key */
     server.stat_expiredkeys++;

src/debug.c

@@ -37,11 +37,7 @@
 
 #ifdef HAVE_BACKTRACE
 #include <execinfo.h>
-#ifndef __OpenBSD__
 #include <ucontext.h>
-#else
-typedef ucontext_t sigcontext_t;
-#endif
 #include <fcntl.h>
 #include "bio.h"
 #include <unistd.h>
@@ -74,7 +70,7 @@ void xorDigest(unsigned char *digest, void *ptr, size_t len) {
         digest[j] ^= hash[j];
 }
 
-void xorStringObjectDigest(unsigned char *digest, robj *o) {
+void xorObjectDigest(unsigned char *digest, robj *o) {
     o = getDecodedObject(o);
     xorDigest(digest,o->ptr,sdslen(o->ptr));
     decrRefCount(o);
@@ -104,151 +100,12 @@ void mixDigest(unsigned char *digest, void *ptr, size_t len) {
     SHA1Final(digest,&ctx);
 }
 
-void mixStringObjectDigest(unsigned char *digest, robj *o) {
+void mixObjectDigest(unsigned char *digest, robj *o) {
     o = getDecodedObject(o);
     mixDigest(digest,o->ptr,sdslen(o->ptr));
     decrRefCount(o);
 }
 
-/* This function computes the digest of a data structure stored in the
- * object 'o'. It is the core of the DEBUG DIGEST command: when taking the
- * digest of a whole dataset, we take the digest of the key and the value
- * pair, and xor all those together.
- *
- * Note that this function does not reset the initial 'digest' passed, it
- * will continue mixing this object digest to anything that was already
- * present. */
-void xorObjectDigest(redisDb *db, robj *keyobj, unsigned char *digest, robj *o) {
-    uint32_t aux = htonl(o->type);
-    mixDigest(digest,&aux,sizeof(aux));
-    long long expiretime = getExpire(db,keyobj);
-    char buf[128];
-
-    /* Save the key and associated value */
-    if (o->type == OBJ_STRING) {
-        mixStringObjectDigest(digest,o);
-    } else if (o->type == OBJ_LIST) {
-        listTypeIterator *li = listTypeInitIterator(o,0,LIST_TAIL);
-        listTypeEntry entry;
-        while(listTypeNext(li,&entry)) {
-            robj *eleobj = listTypeGet(&entry);
-            mixStringObjectDigest(digest,eleobj);
-            decrRefCount(eleobj);
-        }
-        listTypeReleaseIterator(li);
-    } else if (o->type == OBJ_SET) {
-        setTypeIterator *si = setTypeInitIterator(o);
-        sds sdsele;
-        while((sdsele = setTypeNextObject(si)) != NULL) {
-            xorDigest(digest,sdsele,sdslen(sdsele));
-            sdsfree(sdsele);
-        }
-        setTypeReleaseIterator(si);
-    } else if (o->type == OBJ_ZSET) {
-        unsigned char eledigest[20];
-
-        if (o->encoding == OBJ_ENCODING_ZIPLIST) {
-            unsigned char *zl = o->ptr;
-            unsigned char *eptr, *sptr;
-            unsigned char *vstr;
-            unsigned int vlen;
-            long long vll;
-            double score;
-
-            eptr = ziplistIndex(zl,0);
-            serverAssert(eptr != NULL);
-            sptr = ziplistNext(zl,eptr);
-            serverAssert(sptr != NULL);
-
-            while (eptr != NULL) {
-                serverAssert(ziplistGet(eptr,&vstr,&vlen,&vll));
-                score = zzlGetScore(sptr);
-
-                memset(eledigest,0,20);
-                if (vstr != NULL) {
-                    mixDigest(eledigest,vstr,vlen);
-                } else {
-                    ll2string(buf,sizeof(buf),vll);
-                    mixDigest(eledigest,buf,strlen(buf));
-                }
-
-                snprintf(buf,sizeof(buf),"%.17g",score);
-                mixDigest(eledigest,buf,strlen(buf));
-                xorDigest(digest,eledigest,20);
-                zzlNext(zl,&eptr,&sptr);
-            }
-        } else if (o->encoding == OBJ_ENCODING_SKIPLIST) {
-            zset *zs = o->ptr;
-            dictIterator *di = dictGetIterator(zs->dict);
-            dictEntry *de;
-
-            while((de = dictNext(di)) != NULL) {
-                sds sdsele = dictGetKey(de);
-                double *score = dictGetVal(de);
-
-                snprintf(buf,sizeof(buf),"%.17g",*score);
-                memset(eledigest,0,20);
-                mixDigest(eledigest,sdsele,sdslen(sdsele));
-                mixDigest(eledigest,buf,strlen(buf));
-                xorDigest(digest,eledigest,20);
-            }
-            dictReleaseIterator(di);
-        } else {
-            serverPanic("Unknown sorted set encoding");
-        }
-    } else if (o->type == OBJ_HASH) {
-        hashTypeIterator *hi = hashTypeInitIterator(o);
-        while (hashTypeNext(hi) != C_ERR) {
-            unsigned char eledigest[20];
-            sds sdsele;
-
-            memset(eledigest,0,20);
-            sdsele = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_KEY);
-            mixDigest(eledigest,sdsele,sdslen(sdsele));
-            sdsfree(sdsele);
-            sdsele = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_VALUE);
-            mixDigest(eledigest,sdsele,sdslen(sdsele));
-            sdsfree(sdsele);
-            xorDigest(digest,eledigest,20);
-        }
-        hashTypeReleaseIterator(hi);
-    } else if (o->type == OBJ_STREAM) {
-        streamIterator si;
-        streamIteratorStart(&si,o->ptr,NULL,NULL,0);
-        streamID id;
-        int64_t numfields;
-
-        while(streamIteratorGetID(&si,&id,&numfields)) {
-            sds itemid = sdscatfmt(sdsempty(),"%U.%U",id.ms,id.seq);
-            mixDigest(digest,itemid,sdslen(itemid));
-            sdsfree(itemid);
-
-            while(numfields--) {
-                unsigned char *field, *value;
-                int64_t field_len, value_len;
-                streamIteratorGetField(&si,&field,&value,
-                                           &field_len,&value_len);
-                mixDigest(digest,field,field_len);
-                mixDigest(digest,value,value_len);
-            }
-        }
-        streamIteratorStop(&si);
-    } else if (o->type == OBJ_MODULE) {
-        RedisModuleDigest md;
-        moduleValue *mv = o->ptr;
-        moduleType *mt = mv->type;
-        moduleInitDigestContext(md);
-        if (mt->digest) {
-            mt->digest(&md,mv->value);
-            xorDigest(digest,md.x,sizeof(md.x));
-        }
-    } else {
-        serverPanic("Unknown object type");
-    }
-    /* If the key has an expire, add it to the mix */
-    if (expiretime != -1) xorDigest(digest,"!!expire!!",10);
-}
-
 /* Compute the dataset digest. Since keys, sets elements, hashes elements
  * are not ordered, we use a trick: every aggregate digest is the xor
  * of the digests of their elements. This way the order will not change
@@ -257,6 +114,7 @@ void xorObjectDigest(redisDb *db, robj *keyobj, unsigned char *digest, robj *o)
  * a different digest. */
 void computeDatasetDigest(unsigned char *final) {
     unsigned char digest[20];
+    char buf[128];
     dictIterator *di = NULL;
     dictEntry *de;
     int j;
@@ -279,6 +137,7 @@ void computeDatasetDigest(unsigned char *final) {
         while((de = dictNext(di)) != NULL) {
             sds key;
             robj *keyobj, *o;
+            long long expiretime;
 
             memset(digest,0,20); /* This key-val digest */
             key = dictGetKey(de);
@@ -287,8 +146,134 @@ void computeDatasetDigest(unsigned char *final) {
             mixDigest(digest,key,sdslen(key));
 
             o = dictGetVal(de);
-            xorObjectDigest(db,keyobj,digest,o);
 
+            aux = htonl(o->type);
+            mixDigest(digest,&aux,sizeof(aux));
+            expiretime = getExpire(db,keyobj);
+
+            /* Save the key and associated value */
+            if (o->type == OBJ_STRING) {
+                mixObjectDigest(digest,o);
+            } else if (o->type == OBJ_LIST) {
+                listTypeIterator *li = listTypeInitIterator(o,0,LIST_TAIL);
+                listTypeEntry entry;
+                while(listTypeNext(li,&entry)) {
+                    robj *eleobj = listTypeGet(&entry);
+                    mixObjectDigest(digest,eleobj);
+                    decrRefCount(eleobj);
+                }
+                listTypeReleaseIterator(li);
+            } else if (o->type == OBJ_SET) {
+                setTypeIterator *si = setTypeInitIterator(o);
+                sds sdsele;
+                while((sdsele = setTypeNextObject(si)) != NULL) {
+                    xorDigest(digest,sdsele,sdslen(sdsele));
+                    sdsfree(sdsele);
+                }
+                setTypeReleaseIterator(si);
+            } else if (o->type == OBJ_ZSET) {
+                unsigned char eledigest[20];
+
+                if (o->encoding == OBJ_ENCODING_ZIPLIST) {
+                    unsigned char *zl = o->ptr;
+                    unsigned char *eptr, *sptr;
+                    unsigned char *vstr;
+                    unsigned int vlen;
+                    long long vll;
+                    double score;
+
+                    eptr = ziplistIndex(zl,0);
+                    serverAssert(eptr != NULL);
+                    sptr = ziplistNext(zl,eptr);
+                    serverAssert(sptr != NULL);
+
+                    while (eptr != NULL) {
+                        serverAssert(ziplistGet(eptr,&vstr,&vlen,&vll));
+                        score = zzlGetScore(sptr);
+
+                        memset(eledigest,0,20);
+                        if (vstr != NULL) {
+                            mixDigest(eledigest,vstr,vlen);
+                        } else {
+                            ll2string(buf,sizeof(buf),vll);
+                            mixDigest(eledigest,buf,strlen(buf));
+                        }
+
+                        snprintf(buf,sizeof(buf),"%.17g",score);
+                        mixDigest(eledigest,buf,strlen(buf));
+                        xorDigest(digest,eledigest,20);
+                        zzlNext(zl,&eptr,&sptr);
+                    }
+                } else if (o->encoding == OBJ_ENCODING_SKIPLIST) {
+                    zset *zs = o->ptr;
+                    dictIterator *di = dictGetIterator(zs->dict);
+                    dictEntry *de;
+
+                    while((de = dictNext(di)) != NULL) {
+                        sds sdsele = dictGetKey(de);
+                        double *score = dictGetVal(de);
+
+                        snprintf(buf,sizeof(buf),"%.17g",*score);
+                        memset(eledigest,0,20);
+                        mixDigest(eledigest,sdsele,sdslen(sdsele));
+                        mixDigest(eledigest,buf,strlen(buf));
+                        xorDigest(digest,eledigest,20);
+                    }
+                    dictReleaseIterator(di);
+                } else {
+                    serverPanic("Unknown sorted set encoding");
+                }
+            } else if (o->type == OBJ_HASH) {
+                hashTypeIterator *hi = hashTypeInitIterator(o);
+                while (hashTypeNext(hi) != C_ERR) {
+                    unsigned char eledigest[20];
+                    sds sdsele;
+
+                    memset(eledigest,0,20);
+                    sdsele = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_KEY);
+                    mixDigest(eledigest,sdsele,sdslen(sdsele));
+                    sdsfree(sdsele);
+                    sdsele = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_VALUE);
+                    mixDigest(eledigest,sdsele,sdslen(sdsele));
+                    sdsfree(sdsele);
+                    xorDigest(digest,eledigest,20);
+                }
+                hashTypeReleaseIterator(hi);
+            } else if (o->type == OBJ_STREAM) {
+                streamIterator si;
+                streamIteratorStart(&si,o->ptr,NULL,NULL,0);
+                streamID id;
+                int64_t numfields;
+
+                while(streamIteratorGetID(&si,&id,&numfields)) {
+                    sds itemid = sdscatfmt(sdsempty(),"%U.%U",id.ms,id.seq);
+                    mixDigest(digest,itemid,sdslen(itemid));
+                    sdsfree(itemid);
+
+                    while(numfields--) {
+                        unsigned char *field, *value;
+                        int64_t field_len, value_len;
+                        streamIteratorGetField(&si,&field,&value,
+                                                   &field_len,&value_len);
+                        mixDigest(digest,field,field_len);
+                        mixDigest(digest,value,value_len);
+                    }
+                }
+                streamIteratorStop(&si);
+            } else if (o->type == OBJ_MODULE) {
+                RedisModuleDigest md;
+                moduleValue *mv = o->ptr;
+                moduleType *mt = mv->type;
+                moduleInitDigestContext(md);
+                if (mt->digest) {
+                    mt->digest(&md,mv->value);
+                    xorDigest(digest,md.x,sizeof(md.x));
+                }
+            } else {
+                serverPanic("Unknown object type");
+            }
+            /* If the key has an expire, add it to the mix */
+            if (expiretime != -1) xorDigest(digest,"!!expire!!",10);
             /* We can finally xor the key-val digest to the final digest */
             xorDigest(final,digest,20);
             decrRefCount(keyobj);
@@ -304,7 +289,6 @@ void debugCommand(client *c) {
 "CHANGE-REPL-ID -- Change the replication IDs of the instance. Dangerous, should be used only for testing the replication subsystem.",
 "CRASH-AND-RECOVER <milliseconds> -- Hard crash and restart after <milliseconds> delay.",
 "DIGEST -- Output a hex signature representing the current DB content.",
-"DIGEST-VALUE <key-1> ... <key-N>-- Output a hex signature of the values of all the specified keys.",
 "ERROR <string> -- Return a Redis protocol error with <string> as message. Useful for clients unit tests to simulate Redis errors.",
 "LOG <message> -- write message to the server log.",
 "HTSTATS <dbid> -- Return hash table statistics of the specified Redis database.",
@@ -322,7 +306,6 @@ void debugCommand(client *c) {
 "SLEEP <seconds> -- Stop the server for <seconds>. Decimals allowed.",
 "STRUCTSIZE -- Return the size of different Redis core C structures.",
 "ZIPLIST <key> -- Show low level info about the ziplist encoding.",
-"STRINGMATCH-TEST -- Run a fuzz tester against the stringmatchlen() function.",
 NULL
         };
         addReplyHelp(c, help);
@@ -349,6 +332,7 @@ NULL
         zfree(ptr);
         addReply(c,shared.ok);
     } else if (!strcasecmp(c->argv[1]->ptr,"assert")) {
+        if (c->argc >= 3) c->argv[2] = tryObjectEncoding(c->argv[2]);
         serverAssertWithInfo(c,c->argv[0],1 == 2);
     } else if (!strcasecmp(c->argv[1]->ptr,"log") && c->argc == 3) {
         serverLog(LL_WARNING, "DEBUG LOG: %s", (char*)c->argv[2]->ptr);
@@ -361,10 +345,7 @@ NULL
             return;
         }
         emptyDb(-1,EMPTYDB_NO_FLAGS,NULL);
-        protectClient(c);
-        int ret = rdbLoad(server.rdb_filename,NULL);
-        unprotectClient(c);
-        if (ret != C_OK) {
+        if (rdbLoad(server.rdb_filename,NULL) != C_OK) {
             addReplyError(c,"Error trying to load the RDB dump");
             return;
         }
@@ -373,10 +354,7 @@ NULL
     } else if (!strcasecmp(c->argv[1]->ptr,"loadaof")) {
         if (server.aof_state != AOF_OFF) flushAppendOnlyFile(1);
         emptyDb(-1,EMPTYDB_NO_FLAGS,NULL);
-        protectClient(c);
-        int ret = loadAppendOnlyFile(server.aof_filename);
-        unprotectClient(c);
-        if (ret != C_OK) {
+        if (loadAppendOnlyFile(server.aof_filename) != C_OK) {
             addReply(c,shared.err);
             return;
         }
@@ -507,28 +485,15 @@ NULL
         }
         addReply(c,shared.ok);
     } else if (!strcasecmp(c->argv[1]->ptr,"digest") && c->argc == 2) {
-        /* DEBUG DIGEST (form without keys specified) */
         unsigned char digest[20];
         sds d = sdsempty();
+        int j;
 
         computeDatasetDigest(digest);
-        for (int i = 0; i < 20; i++) d = sdscatprintf(d, "%02x",digest[i]);
+        for (j = 0; j < 20; j++)
+            d = sdscatprintf(d, "%02x",digest[j]);
         addReplyStatus(c,d);
         sdsfree(d);
-    } else if (!strcasecmp(c->argv[1]->ptr,"digest-value") && c->argc >= 2) {
-        /* DEBUG DIGEST-VALUE key key key ... key. */
-        addReplyMultiBulkLen(c,c->argc-2);
-        for (int j = 2; j < c->argc; j++) {
-            unsigned char digest[20];
-            memset(digest,0,20); /* Start with a clean result */
-            robj *o = lookupKeyReadWithFlags(c->db,c->argv[j],LOOKUP_NOTOUCH);
-            if (o) xorObjectDigest(c->db,c->argv[j],digest,o);
-
-            sds d = sdsempty();
-            for (int i = 0; i < 20; i++) d = sdscatprintf(d, "%02x",digest[i]);
-            addReplyStatus(c,d);
-            sdsfree(d);
-        }
     } else if (!strcasecmp(c->argv[1]->ptr,"sleep") && c->argc == 3) {
         double dtime = strtod(c->argv[2]->ptr,NULL);
         long long utime = dtime*1000000;
@@ -620,10 +585,6 @@ NULL
         changeReplicationId();
         clearReplicationId2();
         addReply(c,shared.ok);
-    } else if (!strcasecmp(c->argv[1]->ptr,"stringmatch-test") && c->argc == 2)
-    {
-        stringmatchlen_fuzz_test();
-        addReplyStatus(c,"Apparently Redis did not crash: test passed");
     } else {
         addReplySubcommandSyntaxError(c);
         return;
@@ -762,22 +723,6 @@ static void *getMcontextEip(ucontext_t *uc) {
     #elif defined(__aarch64__) /* Linux AArch64 */
     return (void*) uc->uc_mcontext.pc;
     #endif
-#elif defined(__FreeBSD__)
-    /* FreeBSD */
-    #if defined(__i386__)
-    return (void*) uc->uc_mcontext.mc_eip;
-    #elif defined(__x86_64__)
-    return (void*) uc->uc_mcontext.mc_rip;
-    #endif
-#elif defined(__OpenBSD__)
-    /* OpenBSD */
-    #if defined(__i386__)
-    return (void*) uc->sc_eip;
-    #elif defined(__x86_64__)
-    return (void*) uc->sc_rip;
-    #endif
-#elif defined(__DragonFly__)
-    return (void*) uc->uc_mcontext.mc_rip;
 #else
     return NULL;
 #endif
@@ -919,145 +864,6 @@ void logRegisters(ucontext_t *uc) {
     );
     logStackContent((void**)uc->uc_mcontext.gregs[15]);
     #endif
-#elif defined(__FreeBSD__)
-    #if defined(__x86_64__)
-    serverLog(LL_WARNING,
-    "\n"
-    "RAX:%016lx RBX:%016lx\nRCX:%016lx RDX:%016lx\n"
-    "RDI:%016lx RSI:%016lx\nRBP:%016lx RSP:%016lx\n"
-    "R8 :%016lx R9 :%016lx\nR10:%016lx R11:%016lx\n"
-    "R12:%016lx R13:%016lx\nR14:%016lx R15:%016lx\n"
-    "RIP:%016lx EFL:%016lx\nCSGSFS:%016lx",
-        (unsigned long) uc->uc_mcontext.mc_rax,
-        (unsigned long) uc->uc_mcontext.mc_rbx,
-        (unsigned long) uc->uc_mcontext.mc_rcx,
-        (unsigned long) uc->uc_mcontext.mc_rdx,
-        (unsigned long) uc->uc_mcontext.mc_rdi,
-        (unsigned long) uc->uc_mcontext.mc_rsi,
-        (unsigned long) uc->uc_mcontext.mc_rbp,
-        (unsigned long) uc->uc_mcontext.mc_rsp,
-        (unsigned long) uc->uc_mcontext.mc_r8,
-        (unsigned long) uc->uc_mcontext.mc_r9,
-        (unsigned long) uc->uc_mcontext.mc_r10,
-        (unsigned long) uc->uc_mcontext.mc_r11,
-        (unsigned long) uc->uc_mcontext.mc_r12,
-        (unsigned long) uc->uc_mcontext.mc_r13,
-        (unsigned long) uc->uc_mcontext.mc_r14,
-        (unsigned long) uc->uc_mcontext.mc_r15,
-        (unsigned long) uc->uc_mcontext.mc_rip,
-        (unsigned long) uc->uc_mcontext.mc_rflags,
-        (unsigned long) uc->uc_mcontext.mc_cs
-    );
-    logStackContent((void**)uc->uc_mcontext.mc_rsp);
-    #elif defined(__i386__)
-    serverLog(LL_WARNING,
-    "\n"
-    "EAX:%08lx EBX:%08lx ECX:%08lx EDX:%08lx\n"
-    "EDI:%08lx ESI:%08lx EBP:%08lx ESP:%08lx\n"
-    "SS :%08lx EFL:%08lx EIP:%08lx CS:%08lx\n"
-    "DS :%08lx ES :%08lx FS :%08lx GS:%08lx",
-        (unsigned long) uc->uc_mcontext.mc_eax,
-        (unsigned long) uc->uc_mcontext.mc_ebx,
-        (unsigned long) uc->uc_mcontext.mc_ebx,
-        (unsigned long) uc->uc_mcontext.mc_edx,
-        (unsigned long) uc->uc_mcontext.mc_edi,
-        (unsigned long) uc->uc_mcontext.mc_esi,
-        (unsigned long) uc->uc_mcontext.mc_ebp,
-        (unsigned long) uc->uc_mcontext.mc_esp,
-        (unsigned long) uc->uc_mcontext.mc_ss,
-        (unsigned long) uc->uc_mcontext.mc_eflags,
-        (unsigned long) uc->uc_mcontext.mc_eip,
-        (unsigned long) uc->uc_mcontext.mc_cs,
-        (unsigned long) uc->uc_mcontext.mc_es,
-        (unsigned long) uc->uc_mcontext.mc_fs,
-        (unsigned long) uc->uc_mcontext.mc_gs
-    );
-    logStackContent((void**)uc->uc_mcontext.mc_esp);
-    #endif
-#elif defined(__OpenBSD__)
-    #if defined(__x86_64__)
-    serverLog(LL_WARNING,
-    "\n"
-    "RAX:%016lx RBX:%016lx\nRCX:%016lx RDX:%016lx\n"
-    "RDI:%016lx RSI:%016lx\nRBP:%016lx RSP:%016lx\n"
-    "R8 :%016lx R9 :%016lx\nR10:%016lx R11:%016lx\n"
-    "R12:%016lx R13:%016lx\nR14:%016lx R15:%016lx\n"
-    "RIP:%016lx EFL:%016lx\nCSGSFS:%016lx",
-        (unsigned long) uc->sc_rax,
-        (unsigned long) uc->sc_rbx,
-        (unsigned long) uc->sc_rcx,
-        (unsigned long) uc->sc_rdx,
-        (unsigned long) uc->sc_rdi,
-        (unsigned long) uc->sc_rsi,
-        (unsigned long) uc->sc_rbp,
-        (unsigned long) uc->sc_rsp,
-        (unsigned long) uc->sc_r8,
-        (unsigned long) uc->sc_r9,
-        (unsigned long) uc->sc_r10,
-        (unsigned long) uc->sc_r11,
-        (unsigned long) uc->sc_r12,
-        (unsigned long) uc->sc_r13,
-        (unsigned long) uc->sc_r14,
-        (unsigned long) uc->sc_r15,
-        (unsigned long) uc->sc_rip,
-        (unsigned long) uc->sc_rflags,
-        (unsigned long) uc->sc_cs
-    );
-    logStackContent((void**)uc->sc_rsp);
-    #elif defined(__i386__)
-    serverLog(LL_WARNING,
-    "\n"
-    "EAX:%08lx EBX:%08lx ECX:%08lx EDX:%08lx\n"
-    "EDI:%08lx ESI:%08lx EBP:%08lx ESP:%08lx\n"
-    "SS :%08lx EFL:%08lx EIP:%08lx CS:%08lx\n"
-    "DS :%08lx ES :%08lx FS :%08lx GS:%08lx",
-        (unsigned long) uc->sc_eax,
-        (unsigned long) uc->sc_ebx,
-        (unsigned long) uc->sc_ebx,
-        (unsigned long) uc->sc_edx,
-        (unsigned long) uc->sc_edi,
-        (unsigned long) uc->sc_esi,
-        (unsigned long) uc->sc_ebp,
-        (unsigned long) uc->sc_esp,
-        (unsigned long) uc->sc_ss,
-        (unsigned long) uc->sc_eflags,
-        (unsigned long) uc->sc_eip,
-        (unsigned long) uc->sc_cs,
-        (unsigned long) uc->sc_es,
-        (unsigned long) uc->sc_fs,
-        (unsigned long) uc->sc_gs
-    );
-    logStackContent((void**)uc->sc_esp);
-    #endif
-#elif defined(__DragonFly__)
-    serverLog(LL_WARNING,
-    "\n"
-    "RAX:%016lx RBX:%016lx\nRCX:%016lx RDX:%016lx\n"
-    "RDI:%016lx RSI:%016lx\nRBP:%016lx RSP:%016lx\n"
-    "R8 :%016lx R9 :%016lx\nR10:%016lx R11:%016lx\n"
-    "R12:%016lx R13:%016lx\nR14:%016lx R15:%016lx\n"
-    "RIP:%016lx EFL:%016lx\nCSGSFS:%016lx",
-        (unsigned long) uc->uc_mcontext.mc_rax,
-        (unsigned long) uc->uc_mcontext.mc_rbx,
-        (unsigned long) uc->uc_mcontext.mc_rcx,
-        (unsigned long) uc->uc_mcontext.mc_rdx,
-        (unsigned long) uc->uc_mcontext.mc_rdi,
-        (unsigned long) uc->uc_mcontext.mc_rsi,
-        (unsigned long) uc->uc_mcontext.mc_rbp,
-        (unsigned long) uc->uc_mcontext.mc_rsp,
-        (unsigned long) uc->uc_mcontext.mc_r8,
-        (unsigned long) uc->uc_mcontext.mc_r9,
-        (unsigned long) uc->uc_mcontext.mc_r10,
-        (unsigned long) uc->uc_mcontext.mc_r11,
-        (unsigned long) uc->uc_mcontext.mc_r12,
-        (unsigned long) uc->uc_mcontext.mc_r13,
-        (unsigned long) uc->uc_mcontext.mc_r14,
-        (unsigned long) uc->uc_mcontext.mc_r15,
-        (unsigned long) uc->uc_mcontext.mc_rip,
-        (unsigned long) uc->uc_mcontext.mc_rflags,
-        (unsigned long) uc->uc_mcontext.mc_cs
-    );
-    logStackContent((void**)uc->uc_mcontext.mc_rsp);
 #else
     serverLog(LL_WARNING,
         "  Dumping of registers not supported for this OS/arch");
@@ -1377,8 +1183,6 @@ void serverLogHexDump(int level, char *descr, void *value, size_t len) {
 void watchdogSignalHandler(int sig, siginfo_t *info, void *secret) {
 #ifdef HAVE_BACKTRACE
     ucontext_t *uc = (ucontext_t*) secret;
-#else
-    (void)secret;
 #endif
     UNUSED(info);
     UNUSED(sig);

src/defrag.c

@@ -47,7 +47,7 @@ int je_get_defrag_hint(void* ptr, int *bin_util, int *run_util);
 
 /* forward declarations*/
 void defragDictBucketCallback(void *privdata, dictEntry **bucketref);
-dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, uint64_t hash, long *defragged);
+dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, unsigned int hash, long *defragged);
 
 /* Defrag helper for generic allocations.
  *
@@ -355,7 +355,7 @@ long activeDefragSdsListAndDict(list *l, dict *d, int dict_val_type) {
         sdsele = ln->value;
         if ((newsds = activeDefragSds(sdsele))) {
             /* When defragging an sds value, we need to update the dict key */
-            uint64_t hash = dictGetHash(d, sdsele);
+            unsigned int hash = dictGetHash(d, sdsele);
             replaceSateliteDictKeyPtrAndOrDefragDictEntry(d, sdsele, newsds, hash, &defragged);
             ln->value = newsds;
             defragged++;
@@ -392,7 +392,7 @@ long activeDefragSdsListAndDict(list *l, dict *d, int dict_val_type) {
  * moved. Return value is the the dictEntry if found, or NULL if not found.
  * NOTE: this is very ugly code, but it let's us avoid the complication of
  * doing a scan on another dict. */
-dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, uint64_t hash, long *defragged) {
+dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, unsigned int hash, long *defragged) {
     dictEntry **deref = dictFindEntryRefByPtrAndHash(d, oldkey, hash);
     if (deref) {
         dictEntry *de = *deref;

src/evict.c

@@ -364,7 +364,7 @@ size_t freeMemoryGetNotCountedMemory(void) {
         }
     }
     if (server.aof_state != AOF_OFF) {
-        overhead += sdsalloc(server.aof_buf)+aofRewriteBufferSize();
+        overhead += sdslen(server.aof_buf)+aofRewriteBufferSize();
     }
     return overhead;
 }
@@ -444,8 +444,8 @@ int getMaxmemoryState(size_t *total, size_t *logical, size_t *tofree, float *lev
  * Otehrwise if we are over the memory limit, but not enough memory
  * was freed to return back under the limit, the function returns C_ERR. */
 int freeMemoryIfNeeded(void) {
-    /* By default replicas should ignore maxmemory
-     * and just be masters exact copies. */
+    /* By default slaves should ignore maxmemory and just be masters excat
+     * copies. */
     if (server.masterhost && server.repl_slave_ignore_maxmemory) return C_OK;
 
     size_t mem_reported, mem_tofree, mem_freed;
@@ -622,14 +622,3 @@ cant_free:
     return C_ERR;
 }
 
-/* This is a wrapper for freeMemoryIfNeeded() that only really calls the
- * function if right now there are the conditions to do so safely:
- *
- * - There must be no script in timeout condition.
- * - Nor we are loading data right now.
- *
- */
-int freeMemoryIfNeededAndSafe(void) {
-    if (server.lua_timedout || server.loading) return C_OK;
-    return freeMemoryIfNeeded();
-}

src/geo.c

@@ -659,7 +659,7 @@ void georadiusGeneric(client *c, int flags) {
             zsetConvertToZiplistIfNeeded(zobj,maxelelen);
             setKey(c->db,storekey,zobj);
             decrRefCount(zobj);
-            notifyKeyspaceEvent(NOTIFY_ZSET,"georadiusstore",storekey,
+            notifyKeyspaceEvent(NOTIFY_LIST,"georadiusstore",storekey,
                                 c->db->id);
             server.dirty += returned_items;
         } else if (dbDelete(c->db,storekey)) {

src/help.h

@@ -98,11 +98,6 @@ struct commandHelp {
     "Get the current connection name",
     9,
     "2.6.9" },
-    { "CLIENT ID",
-    "-",
-    "Returns the client ID for the current connection",
-    9,
-    "5.0.0" },
     { "CLIENT KILL",
     "[ip:port] [ID client-id] [TYPE normal|master|slave|pubsub] [ADDR ip:port] [SKIPME yes/no]",
     "Kill the connection of a client",
@@ -128,11 +123,6 @@ struct commandHelp {
     "Set the current connection name",
     9,
     "2.6.9" },
-    { "CLIENT UNBLOCK",
-    "client-id [TIMEOUT|ERROR]",
-    "Unblock a client blocked in a blocking command from a different connection",
-    9,
-    "5.0.0" },
     { "CLUSTER ADDSLOTS",
     "slot [slot ...]",
     "Assign new hash slots to receiving node",
@@ -155,7 +145,7 @@ struct commandHelp {
     "3.0.0" },
     { "CLUSTER FAILOVER",
     "[FORCE|TAKEOVER]",
-    "Forces a replica to perform a manual failover of its master.",
+    "Forces a slave to perform a manual failover of its master.",
     12,
     "3.0.0" },
     { "CLUSTER FORGET",
@@ -188,14 +178,9 @@ struct commandHelp {
     "Get Cluster config for the node",
     12,
     "3.0.0" },
-    { "CLUSTER REPLICAS",
-    "node-id",
-    "List replica nodes of the specified master node",
-    12,
-    "5.0.0" },
     { "CLUSTER REPLICATE",
     "node-id",
-    "Reconfigure a node as a replica of the specified master node",
+    "Reconfigure a node as a slave of the specified master node",
     12,
     "3.0.0" },
     { "CLUSTER RESET",
@@ -220,7 +205,7 @@ struct commandHelp {
     "3.0.0" },
     { "CLUSTER SLAVES",
     "node-id",
-    "List replica nodes of the specified master node",
+    "List slave nodes of the specified master node",
     12,
     "3.0.0" },
     { "CLUSTER SLOTS",
@@ -705,12 +690,12 @@ struct commandHelp {
     "1.0.0" },
     { "READONLY",
     "-",
-    "Enables read queries for a connection to a cluster replica node",
+    "Enables read queries for a connection to a cluster slave node",
     12,
     "3.0.0" },
     { "READWRITE",
     "-",
-    "Disables read queries for a connection to a cluster replica node",
+    "Disables read queries for a connection to a cluster slave node",
     12,
     "3.0.0" },
     { "RENAME",
@@ -723,11 +708,6 @@ struct commandHelp {
     "Rename a key, only if the new key does not exist",
     0,
     "1.0.0" },
-    { "REPLICAOF",
-    "host port",
-    "Make the server a replica of another instance, or promote it as master.",
-    9,
-    "5.0.0" },
     { "RESTORE",
     "key ttl serialized-value [REPLACE]",
     "Create a key using the provided serialized value, previously obtained using DUMP.",
@@ -865,7 +845,7 @@ struct commandHelp {
     "1.0.0" },
     { "SLAVEOF",
     "host port",
-    "Make the server a replica of another instance, or promote it as master. Deprecated starting with Redis 5. Use REPLICAOF instead.",
+    "Make the server a slave of another instance, or promote it as master",
     9,
     "1.0.0" },
     { "SLOWLOG",
@@ -974,7 +954,7 @@ struct commandHelp {
     7,
     "2.2.0" },
     { "WAIT",
-    "numreplicas timeout",
+    "numslaves timeout",
     "Wait for the synchronous replication of all the write commands sent in the context of the current connection",
     0,
     "3.0.0" },
@@ -983,36 +963,11 @@ struct commandHelp {
     "Watch the given keys to determine execution of the MULTI/EXEC block",
     7,
     "2.2.0" },
-    { "XACK",
-    "key group ID [ID ...]",
-    "Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.",
-    14,
-    "5.0.0" },
     { "XADD",
     "key ID field string [field string ...]",
     "Appends a new entry to a stream",
     14,
     "5.0.0" },
-    { "XCLAIM",
-    "key group consumer min-idle-time ID [ID ...] [IDLE ms] [TIME ms-unix-time] [RETRYCOUNT count] [force] [justid]",
-    "Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.",
-    14,
-    "5.0.0" },
-    { "XDEL",
-    "key ID [ID ...]",
-    "Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.",
-    14,
-    "5.0.0" },
-    { "XGROUP",
-    "[CREATE key groupname id-or-$] [SETID key id-or-$] [DESTROY key groupname] [DELCONSUMER key groupname consumername]",
-    "Create, destroy, and manage consumer groups.",
-    14,
-    "5.0.0" },
-    { "XINFO",
-    "[CONSUMERS key groupname] [GROUPS key] [STREAM key] [HELP]",
-    "Get information on streams and consumer groups",
-    14,
-    "5.0.0" },
     { "XLEN",
     "key",
     "Return the number of entires in a stream",
@@ -1043,11 +998,6 @@ struct commandHelp {
     "Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE",
     14,
     "5.0.0" },
-    { "XTRIM",
-    "key MAXLEN [~] count",
-    "Trims the stream to (approximately if '~' is passed) a certain size",
-    14,
-    "5.0.0" },
     { "ZADD",
     "key [NX|XX] [CH] [INCR] score member [score member ...]",
     "Add one or more members to a sorted set, or update its score if it already exists",

src/hyperloglog.c

@@ -614,7 +614,6 @@ int hllSparseToDense(robj *o) {
         } else {
             runlen = HLL_SPARSE_VAL_LEN(p);
             regval = HLL_SPARSE_VAL_VALUE(p);
-            if ((runlen + idx) > HLL_REGISTERS) break; /* Overflow. */
             while(runlen--) {
                 HLL_DENSE_SET_REGISTER(hdr->registers,idx,regval);
                 idx++;
@@ -700,7 +699,7 @@ int hllSparseSet(robj *o, long index, uint8_t count) {
         p += oplen;
         first += span;
     }
-    if (span == 0 || p >= end) return -1; /* Invalid format. */
+    if (span == 0) return -1; /* Invalid format. */
 
     next = HLL_SPARSE_IS_XZERO(p) ? p+2 : p+1;
     if (next >= end) next = NULL;
@@ -1014,12 +1013,7 @@ uint64_t hllCount(struct hllhdr *hdr, int *invalid) {
     double m = HLL_REGISTERS;
     double E;
     int j;
-    /* Note that reghisto size could be just HLL_Q+2, becuase HLL_Q+1 is
-     * the maximum frequency of the "000...1" sequence the hash function is
-     * able to return. However it is slow to check for sanity of the
-     * input: instead we history array at a safe size: overflows will
-     * just write data to wrong, but correctly allocated, places. */
-    int reghisto[64] = {0};
+    int reghisto[HLL_Q+2] = {0};
 
     /* Compute register histogram */
     if (hdr->encoding == HLL_DENSE) {
@@ -1094,7 +1088,6 @@ int hllMerge(uint8_t *max, robj *hll) {
             } else {
                 runlen = HLL_SPARSE_VAL_LEN(p);
                 regval = HLL_SPARSE_VAL_VALUE(p);
-                if ((runlen + i) > HLL_REGISTERS) break; /* Overflow. */
                 while(runlen--) {
                     if (regval > max[i]) max[i] = regval;
                     i++;
@@ -1535,7 +1528,6 @@ void pfdebugCommand(client *c) {
         sds decoded = sdsempty();
 
         if (hdr->encoding != HLL_SPARSE) {
-            sdsfree(decoded);
             addReplyError(c,"HLL encoding is not sparse");
             return;
         }

src/intset.c

@@ -123,7 +123,7 @@ static uint8_t intsetSearch(intset *is, int64_t value, uint32_t *pos) {
     } else {
         /* Check for the case where we know we cannot find the value,
          * but do know the insert position. */
-        if (value > _intsetGet(is,max)) {
+        if (value > _intsetGet(is,intrev32ifbe(is->length)-1)) {
             if (pos) *pos = intrev32ifbe(is->length);
             return 0;
         } else if (value < _intsetGet(is,0)) {

src/latency.c

@@ -562,21 +562,11 @@ sds latencyCommandGenSparkeline(char *event, struct latencyTimeSeries *ts) {
  *
  * LATENCY HISTORY: return time-latency samples for the specified event.
  * LATENCY LATEST: return the latest latency for all the events classes.
- * LATENCY DOCTOR: returns a human readable analysis of instance latency.
+ * LATENCY DOCTOR: returns an human readable analysis of instance latency.
  * LATENCY GRAPH: provide an ASCII graph of the latency of the specified event.
  * LATENCY RESET: reset data of a specified event or all the data if no event provided.
  */
 void latencyCommand(client *c) {
-    const char *help[] = {
-"DOCTOR              -- Returns a human readable latency analysis report.",
-"GRAPH   <event>     -- Returns an ASCII latency graph for the event class.",
-"HISTORY <event>     -- Returns time-latency samples for the event class.",
-"LATEST              -- Returns the latest latency samples for all events.",
-"RESET   [event ...] -- Resets latency data of one or more event classes.",
-"                       (default: reset all data for all event classes)",
-"HELP                -- Prints this help.",
-NULL
-    };
     struct latencyTimeSeries *ts;
 
     if (!strcasecmp(c->argv[1]->ptr,"history") && c->argc == 3) {
@@ -621,10 +611,8 @@ NULL
                 resets += latencyResetEvent(c->argv[j]->ptr);
             addReplyLongLong(c,resets);
         }
-    } else if (!strcasecmp(c->argv[1]->ptr,"help") && c->argc >= 2) {
-        addReplyHelp(c, help);
     } else {
-        addReplySubcommandSyntaxError(c);
+        addReply(c,shared.syntaxerr);
     }
     return;
 

src/lolwut5.c

@@ -274,7 +274,7 @@ void lolwut5Command(client *c) {
     lwCanvas *canvas = lwDrawSchotter(cols,squares_per_row,squares_per_col);
     sds rendered = lwRenderCanvas(canvas);
     rendered = sdscat(rendered,
-        "\nGeorg Nees - schotter, plotter on paper, 1968. Redis ver. ");
+        "\nGeorg nees - schotter, plotter on paper, 1968. Redis ver. ");
     rendered = sdscat(rendered,REDIS_VERSION);
     rendered = sdscatlen(rendered,"\n",1);
     addReplyBulkSds(c,rendered);

src/mkreleasehdr.sh

@@ -3,7 +3,7 @@ GIT_SHA1=`(git show-ref --head --hash=8 2> /dev/null || echo 00000000) | head -n
 GIT_DIRTY=`git diff --no-ext-diff 2> /dev/null | wc -l`
 BUILD_ID=`uname -n`"-"`date +%s`
 if [ -n "$SOURCE_DATE_EPOCH" ]; then
-  BUILD_ID=$(date -u -d "@$SOURCE_DATE_EPOCH" +%s 2>/dev/null || date -u -r "$SOURCE_DATE_EPOCH" +%s 2>/dev/null || date -u +%s)
+  BUILD_ID=$(date -u -d "@$SOURCE_DATE_EPOCH" +%s 2>/dev/null || date -u -r "$SOURCE_DATE_EPOCH" +%s 2>/dev/null || date -u %s)
 fi
 test -f release.h || touch release.h
 (cat release.h | grep SHA1 | grep $GIT_SHA1) && \

src/modules/Makefile

@@ -46,6 +46,7 @@ hellotimer.so: hellotimer.xo
 hellodict.xo: ../redismodule.h
 
 hellodict.so: hellodict.xo
+	$(LD) -o $@ $< $(SHOBJ_LDFLAGS) $(LIBS) -lc
 
 testmodule.xo: ../redismodule.h
 

src/multi.c

@@ -35,7 +35,6 @@
 void initClientMultiState(client *c) {
     c->mstate.commands = NULL;
     c->mstate.count = 0;
-    c->mstate.cmd_flags = 0;
 }
 
 /* Release all the resources associated with MULTI/EXEC state */
@@ -68,7 +67,6 @@ void queueMultiCommand(client *c) {
     for (j = 0; j < c->argc; j++)
         incrRefCount(mc->argv[j]);
     c->mstate.count++;
-    c->mstate.cmd_flags |= c->cmd->flags;
 }
 
 void discardTransaction(client *c) {
@@ -139,21 +137,6 @@ void execCommand(client *c) {
         goto handle_monitor;
     }
 
-    /* If there are write commands inside the transaction, and this is a read
-     * only slave, we want to send an error. This happens when the transaction
-     * was initiated when the instance was a master or a writable replica and
-     * then the configuration changed (for example instance was turned into
-     * a replica). */
-    if (!server.loading && server.masterhost && server.repl_slave_ro &&
-        !(c->flags & CLIENT_MASTER) && c->mstate.cmd_flags & CMD_WRITE)
-    {
-        addReplyError(c,
-            "Transaction contains write commands but instance "
-            "is now a read-only slave. EXEC aborted.");
-        discardTransaction(c);
-        goto handle_monitor;
-    }
-
     /* Exec all the queued commands */
     unwatchAllKeys(c); /* Unwatch ASAP otherwise we'll waste CPU cycles */
     orig_argv = c->argv;
@@ -175,7 +158,7 @@ void execCommand(client *c) {
             must_propagate = 1;
         }
 
-        call(c,server.loading ? CMD_CALL_NONE : CMD_CALL_FULL);
+        call(c,CMD_CALL_FULL|CMD_CALL_NOQUEUE);
 
         /* Commands may alter argc/argv, restore mstate. */
         c->mstate.commands[j].argc = c->argc;

src/networking.c

@@ -29,7 +29,6 @@
 
 #include "server.h"
 #include "atomicvar.h"
-#include <sys/socket.h>
 #include <sys/uio.h>
 #include <math.h>
 #include <ctype.h>
@@ -161,32 +160,6 @@ client *createClient(int fd) {
     return c;
 }
 
-/* This funciton puts the client in the queue of clients that should write
- * their output buffers to the socket. Note that it does not *yet* install
- * the write handler, to start clients are put in a queue of clients that need
- * to write, so we try to do that before returning in the event loop (see the
- * handleClientsWithPendingWrites() function).
- * If we fail and there is more data to write, compared to what the socket
- * buffers can hold, then we'll really install the handler. */
-void clientInstallWriteHandler(client *c) {
-    /* Schedule the client to write the output buffers to the socket only
-     * if not already done and, for slaves, if the slave can actually receive
-     * writes at this stage. */
-    if (!(c->flags & CLIENT_PENDING_WRITE) &&
-        (c->replstate == REPL_STATE_NONE ||
-         (c->replstate == SLAVE_STATE_ONLINE && !c->repl_put_online_on_ack)))
-    {
-        /* Here instead of installing the write handler, we just flag the
-         * client and put it into a list of clients that have something
-         * to write to the socket. This way before re-entering the event
-         * loop, we can try to directly write to the client sockets avoiding
-         * a system call. We'll only really install the write handler if
-         * we'll not be able to write the whole reply at once. */
-        c->flags |= CLIENT_PENDING_WRITE;
-        listAddNodeHead(server.clients_pending_write,c);
-    }
-}
-
 /* This function is called every time we are going to transmit new data
  * to the client. The behavior is the following:
  *
@@ -224,9 +197,24 @@ int prepareClientToWrite(client *c) {
 
     if (c->fd <= 0) return C_ERR; /* Fake client for AOF loading. */
 
-    /* Schedule the client to write the output buffers to the socket, unless
-     * it should already be setup to do so (it has already pending data). */
-    if (!clientHasPendingReplies(c)) clientInstallWriteHandler(c);
+    /* Schedule the client to write the output buffers to the socket only
+     * if not already done (there were no pending writes already and the client
+     * was yet not flagged), and, for slaves, if the slave can actually
+     * receive writes at this stage. */
+    if (!clientHasPendingReplies(c) &&
+        !(c->flags & CLIENT_PENDING_WRITE) &&
+        (c->replstate == REPL_STATE_NONE ||
+         (c->replstate == SLAVE_STATE_ONLINE && !c->repl_put_online_on_ack)))
+    {
+        /* Here instead of installing the write handler, we just flag the
+         * client and put it into a list of clients that have something
+         * to write to the socket. This way before re-entering the event
+         * loop, we can try to directly write to the client sockets avoiding
+         * a system call. We'll only really install the write handler if
+         * we'll not be able to write the whole reply at once. */
+        c->flags |= CLIENT_PENDING_WRITE;
+        listAddNodeHead(server.clients_pending_write,c);
+    }
 
     /* Authorize the caller to queue in the output buffer of this client. */
     return C_OK;
@@ -366,13 +354,19 @@ void addReplyErrorLength(client *c, const char *s, size_t len) {
      * Where the master must propagate the first change even if the second
      * will produce an error. However it is useful to log such events since
      * they are rare and may hint at errors in a script or a bug in Redis. */
-    if (c->flags & (CLIENT_MASTER|CLIENT_SLAVE) && !(c->flags & CLIENT_MONITOR)) {
+    if (c->flags & (CLIENT_MASTER|CLIENT_SLAVE)) {
         char* to = c->flags & CLIENT_MASTER? "master": "replica";
         char* from = c->flags & CLIENT_MASTER? "replica": "master";
         char *cmdname = c->lastcmd ? c->lastcmd->name : "<unknown>";
         serverLog(LL_WARNING,"== CRITICAL == This %s is sending an error "
                              "to its %s: '%s' after processing the command "
                              "'%s'", from, to, s, cmdname);
+        /* Here we want to panic because when a master is sending an
+         * error to some slave in the context of replication, this can
+         * only create some kind of offset or data desynchronization. Better
+         * to catch it ASAP and crash instead of continuing. */
+        if (c->flags & CLIENT_SLAVE)
+            serverPanic("Continuing is unsafe: replication protocol violation.");
     }
 }
 
@@ -629,19 +623,6 @@ void addReplySubcommandSyntaxError(client *c) {
     sdsfree(cmd);
 }
 
-/* Append 'src' client output buffers into 'dst' client output buffers. 
- * This function clears the output buffers of 'src' */
-void AddReplyFromClient(client *dst, client *src) {
-    if (prepareClientToWrite(dst) != C_OK)
-        return;
-    addReplyString(dst,src->buf, src->bufpos);
-    if (listLength(src->reply))
-        listJoin(dst->reply,src->reply);
-    dst->reply_bytes += src->reply_bytes;
-    src->reply_bytes = 0;
-    src->bufpos = 0;
-}
-
 /* Copy 'src' client output buffers into 'dst' client output buffers.
  * The function takes care of freeing the old output buffers of the
  * destination client. */
@@ -809,16 +790,6 @@ void unlinkClient(client *c) {
             c->client_list_node = NULL;
         }
 
-        /* In the case of diskless replication the fork is writing to the
-         * sockets and just closing the fd isn't enough, if we don't also
-         * shutdown the socket the fork will continue to write to the slave
-         * and the salve will only find out that it was disconnected when
-         * it will finish reading the rdb. */
-        if ((c->flags & CLIENT_SLAVE) &&
-            (c->replstate == SLAVE_STATE_WAIT_BGSAVE_END)) {
-            shutdown(c->fd, SHUT_RDWR);
-        }
-
         /* Unregister async I/O handlers and close the socket. */
         aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
         aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
@@ -847,13 +818,6 @@ void unlinkClient(client *c) {
 void freeClient(client *c) {
     listNode *ln;
 
-    /* If a client is protected, yet we need to free it right now, make sure
-     * to at least use asynchronous freeing. */
-    if (c->flags & CLIENT_PROTECTED) {
-        freeClientAsync(c);
-        return;
-    }
-
     /* If it is our master that's beging disconnected we should make sure
      * to cache the state to try a partial resynchronization later.
      *
@@ -918,7 +882,7 @@ void freeClient(client *c) {
         /* We need to remember the time when we started to have zero
          * attached slaves, as after some time we'll free the replication
          * backlog. */
-        if (getClientType(c) == CLIENT_TYPE_SLAVE && listLength(server.slaves) == 0)
+        if (c->flags & CLIENT_SLAVE && listLength(server.slaves) == 0)
             server.repl_no_slaves_since = server.unixtime;
         refreshGoodSlavesCount();
     }
@@ -1030,8 +994,8 @@ int writeToClient(int fd, client *c, int handler_installed) {
          * just deliver as much data as it is possible to deliver.
          *
          * Moreover, we also send as much as possible if the client is
-         * a slave or a monitor (otherwise, on high-speed traffic, the
-         * replication/output buffer will grow indefinitely) */
+         * a slave (otherwise, on high-speed traffic, the replication
+         * buffer will grow indefinitely) */
         if (totwritten > NET_MAX_WRITES_PER_EVENT &&
             (server.maxmemory == 0 ||
              zmalloc_used_memory() < server.maxmemory) &&
@@ -1090,10 +1054,6 @@ int handleClientsWithPendingWrites(void) {
         c->flags &= ~CLIENT_PENDING_WRITE;
         listDelNode(server.clients_pending_write,ln);
 
-        /* If a client is protected, don't do anything,
-         * that may trigger write error or recreate handler. */
-        if (c->flags & CLIENT_PROTECTED) continue;
-
         /* Try to write buffers to the client socket. */
         if (writeToClient(c->fd,c,0) == C_ERR) continue;
 
@@ -1145,34 +1105,6 @@ void resetClient(client *c) {
     }
 }
 
-/* This funciton is used when we want to re-enter the event loop but there
- * is the risk that the client we are dealing with will be freed in some
- * way. This happens for instance in:
- *
- * * DEBUG RELOAD and similar.
- * * When a Lua script is in -BUSY state.
- *
- * So the function will protect the client by doing two things:
- *
- * 1) It removes the file events. This way it is not possible that an
- *    error is signaled on the socket, freeing the client.
- * 2) Moreover it makes sure that if the client is freed in a different code
- *    path, it is not really released, but only marked for later release. */
-void protectClient(client *c) {
-    c->flags |= CLIENT_PROTECTED;
-    aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
-    aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
-}
-
-/* This will undo the client protection done by protectClient() */
-void unprotectClient(client *c) {
-    if (c->flags & CLIENT_PROTECTED) {
-        c->flags &= ~CLIENT_PROTECTED;
-        aeCreateFileEvent(server.el,c->fd,AE_READABLE,readQueryFromClient,c);
-        if (clientHasPendingReplies(c)) clientInstallWriteHandler(c);
-    }
-}
-
 /* Like processMultibulkBuffer(), but for the inline protocol instead of RESP,
  * this function consumes the client query buffer and creates a command ready
  * to be executed inside the client structure. Returns C_OK if the command
@@ -1216,7 +1148,7 @@ int processInlineBuffer(client *c) {
     /* Newline from slaves can be used to refresh the last ACK time.
      * This is useful for a slave to ping back while loading a big
      * RDB file. */
-    if (querylen == 0 && getClientType(c) == CLIENT_TYPE_SLAVE)
+    if (querylen == 0 && c->flags & CLIENT_SLAVE)
         c->repl_ack_time = server.unixtime;
 
     /* Move querybuffer position to the next query in the buffer. */
@@ -1230,8 +1162,12 @@ int processInlineBuffer(client *c) {
 
     /* Create redis objects for all arguments. */
     for (c->argc = 0, j = 0; j < argc; j++) {
-        c->argv[c->argc] = createObject(OBJ_STRING,argv[j]);
-        c->argc++;
+        if (sdslen(argv[j])) {
+            c->argv[c->argc] = createObject(OBJ_STRING,argv[j]);
+            c->argc++;
+        } else {
+            sdsfree(argv[j]);
+        }
     }
     zfree(argv);
     return C_OK;
@@ -1484,7 +1420,7 @@ void processInputBuffer(client *c) {
     }
 
     /* Trim to pos */
-    if (server.current_client != NULL && c->qb_pos) {
+    if (c->qb_pos) {
         sdsrange(c->querybuf,c->qb_pos,-1);
         c->qb_pos = 0;
     }
@@ -2017,8 +1953,15 @@ void rewriteClientCommandArgument(client *c, int i, robj *newval) {
     }
 }
 
-/* This function returns the number of bytes that Redis is
+/* This function returns the number of bytes that Redis is virtually
  * using to store the reply still not read by the client.
+ * It is "virtual" since the reply output list may contain objects that
+ * are shared and are not really using additional memory.
+ *
+ * The function returns the total sum of the length of all the objects
+ * stored in the output list, plus the memory used to allocate every
+ * list node. The static reply buffer is not taken into account since it
+ * is allocated anyway.
  *
  * Note: this function is very fast so can be called as many time as
  * the caller wishes. The main usage of this function currently is
@@ -2033,14 +1976,12 @@ unsigned long getClientOutputBufferMemoryUsage(client *c) {
  *
  * The function will return one of the following:
  * CLIENT_TYPE_NORMAL -> Normal client
- * CLIENT_TYPE_SLAVE  -> Slave
+ * CLIENT_TYPE_SLAVE  -> Slave or client executing MONITOR command
  * CLIENT_TYPE_PUBSUB -> Client subscribed to Pub/Sub channels
  * CLIENT_TYPE_MASTER -> The client representing our replication master.
  */
 int getClientType(client *c) {
     if (c->flags & CLIENT_MASTER) return CLIENT_TYPE_MASTER;
-    /* Even though MONITOR clients are marked as replicas, we
-     * want the expose them as normal clients. */
     if ((c->flags & CLIENT_SLAVE) && !(c->flags & CLIENT_MONITOR))
         return CLIENT_TYPE_SLAVE;
     if (c->flags & CLIENT_PUBSUB) return CLIENT_TYPE_PUBSUB;
@@ -2118,7 +2059,6 @@ int checkClientOutputBufferLimits(client *c) {
  * called from contexts where the client can't be freed safely, i.e. from the
  * lower level functions pushing data inside the client output buffers. */
 void asyncCloseClientOnOutputBufferLimitReached(client *c) {
-    if (c->fd == -1) return; /* It is unsafe to free fake clients. */
     serverAssert(c->reply_bytes < SIZE_MAX-(1024*64));
     if (c->reply_bytes == 0 || c->flags & CLIENT_CLOSE_ASAP) return;
     if (checkClientOutputBufferLimits(c)) {
@@ -2141,27 +2081,17 @@ void flushSlavesOutputBuffers(void) {
     listRewind(server.slaves,&li);
     while((ln = listNext(&li))) {
         client *slave = listNodeValue(ln);
-        int events = aeGetFileEvents(server.el,slave->fd);
-        int can_receive_writes = (events & AE_WRITABLE) ||
-                                 (slave->flags & CLIENT_PENDING_WRITE);
+        int events;
 
-        /* We don't want to send the pending data to the replica in a few
-         * cases:
-         *
-         * 1. For some reason there is neither the write handler installed
-         *    nor the client is flagged as to have pending writes: for some
-         *    reason this replica may not be set to receive data. This is
-         *    just for the sake of defensive programming.
-         *
-         * 2. The put_online_on_ack flag is true. To know why we don't want
-         *    to send data to the replica in this case, please grep for the
-         *    flag for this flag.
-         *
-         * 3. Obviously if the slave is not ONLINE.
-         */
-        if (slave->replstate == SLAVE_STATE_ONLINE &&
-            can_receive_writes &&
-            !slave->repl_put_online_on_ack &&
+        /* Note that the following will not flush output buffers of slaves
+         * in STATE_ONLINE but having put_online_on_ack set to true: in this
+         * case the writable event is never installed, since the purpose
+         * of put_online_on_ack is to postpone the moment it is installed.
+         * This is what we want since slaves in this state should not receive
+         * writes before the first ACK. */
+        events = aeGetFileEvents(server.el,slave->fd);
+        if (events & AE_WRITABLE &&
+            slave->replstate == SLAVE_STATE_ONLINE &&
             clientHasPendingReplies(slave))
         {
             writeToClient(slave->fd,slave,0);

src/object.c

@@ -185,7 +185,7 @@ robj *createStringObjectFromLongDouble(long double value, int humanfriendly) {
 /* Duplicate a string object, with the guarantee that the returned object
  * has the same encoding as the original one.
  *
- * This function also guarantees that duplicating a small integer object
+ * This function also guarantees that duplicating a small integere object
  * (or a string object that contains a representation of a small integer)
  * will always result in a fresh object that is unshared (refcount == 1).
  *
@@ -415,18 +415,6 @@ int isObjectRepresentableAsLongLong(robj *o, long long *llval) {
     }
 }
 
-/* Optimize the SDS string inside the string object to require little space,
- * in case there is more than 10% of free space at the end of the SDS
- * string. This happens because SDS strings tend to overallocate to avoid
- * wasting too much time in allocations when appending to the string. */
-void trimStringObjectIfNeeded(robj *o) {
-    if (o->encoding == OBJ_ENCODING_RAW &&
-        sdsavail(o->ptr) > sdslen(o->ptr)/10)
-    {
-        o->ptr = sdsRemoveFreeSpace(o->ptr);
-    }
-}
-
 /* Try to encode a string object in order to save space */
 robj *tryObjectEncoding(robj *o) {
     long value;
@@ -467,15 +455,10 @@ robj *tryObjectEncoding(robj *o) {
             incrRefCount(shared.integers[value]);
             return shared.integers[value];
         } else {
-            if (o->encoding == OBJ_ENCODING_RAW) {
-                sdsfree(o->ptr);
-                o->encoding = OBJ_ENCODING_INT;
-                o->ptr = (void*) value;
-                return o;
-            } else if (o->encoding == OBJ_ENCODING_EMBSTR) {
-                decrRefCount(o);
-                return createStringObjectFromLongLongForValue(value);
-            }
+            if (o->encoding == OBJ_ENCODING_RAW) sdsfree(o->ptr);
+            o->encoding = OBJ_ENCODING_INT;
+            o->ptr = (void*) value;
+            return o;
         }
     }
 
@@ -501,7 +484,11 @@ robj *tryObjectEncoding(robj *o) {
      * We do that only for relatively large strings as this branch
      * is only entered if the length of the string is greater than
      * OBJ_ENCODING_EMBSTR_SIZE_LIMIT. */
-    trimStringObjectIfNeeded(o);
+    if (o->encoding == OBJ_ENCODING_RAW &&
+        sdsavail(s) > len/10)
+    {
+        o->ptr = sdsRemoveFreeSpace(o->ptr);
+    }
 
     /* Return the original object. */
     return o;
@@ -839,9 +826,7 @@ size_t objectComputeSize(robj *o, size_t sample_size) {
             d = ((zset*)o->ptr)->dict;
             zskiplist *zsl = ((zset*)o->ptr)->zsl;
             zskiplistNode *znode = zsl->header->level[0].forward;
-            asize = sizeof(*o)+sizeof(zset)+sizeof(zskiplist)+sizeof(dict)+
-                    (sizeof(struct dictEntry*)*dictSlots(d))+
-                    zmalloc_size(zsl->header);
+            asize = sizeof(*o)+sizeof(zset)+(sizeof(struct dictEntry*)*dictSlots(d));
             while(znode != NULL && samples < sample_size) {
                 elesize += sdsAllocSize(znode->ele);
                 elesize += sizeof(struct dictEntry) + zmalloc_size(znode);
@@ -1026,7 +1011,7 @@ struct redisMemOverhead *getMemoryOverheadData(void) {
 
     mem = 0;
     if (server.aof_state != AOF_OFF) {
-        mem += sdsalloc(server.aof_buf);
+        mem += sdslen(server.aof_buf);
         mem += aofRewriteBufferSize();
     }
     mh->aof_buffer = mem;
@@ -1206,7 +1191,7 @@ sds getMemoryDoctorReport(void) {
 
 /* Set the object LRU/LFU depending on server.maxmemory_policy.
  * The lfu_freq arg is only relevant if policy is MAXMEMORY_FLAG_LFU.
- * The lru_idle and lru_clock args are only relevant if policy
+ * The lru_idle and lru_clock args are only relevant if policy 
  * is MAXMEMORY_FLAG_LRU.
  * Either or both of them may be <0, in that case, nothing is set. */
 void objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
@@ -1217,20 +1202,16 @@ void objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
             val->lru = (LFUGetTimeInMinutes()<<8) | lfu_freq;
         }
     } else if (lru_idle >= 0) {
-        /* Provided LRU idle time is in seconds. Scale
+        /* Serialized LRU idle time is in seconds. Scale
          * according to the LRU clock resolution this Redis
          * instance was compiled with (normally 1000 ms, so the
          * below statement will expand to lru_idle*1000/1000. */
         lru_idle = lru_idle*1000/LRU_CLOCK_RESOLUTION;
-        long lru_abs = lru_clock - lru_idle; /* Absolute access time. */
-        /* If the LRU field underflows (since LRU it is a wrapping
-         * clock), the best we can do is to provide a large enough LRU
-         * that is half-way in the circlular LRU clock we use: this way
-         * the computed idle time for this object will stay high for quite
-         * some time. */
-        if (lru_abs < 0)
-            lru_abs = (lru_clock+(LRU_CLOCK_MAX/2)) % LRU_CLOCK_MAX;
-        val->lru = lru_abs;
+        val->lru = lru_clock - lru_idle;
+        /* If the lru field overflows (since LRU it is a wrapping
+         * clock), the best we can do is to provide the maximum
+         * representable idle time. */
+        if (val->lru < 0) val->lru = lru_clock+1;
     }
 }
 
@@ -1304,18 +1285,9 @@ NULL
  *
  * Usage: MEMORY usage <key> */
 void memoryCommand(client *c) {
-    if (!strcasecmp(c->argv[1]->ptr,"help") && c->argc == 2) {
-        const char *help[] = {
-"DOCTOR - Return memory problems reports.",
-"MALLOC-STATS -- Return internal statistics report from the memory allocator.",
-"PURGE -- Attempt to purge dirty pages for reclamation by the allocator.",
-"STATS -- Return information about the memory usage of the server.",
-"USAGE <key> [SAMPLES <count>] -- Return memory in bytes used by <key> and its value. Nested values are sampled up to <count> times (default: 5).",
-NULL
-        };
-        addReplyHelp(c, help);
-    } else if (!strcasecmp(c->argv[1]->ptr,"usage") && c->argc >= 3) {
-        dictEntry *de;
+    robj *o;
+
+    if (!strcasecmp(c->argv[1]->ptr,"usage") && c->argc >= 3) {
         long long samples = OBJ_COMPUTE_SIZE_DEF_SAMPLES;
         for (int j = 3; j < c->argc; j++) {
             if (!strcasecmp(c->argv[j]->ptr,"samples") &&
@@ -1334,12 +1306,10 @@ NULL
                 return;
             }
         }
-        if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {
-            addReply(c, shared.nullbulk);
-            return;
-        }
-        size_t usage = objectComputeSize(dictGetVal(de),samples);
-        usage += sdsAllocSize(dictGetKey(de));
+        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
+                == NULL) return;
+        size_t usage = objectComputeSize(o,samples);
+        usage += sdsAllocSize(c->argv[2]->ptr);
         usage += sizeof(dictEntry);
         addReplyLongLong(c,usage);
     } else if (!strcasecmp(c->argv[1]->ptr,"stats") && c->argc == 2) {
@@ -1464,7 +1434,19 @@ NULL
         addReply(c, shared.ok);
         /* Nothing to do for other allocators. */
 #endif
+    } else if (!strcasecmp(c->argv[1]->ptr,"help") && c->argc == 2) {
+        addReplyMultiBulkLen(c,5);
+        addReplyBulkCString(c,
+"MEMORY DOCTOR                        - Outputs memory problems report");
+        addReplyBulkCString(c,
+"MEMORY USAGE <key> [SAMPLES <count>] - Estimate memory usage of key");
+        addReplyBulkCString(c,
+"MEMORY STATS                         - Show memory usage details");
+        addReplyBulkCString(c,
+"MEMORY PURGE                         - Ask the allocator to release memory");
+        addReplyBulkCString(c,
+"MEMORY MALLOC-STATS                  - Show allocator internal stats");
     } else {
-        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try MEMORY HELP", (char*)c->argv[1]->ptr);
+        addReplyError(c,"Syntax error. Try MEMORY HELP");
     }
 }

src/quicklist.h

@@ -40,7 +40,7 @@
  * container: 2 bits, NONE=1, ZIPLIST=2.
  * recompress: 1 bit, bool, true if node is temporarry decompressed for usage.
  * attempted_compress: 1 bit, boolean, used for verifying during testing.
- * extra: 10 bits, free for future use; pads out the remainder of 32 bits */
+ * extra: 12 bits, free for future use; pads out the remainder of 32 bits */
 typedef struct quicklistNode {
     struct quicklistNode *prev;
     struct quicklistNode *next;

src/rax.c

@@ -1,6 +1,6 @@
 /* Rax -- A radix tree implementation.
  *
- * Copyright (c) 2017-2018, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2017, Salvatore Sanfilippo <antirez at gmail dot com>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -51,18 +51,14 @@ void *raxNotFound = (void*)"rax-not-found-pointer";
 
 void raxDebugShowNode(const char *msg, raxNode *n);
 
-/* Turn debugging messages on/off by compiling with RAX_DEBUG_MSG macro on.
- * When RAX_DEBUG_MSG is defined by default Rax operations will emit a lot
- * of debugging info to the standard output, however you can still turn
- * debugging on/off in order to enable it only when you suspect there is an
- * operation causing a bug using the function raxSetDebugMsg(). */
-#ifdef RAX_DEBUG_MSG
+/* Turn debugging messages on/off. */
+#if 0
 #define debugf(...)                                                            \
-    if (raxDebugMsg) {                                                         \
+    do {                                                                       \
         printf("%s:%s:%d:\t", __FILE__, __FUNCTION__, __LINE__);               \
         printf(__VA_ARGS__);                                                   \
         fflush(stdout);                                                        \
-    }
+    } while (0);
 
 #define debugnode(msg,n) raxDebugShowNode(msg,n)
 #else
@@ -70,16 +66,6 @@ void raxDebugShowNode(const char *msg, raxNode *n);
 #define debugnode(msg,n)
 #endif
 
-/* By default log debug info if RAX_DEBUG_MSG is defined. */
-static int raxDebugMsg = 1;
-
-/* When debug messages are enabled, turn them on/off dynamically. By
- * default they are enabled. Set the state to 0 to disable, and 1 to
- * re-enable. */
-void raxSetDebugMsg(int onoff) {
-    raxDebugMsg = onoff;
-}
-
 /* ------------------------- raxStack functions --------------------------
  * The raxStack is a simple stack of pointers that is capable of switching
  * from using a stack-allocated array to dynamic heap once a given number of
@@ -148,43 +134,12 @@ static inline void raxStackFree(raxStack *ts) {
  * Radix tree implementation
  * --------------------------------------------------------------------------*/
 
-/* Return the padding needed in the characters section of a node having size
- * 'nodesize'. The padding is needed to store the child pointers to aligned
- * addresses. Note that we add 4 to the node size because the node has a four
- * bytes header. */
-#define raxPadding(nodesize) ((sizeof(void*)-((nodesize+4) % sizeof(void*))) & (sizeof(void*)-1))
-
-/* Return the pointer to the last child pointer in a node. For the compressed
- * nodes this is the only child pointer. */
-#define raxNodeLastChildPtr(n) ((raxNode**) ( \
-    ((char*)(n)) + \
-    raxNodeCurrentLength(n) - \
-    sizeof(raxNode*) - \
-    (((n)->iskey && !(n)->isnull) ? sizeof(void*) : 0) \
-))
-
-/* Return the pointer to the first child pointer. */
-#define raxNodeFirstChildPtr(n) ((raxNode**) ( \
-    (n)->data + \
-    (n)->size + \
-    raxPadding((n)->size)))
-
-/* Return the current total size of the node. Note that the second line
- * computes the padding after the string of characters, needed in order to
- * save pointers to aligned addresses. */
-#define raxNodeCurrentLength(n) ( \
-    sizeof(raxNode)+(n)->size+ \
-    raxPadding((n)->size)+ \
-    ((n)->iscompr ? sizeof(raxNode*) : sizeof(raxNode*)*(n)->size)+ \
-    (((n)->iskey && !(n)->isnull)*sizeof(void*)) \
-)
-
 /* Allocate a new non compressed node with the specified number of children.
  * If datafiled is true, the allocation is made large enough to hold the
  * associated data pointer.
  * Returns the new node pointer. On out of memory NULL is returned. */
 raxNode *raxNewNode(size_t children, int datafield) {
-    size_t nodesize = sizeof(raxNode)+children+raxPadding(children)+
+    size_t nodesize = sizeof(raxNode)+children+
                       sizeof(raxNode*)*children;
     if (datafield) nodesize += sizeof(void*);
     raxNode *node = rax_malloc(nodesize);
@@ -212,6 +167,13 @@ rax *raxNew(void) {
     }
 }
 
+/* Return the current total size of the node. */
+#define raxNodeCurrentLength(n) ( \
+    sizeof(raxNode)+(n)->size+ \
+    ((n)->iscompr ? sizeof(raxNode*) : sizeof(raxNode*)*(n)->size)+ \
+    (((n)->iskey && !(n)->isnull)*sizeof(void*)) \
+)
+
 /* realloc the node to make room for auxiliary data in order
  * to store an item in that node. On out of memory NULL is returned. */
 raxNode *raxReallocForData(raxNode *n, void *data) {
@@ -254,17 +216,18 @@ void *raxGetData(raxNode *n) {
 raxNode *raxAddChild(raxNode *n, unsigned char c, raxNode **childptr, raxNode ***parentlink) {
     assert(n->iscompr == 0);
 
-    size_t curlen = raxNodeCurrentLength(n);
-    n->size++;
-    size_t newlen = raxNodeCurrentLength(n);
-    n->size--; /* For now restore the orignal size. We'll update it only on
-                  success at the end. */
+    size_t curlen = sizeof(raxNode)+
+                    n->size+
+                    sizeof(raxNode*)*n->size;
+    size_t newlen;
 
     /* Alloc the new child we will link to 'n'. */
     raxNode *child = raxNewNode(0,0);
     if (child == NULL) return NULL;
 
     /* Make space in the original node. */
+    if (n->iskey) curlen += sizeof(void*);
+    newlen = curlen+sizeof(raxNode*)+1; /* Add 1 char and 1 pointer. */
     raxNode *newn = rax_realloc(n,newlen);
     if (newn == NULL) {
         rax_free(child);
@@ -272,34 +235,14 @@ raxNode *raxAddChild(raxNode *n, unsigned char c, raxNode **childptr, raxNode **
     }
     n = newn;
 
-    /* After the reallocation, we have up to 8/16 (depending on the system
-     * pointer size, and the required node padding) bytes at the end, that is,
-     * the additional char in the 'data' section, plus one pointer to the new
-     * child, plus the padding needed in order to store addresses into aligned
-     * locations.
+    /* After the reallocation, we have 5/9 (depending on the system
+     * pointer size) bytes at the end, that is, the additional char
+     * in the 'data' section, plus one pointer to the new child:
      *
-     * So if we start with the following node, having "abde" edges.
-     *
-     * Note:
-     * - We assume 4 bytes pointer for simplicity.
-     * - Each space below corresponds to one byte
-     *
-     * [HDR*][abde][Aptr][Bptr][Dptr][Eptr]|AUXP|
-     *
-     * After the reallocation we need: 1 byte for the new edge character
-     * plus 4 bytes for a new child pointer (assuming 32 bit machine).
-     * However after adding 1 byte to the edge char, the header + the edge
-     * characters are no longer aligned, so we also need 3 bytes of padding.
-     * In total the reallocation will add 1+4+3 bytes = 8 bytes:
-     *
-     * (Blank bytes are represented by ".")
-     *
-     * [HDR*][abde][Aptr][Bptr][Dptr][Eptr]|AUXP|[....][....]
+     * [numc][abx][ap][bp][xp]|auxp|.....
      *
      * Let's find where to insert the new child in order to make sure
-     * it is inserted in-place lexicographically. Assuming we are adding
-     * a child "c" in our case pos will be = 2 after the end of the following
-     * loop. */
+     * it is inserted in-place lexicographically. */
     int pos;
     for (pos = 0; pos < n->size; pos++) {
         if (n->data[pos] > c) break;
@@ -309,81 +252,55 @@ raxNode *raxAddChild(raxNode *n, unsigned char c, raxNode **childptr, raxNode **
      * so that we can mess with the other data without overwriting it.
      * We will obtain something like that:
      *
-     * [HDR*][abde][Aptr][Bptr][Dptr][Eptr][....][....]|AUXP|
-     */
-    unsigned char *src, *dst;
+     * [numc][abx][ap][bp][xp].....|auxp| */
+    unsigned char *src;
     if (n->iskey && !n->isnull) {
-        src = ((unsigned char*)n+curlen-sizeof(void*));
-        dst = ((unsigned char*)n+newlen-sizeof(void*));
-        memmove(dst,src,sizeof(void*));
+        src = n->data+n->size+sizeof(raxNode*)*n->size;
+        memmove(src+1+sizeof(raxNode*),src,sizeof(void*));
     }
 
-    /* Compute the "shift", that is, how many bytes we need to move the
-     * pointers section forward because of the addition of the new child
-     * byte in the string section. Note that if we had no padding, that
-     * would be always "1", since we are adding a single byte in the string
-     * section of the node (where now there is "abde" basically).
-     *
-     * However we have padding, so it could be zero, or up to 8.
-     *
-     * Another way to think at the shift is, how many bytes we need to
-     * move child pointers forward *other than* the obvious sizeof(void*)
-     * needed for the additional pointer itself. */
-    size_t shift = newlen - curlen - sizeof(void*);
-
-    /* We said we are adding a node with edge 'c'. The insertion
-     * point is between 'b' and 'd', so the 'pos' variable value is
-     * the index of the first child pointer that we need to move forward
-     * to make space for our new pointer.
-     *
+    /* Now imagine we are adding a node with edge 'c'. The insertion
+     * point is between 'b' and 'x', so the 'pos' variable value is
      * To start, move all the child pointers after the insertion point
-     * of shift+sizeof(pointer) bytes on the right, to obtain:
+     * of 1+sizeof(pointer) bytes on the right, to obtain:
      *
-     * [HDR*][abde][Aptr][Bptr][....][....][Dptr][Eptr]|AUXP|
-     */
-    src = n->data+n->size+
-          raxPadding(n->size)+
-          sizeof(raxNode*)*pos;
-    memmove(src+shift+sizeof(raxNode*),src,sizeof(raxNode*)*(n->size-pos));
-
-    /* Move the pointers to the left of the insertion position as well. Often
-     * we don't need to do anything if there was already some padding to use. In
-     * that case the final destination of the pointers will be the same, however
-     * in our example there was no pre-existing padding, so we added one byte
-     * plus thre bytes of padding. After the next memmove() things will look
-     * like thata:
-     *
-     * [HDR*][abde][....][Aptr][Bptr][....][Dptr][Eptr]|AUXP|
-     */
-    if (shift) {
-        src = (unsigned char*) raxNodeFirstChildPtr(n);
-        memmove(src+shift,src,sizeof(raxNode*)*pos);
-    }
+     * [numc][abx][ap][bp].....[xp]|auxp| */
+    src = n->data+n->size+sizeof(raxNode*)*pos;
+    memmove(src+1+sizeof(raxNode*),src,sizeof(raxNode*)*(n->size-pos));
 
     /* Now make the space for the additional char in the data section,
-     * but also move the pointers before the insertion point to the right
-     * by shift bytes, in order to obtain the following:
+     * but also move the pointers before the insertion point in the right
+     * by 1 byte, in order to obtain the following:
      *
-     * [HDR*][ab.d][e...][Aptr][Bptr][....][Dptr][Eptr]|AUXP|
-     */
+     * [numc][ab.x][ap][bp]....[xp]|auxp| */
     src = n->data+pos;
-    memmove(src+1,src,n->size-pos);
+    memmove(src+1,src,n->size-pos+sizeof(raxNode*)*pos);
 
     /* We can now set the character and its child node pointer to get:
      *
-     * [HDR*][abcd][e...][Aptr][Bptr][....][Dptr][Eptr]|AUXP|
-     * [HDR*][abcd][e...][Aptr][Bptr][Cptr][Dptr][Eptr]|AUXP|
-     */
+     * [numc][abcx][ap][bp][cp]....|auxp|
+     * [numc][abcx][ap][bp][cp][xp]|auxp| */
     n->data[pos] = c;
     n->size++;
-    src = (unsigned char*) raxNodeFirstChildPtr(n);
-    raxNode **childfield = (raxNode**)(src+sizeof(raxNode*)*pos);
+    raxNode **childfield = (raxNode**)(n->data+n->size+sizeof(raxNode*)*pos);
     memcpy(childfield,&child,sizeof(child));
     *childptr = child;
     *parentlink = childfield;
     return n;
 }
 
+/* Return the pointer to the last child pointer in a node. For the compressed
+ * nodes this is the only child pointer. */
+#define raxNodeLastChildPtr(n) ((raxNode**) ( \
+    ((char*)(n)) + \
+    raxNodeCurrentLength(n) - \
+    sizeof(raxNode*) - \
+    (((n)->iskey && !(n)->isnull) ? sizeof(void*) : 0) \
+))
+
+/* Return the pointer to the first child pointer. */
+#define raxNodeFirstChildPtr(n) ((raxNode**)((n)->data+(n)->size))
+
 /* Turn the node 'n', that must be a node without any children, into a
  * compressed node representing a set of nodes linked one after the other
  * and having exactly one child each. The node can be a key or not: this
@@ -404,7 +321,7 @@ raxNode *raxCompressNode(raxNode *n, unsigned char *s, size_t len, raxNode **chi
     if (*child == NULL) return NULL;
 
     /* Make space in the parent node. */
-    newsize = sizeof(raxNode)+len+raxPadding(len)+sizeof(raxNode*);
+    newsize = sizeof(raxNode)+len+sizeof(raxNode*);
     if (n->iskey) {
         data = raxGetData(n); /* To restore it later. */
         if (!n->isnull) newsize += sizeof(void*);
@@ -702,14 +619,13 @@ int raxGenericInsert(rax *rax, unsigned char *s, size_t len, void *data, void **
         raxNode *postfix = NULL;
 
         if (trimmedlen) {
-            nodesize = sizeof(raxNode)+trimmedlen+raxPadding(trimmedlen)+
-                       sizeof(raxNode*);
+            nodesize = sizeof(raxNode)+trimmedlen+sizeof(raxNode*);
             if (h->iskey && !h->isnull) nodesize += sizeof(void*);
             trimmed = rax_malloc(nodesize);
         }
 
         if (postfixlen) {
-            nodesize = sizeof(raxNode)+postfixlen+raxPadding(postfixlen)+
+            nodesize = sizeof(raxNode)+postfixlen+
                        sizeof(raxNode*);
             postfix = rax_malloc(nodesize);
         }
@@ -785,12 +701,11 @@ int raxGenericInsert(rax *rax, unsigned char *s, size_t len, void *data, void **
 
         /* Allocate postfix & trimmed nodes ASAP to fail for OOM gracefully. */
         size_t postfixlen = h->size - j;
-        size_t nodesize = sizeof(raxNode)+postfixlen+raxPadding(postfixlen)+
-                          sizeof(raxNode*);
+        size_t nodesize = sizeof(raxNode)+postfixlen+sizeof(raxNode*);
         if (data != NULL) nodesize += sizeof(void*);
         raxNode *postfix = rax_malloc(nodesize);
 
-        nodesize = sizeof(raxNode)+j+raxPadding(j)+sizeof(raxNode*);
+        nodesize = sizeof(raxNode)+j+sizeof(raxNode*);
         if (h->iskey && !h->isnull) nodesize += sizeof(void*);
         raxNode *trimmed = rax_malloc(nodesize);
 
@@ -960,7 +875,7 @@ raxNode *raxRemoveChild(raxNode *parent, raxNode *child) {
         return parent;
     }
 
-    /* Otherwise we need to scan for the child pointer and memmove()
+    /* Otherwise we need to scan for the children pointer and memmove()
      * accordingly.
      *
      * 1. To start we seek the first element in both the children
@@ -985,21 +900,13 @@ raxNode *raxRemoveChild(raxNode *parent, raxNode *child) {
     debugf("raxRemoveChild tail len: %d\n", taillen);
     memmove(e,e+1,taillen);
 
-    /* Compute the shift, that is the amount of bytes we should move our
-     * child pointers to the left, since the removal of one edge character
-     * and the corresponding padding change, may change the layout.
-     * We just check if in the old version of the node there was at the
-     * end just a single byte and all padding: in that case removing one char
-     * will remove a whole sizeof(void*) word. */
-    size_t shift = ((parent->size+4) % sizeof(void*)) == 1 ? sizeof(void*) : 0;
+    /* Since we have one data byte less, also child pointers start one byte
+     * before now. */
+    memmove(((char*)cp)-1,cp,(parent->size-taillen-1)*sizeof(raxNode**));
 
-    /* Move the children pointers before the deletion point. */
-    if (shift)
-        memmove(((char*)cp)-shift,cp,(parent->size-taillen-1)*sizeof(raxNode**));
-
-    /* Move the remaining "tail" pointers at the right position as well. */
+    /* Move the remaining "tail" pointer at the right position as well. */
     size_t valuelen = (parent->iskey && !parent->isnull) ? sizeof(void*) : 0;
-    memmove(((char*)c)-shift,c+1,taillen*sizeof(raxNode**)+valuelen);
+    memmove(((char*)c)-1,c+1,taillen*sizeof(raxNode**)+valuelen);
 
     /* 4. Update size. */
     parent->size--;
@@ -1165,7 +1072,7 @@ int raxRemove(rax *rax, unsigned char *s, size_t len, void **old) {
         if (nodes > 1) {
             /* If we can compress, create the new node and populate it. */
             size_t nodesize =
-                sizeof(raxNode)+comprsize+raxPadding(comprsize)+sizeof(raxNode*);
+                sizeof(raxNode)+comprsize+sizeof(raxNode*);
             raxNode *new = rax_malloc(nodesize);
             /* An out of memory here just means we cannot optimize this
              * node, but the tree is left in a consistent state. */
@@ -1406,7 +1313,7 @@ int raxIteratorNextStep(raxIterator *it, int noup) {
     }
 }
 
-/* Seek the grestest key in the subtree at the current node. Return 0 on
+/* Seek the greatest key in the subtree at the current node. Return 0 on
  * out of memory, otherwise 1. This is an helper function for different
  * iteration functions below. */
 int raxSeekGreatest(raxIterator *it) {
@@ -1886,7 +1793,6 @@ void raxShow(rax *rax) {
 
 /* Used by debugnode() macro to show info about a given node. */
 void raxDebugShowNode(const char *msg, raxNode *n) {
-    if (raxDebugMsg == 0) return;
     printf("%s: %p [%.*s] key:%d size:%d children:",
         msg, (void*)n, (int)n->size, (char*)n->data, n->iskey, n->size);
     int numcld = n->iscompr ? 1 : n->size;
@@ -1901,43 +1807,4 @@ void raxDebugShowNode(const char *msg, raxNode *n) {
     fflush(stdout);
 }
 
-/* Touch all the nodes of a tree returning a check sum. This is useful
- * in order to make Valgrind detect if there is something wrong while
- * reading the data structure.
- *
- * This function was used in order to identify Rax bugs after a big refactoring
- * using this technique:
- *
- * 1. The rax-test is executed using Valgrind, adding a printf() so that for
- *    the fuzz tester we see what iteration in the loop we are in.
- * 2. After every modification of the radix tree made by the fuzz tester
- *    in rax-test.c, we add a call to raxTouch().
- * 3. Now as soon as an operation will corrupt the tree, raxTouch() will
- *    detect it (via Valgrind) immediately. We can add more calls to narrow
- *    the state.
- * 4. At this point a good idea is to enable Rax debugging messages immediately
- *    before the moment the tree is corrupted, to see what happens.
- */
-unsigned long raxTouch(raxNode *n) {
-    debugf("Touching %p\n", (void*)n);
-    unsigned long sum = 0;
-    if (n->iskey) {
-        sum += (unsigned long)raxGetData(n);
-    }
 
-    int numchildren = n->iscompr ? 1 : n->size;
-    raxNode **cp = raxNodeFirstChildPtr(n);
-    int count = 0;
-    for (int i = 0; i < numchildren; i++) {
-        if (numchildren > 1) {
-            sum += (long)n->data[i];
-        }
-        raxNode *child;
-        memcpy(&child,cp,sizeof(child));
-        if (child == (void*)0x65d1760) count++;
-        if (count > 1) exit(1);
-        sum += raxTouch(child);
-        cp++;
-    }
-    return sum;
-}

src/rax.h

@@ -1,33 +1,3 @@
-/* Rax -- A radix tree implementation.
- *
- * Copyright (c) 2017-2018, Salvatore Sanfilippo <antirez at gmail dot com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
 #ifndef RAX_H
 #define RAX_H
 
@@ -107,16 +77,16 @@ typedef struct raxNode {
      * Note how the character is not stored in the children but in the
      * edge of the parents:
      *
-     * [header iscompr=0][abc][a-ptr][b-ptr][c-ptr](value-ptr?)
+     * [header strlen=0][abc][a-ptr][b-ptr][c-ptr](value-ptr?)
      *
-     * if node is compressed (iscompr bit is 1) the node has 1 children.
+     * if node is compressed (strlen != 0) the node has 1 children.
      * In that case the 'size' bytes of the string stored immediately at
      * the start of the data section, represent a sequence of successive
      * nodes linked one after the other, for which only the last one in
      * the sequence is actually represented as a node, and pointed to by
      * the current compressed node.
      *
-     * [header iscompr=1][xyz][z-ptr](value-ptr?)
+     * [header strlen=3][xyz][z-ptr](value-ptr?)
      *
      * Both compressed and not compressed nodes can represent a key
      * with associated data in the radix tree at any level (not just terminal
@@ -206,8 +176,6 @@ void raxStop(raxIterator *it);
 int raxEOF(raxIterator *it);
 void raxShow(rax *rax);
 uint64_t raxSize(rax *rax);
-unsigned long raxTouch(raxNode *n);
-void raxSetDebugMsg(int onoff);
 
 /* Internal API. May be used by the node callback in order to access rax nodes
  * in a low level way, so this function is exported as well. */

src/rdb.c

@@ -751,7 +751,7 @@ size_t rdbSaveStreamConsumers(rio *rdb, streamCG *cg) {
 
 /* Save a Redis object.
  * Returns -1 on error, number of bytes written on success. */
-ssize_t rdbSaveObject(rio *rdb, robj *o, robj *key) {
+ssize_t rdbSaveObject(rio *rdb, robj *o) {
     ssize_t n = 0, nwritten = 0;
 
     if (o->type == OBJ_STRING) {
@@ -966,6 +966,7 @@ ssize_t rdbSaveObject(rio *rdb, robj *o, robj *key) {
         RedisModuleIO io;
         moduleValue *mv = o->ptr;
         moduleType *mt = mv->type;
+        moduleInitIOContext(io,mt,rdb);
 
         /* Write the "module" identifier as prefix, so that we'll be able
          * to call the right module during loading. */
@@ -974,13 +975,10 @@ ssize_t rdbSaveObject(rio *rdb, robj *o, robj *key) {
         io.bytes += retval;
 
         /* Then write the module-specific representation + EOF marker. */
-        moduleInitIOContext(io,mt,rdb,key);
         mt->rdb_save(&io,mv->value);
         retval = rdbSaveLen(rdb,RDB_MODULE_OPCODE_EOF);
-        if (retval == -1)
-            io.error = 1;
-        else
-            io.bytes += retval;
+        if (retval == -1) return -1;
+        io.bytes += retval;
 
         if (io.ctx) {
             moduleFreeContext(io.ctx);
@@ -998,7 +996,7 @@ ssize_t rdbSaveObject(rio *rdb, robj *o, robj *key) {
  * this length with very little changes to the code. In the future
  * we could switch to a faster solution. */
 size_t rdbSavedObjectLen(robj *o) {
-    ssize_t len = rdbSaveObject(NULL,o,NULL);
+    ssize_t len = rdbSaveObject(NULL,o);
     serverAssertWithInfo(NULL,o,len != -1);
     return len;
 }
@@ -1040,7 +1038,7 @@ int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime) {
     /* Save type, key, value */
     if (rdbSaveObjectType(rdb,val) == -1) return -1;
     if (rdbSaveStringObject(rdb,key) == -1) return -1;
-    if (rdbSaveObject(rdb,val,key) == -1) return -1;
+    if (rdbSaveObject(rdb,val) == -1) return -1;
     return 1;
 }
 
@@ -1093,45 +1091,6 @@ int rdbSaveInfoAuxFields(rio *rdb, int flags, rdbSaveInfo *rsi) {
     return 1;
 }
 
-ssize_t rdbSaveSingleModuleAux(rio *rdb, int when, moduleType *mt) {
-    /* Save a module-specific aux value. */
-    RedisModuleIO io;
-    int retval = rdbSaveType(rdb, RDB_OPCODE_MODULE_AUX);
-
-    /* Write the "module" identifier as prefix, so that we'll be able
-     * to call the right module during loading. */
-    retval = rdbSaveLen(rdb,mt->id);
-    if (retval == -1) return -1;
-    io.bytes += retval;
-
-    /* write the 'when' so that we can provide it on loading. add a UINT opcode
-     * for backwards compatibility, everything after the MT needs to be prefixed
-     * by an opcode. */
-    retval = rdbSaveLen(rdb,RDB_MODULE_OPCODE_UINT);
-    if (retval == -1) return -1;
-    io.bytes += retval;
-    retval = rdbSaveLen(rdb,when);
-    if (retval == -1) return -1;
-    io.bytes += retval;
-
-    /* Then write the module-specific representation + EOF marker. */
-    moduleInitIOContext(io,mt,rdb,NULL);
-    mt->aux_save(&io,when);
-    retval = rdbSaveLen(rdb,RDB_MODULE_OPCODE_EOF);
-    if (retval == -1)
-        io.error = 1;
-    else
-        io.bytes += retval;
-
-    if (io.ctx) {
-        moduleFreeContext(io.ctx);
-        zfree(io.ctx);
-    }
-    if (io.error)
-        return -1;
-    return io.bytes;
-}
-
 /* Produces a dump of the database in RDB format sending it to the specified
  * Redis I/O channel. On success C_OK is returned, otherwise C_ERR
  * is returned and part of the output, or all the output, can be
@@ -1153,7 +1112,6 @@ int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
     snprintf(magic,sizeof(magic),"REDIS%04d",RDB_VERSION);
     if (rdbWriteRaw(rdb,magic,9) == -1) goto werr;
     if (rdbSaveInfoAuxFields(rdb,flags,rsi) == -1) goto werr;
-    if (rdbSaveModulesAux(rdb, REDISMODULE_AUX_BEFORE_RDB) == -1) goto werr;
 
     for (j = 0; j < server.dbnum; j++) {
         redisDb *db = server.db+j;
@@ -1215,8 +1173,6 @@ int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
         di = NULL; /* So that we don't release it again on error. */
     }
 
-    if (rdbSaveModulesAux(rdb, REDISMODULE_AUX_AFTER_RDB) == -1) goto werr;
-
     /* EOF opcode */
     if (rdbSaveType(rdb,RDB_OPCODE_EOF) == -1) goto werr;
 
@@ -1424,7 +1380,7 @@ robj *rdbLoadCheckModuleValue(rio *rdb, char *modulename) {
 
 /* Load a Redis object of the specified type from the specified file.
  * On success a newly allocated object is returned, otherwise NULL. */
-robj *rdbLoadObject(int rdbtype, rio *rdb, robj *key) {
+robj *rdbLoadObject(int rdbtype, rio *rdb) {
     robj *o = NULL, *ele, *dec;
     uint64_t len;
     unsigned int i;
@@ -1689,9 +1645,6 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, robj *key) {
              * node: the entries inside the listpack itself are delta-encoded
              * relatively to this ID. */
             sds nodekey = rdbGenericLoadStringObject(rdb,RDB_LOAD_SDS,NULL);
-            if (nodekey == NULL) {
-                rdbExitReportCorruptRDB("Stream master ID loading failed: invalid encoding or I/O error.");
-            }
             if (sdslen(nodekey) != sizeof(streamID)) {
                 rdbExitReportCorruptRDB("Stream node key entry is not the "
                                         "size of a stream ID");
@@ -1811,7 +1764,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, robj *key) {
             exit(1);
         }
         RedisModuleIO io;
-        moduleInitIOContext(io,mt,rdb,key);
+        moduleInitIOContext(io,mt,rdb);
         io.ver = (rdbtype == RDB_TYPE_MODULE) ? 1 : 2;
         /* Call the rdb_load method of the module providing the 10 bit
          * encoding version in the lower 10 bits of the module ID. */
@@ -1881,7 +1834,7 @@ void rdbLoadProgressCallback(rio *r, const void *buf, size_t len) {
         /* The DB can take some non trivial amount of time to load. Update
          * our cached time since it is used to create and update the last
          * interaction time with clients and for other important things. */
-        updateCachedTime(0);
+        updateCachedTime();
         if (server.masterhost && server.repl_state == REPL_STATE_TRANSFER)
             replicationSendNewlineToMaster();
         loadingProgress(r->processed_bytes);
@@ -2018,14 +1971,15 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
             decrRefCount(auxval);
             continue; /* Read type again. */
         } else if (type == RDB_OPCODE_MODULE_AUX) {
-            /* Load module data that is not related to the Redis key space.
-             * Such data can be potentially be stored both before and after the
-             * RDB keys-values section. */
+            /* This is just for compatibility with the future: we have plans
+             * to add the ability for modules to store anything in the RDB
+             * file, like data that is not related to the Redis key space.
+             * Such data will potentially be stored both before and after the
+             * RDB keys-values section. For this reason since RDB version 9,
+             * we have the ability to read a MODULE_AUX opcode followed by an
+             * identifier of the module, and a serialized value in "MODULE V2"
+             * format. */
             uint64_t moduleid = rdbLoadLen(rdb,NULL);
-            int when_opcode = rdbLoadLen(rdb,NULL);
-            int when = rdbLoadLen(rdb,NULL);
-            if (when_opcode != RDB_MODULE_OPCODE_UINT)
-                rdbExitReportCorruptRDB("bad when_opcode");
             moduleType *mt = moduleTypeLookupModuleByID(moduleid);
             char name[10];
             moduleTypeNameByID(name,moduleid);
@@ -2035,44 +1989,21 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
                 serverLog(LL_WARNING,"The RDB file contains AUX module data I can't load: no matching module '%s'", name);
                 exit(1);
             } else if (!rdbCheckMode && mt != NULL) {
-                if (!mt->aux_load) {
-                    /* Module doesn't support AUX. */
-                    serverLog(LL_WARNING,"The RDB file contains module AUX data, but the module '%s' doesn't seem to support it.", name);
-                    exit(1);
-                }
-
-                RedisModuleIO io;
-                moduleInitIOContext(io,mt,rdb,NULL);
-                io.ver = 2;
-                /* Call the rdb_load method of the module providing the 10 bit
-                 * encoding version in the lower 10 bits of the module ID. */
-                if (mt->aux_load(&io,moduleid&1023, when) || io.error) {
-                    moduleTypeNameByID(name,moduleid);
-                    serverLog(LL_WARNING,"The RDB file contains module AUX data for the module type '%s', that the responsible module is not able to load. Check for modules log above for additional clues.", name);
-                    exit(1);
-                }
-                if (io.ctx) {
-                    moduleFreeContext(io.ctx);
-                    zfree(io.ctx);
-                }
-                uint64_t eof = rdbLoadLen(rdb,NULL);
-                if (eof != RDB_MODULE_OPCODE_EOF) {
-                    serverLog(LL_WARNING,"The RDB file contains module AUX data for the module '%s' that is not terminated by the proper module value EOF marker", name);
-                    exit(1);
-                }
-                continue;
+                /* This version of Redis actually does not know what to do
+                 * with modules AUX data... */
+                serverLog(LL_WARNING,"The RDB file contains AUX module data I can't load for the module '%s'. Probably you want to use a newer version of Redis which implements aux data callbacks", name);
+                exit(1);
             } else {
                 /* RDB check mode. */
                 robj *aux = rdbLoadCheckModuleValue(rdb,name);
                 decrRefCount(aux);
-                continue; /* Read next opcode. */
             }
         }
 
         /* Read key */
         if ((key = rdbLoadStringObject(rdb)) == NULL) goto eoferr;
         /* Read value */
-        if ((val = rdbLoadObject(type,rdb,key)) == NULL) goto eoferr;
+        if ((val = rdbLoadObject(type,rdb)) == NULL) goto eoferr;
         /* Check if the key already expired. This function is used when loading
          * an RDB file from disk, either at startup, or when an RDB was
          * received from the master. In the latter case, the master is

src/rdb.h

@@ -140,12 +140,11 @@ int rdbSaveBackground(char *filename, rdbSaveInfo *rsi);
 int rdbSaveToSlavesSockets(rdbSaveInfo *rsi);
 void rdbRemoveTempFile(pid_t childpid);
 int rdbSave(char *filename, rdbSaveInfo *rsi);
-ssize_t rdbSaveObject(rio *rdb, robj *o, robj *key);
+ssize_t rdbSaveObject(rio *rdb, robj *o);
 size_t rdbSavedObjectLen(robj *o);
-robj *rdbLoadObject(int type, rio *rdb, robj *key);
+robj *rdbLoadObject(int type, rio *rdb);
 void backgroundSaveDoneHandler(int exitcode, int bysignal);
 int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime);
-ssize_t rdbSaveSingleModuleAux(rio *rdb, int when, moduleType *mt);
 robj *rdbLoadStringObject(rio *rdb);
 ssize_t rdbSaveStringObject(rio *rdb, robj *obj);
 ssize_t rdbSaveRawString(rio *rdb, unsigned char *s, size_t len);

src/redis-check-aof.c

@@ -33,11 +33,11 @@
 
 #define ERROR(...) { \
     char __buf[1024]; \
-    snprintf(__buf, sizeof(__buf), __VA_ARGS__); \
-    snprintf(error, sizeof(error), "0x%16llx: %s", (long long)epos, __buf); \
+    sprintf(__buf, __VA_ARGS__); \
+    sprintf(error, "0x%16llx: %s", (long long)epos, __buf); \
 }
 
-static char error[1044];
+static char error[1024];
 static off_t epos;
 
 int consumeNewline(char *buf) {

src/redis-check-rdb.c

@@ -285,7 +285,7 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
         rdbstate.keys++;
         /* Read value */
         rdbstate.doing = RDB_CHECK_DOING_READ_OBJECT_VALUE;
-        if ((val = rdbLoadObject(type,&rdb,key)) == NULL) goto eoferr;
+        if ((val = rdbLoadObject(type,&rdb)) == NULL) goto eoferr;
         /* Check if the key already expired. */
         if (expiretime != -1 && expiretime < now)
             rdbstate.already_expired++;

src/redismodule.h

@@ -85,26 +85,6 @@
 #define REDISMODULE_CTX_FLAGS_OOM (1<<10)
 /* Less than 25% of memory available according to maxmemory. */
 #define REDISMODULE_CTX_FLAGS_OOM_WARNING (1<<11)
-/* The command was sent over the replication link. */
-#define REDISMODULE_CTX_FLAGS_REPLICATED (1<<12)
-/* Redis is currently loading either from AOF or RDB. */
-#define REDISMODULE_CTX_FLAGS_LOADING (1<<13)
-/* The replica has no link with its master, note that
- * there is the inverse flag as well:
- *
- *  REDISMODULE_CTX_FLAGS_REPLICA_IS_ONLINE
- *
- * The two flags are exclusive, one or the other can be set. */
-#define REDISMODULE_CTX_FLAGS_REPLICA_IS_STALE (1<<14)
-/* The replica is trying to connect with the master.
- * (REPL_STATE_CONNECT and REPL_STATE_CONNECTING states) */
-#define REDISMODULE_CTX_FLAGS_REPLICA_IS_CONNECTING (1<<15)
-/* THe replica is receiving an RDB file from its master. */
-#define REDISMODULE_CTX_FLAGS_REPLICA_IS_TRANSFERRING (1<<16)
-/* The replica is online, receiving updates from its master. */
-#define REDISMODULE_CTX_FLAGS_REPLICA_IS_ONLINE (1<<17)
-/* There is currently some background process active. */
-#define REDISMODULE_CTX_FLAGS_ACTIVE_CHILD (1<<18)
 
 #define REDISMODULE_NOTIFY_GENERIC (1<<2)     /* g */
 #define REDISMODULE_NOTIFY_STRING (1<<3)      /* $ */
@@ -143,21 +123,12 @@
 
 #define REDISMODULE_NOT_USED(V) ((void) V)
 
-/* Bit flags for aux_save_triggers and the aux_load and aux_save callbacks */
-#define REDISMODULE_AUX_BEFORE_RDB (1<<0)
-#define REDISMODULE_AUX_AFTER_RDB (1<<1)
-
 /* This type represents a timer handle, and is returned when a timer is
  * registered and used in order to invalidate a timer. It's just a 64 bit
  * number, because this is how each timer is represented inside the radix tree
  * of timers that are going to expire, sorted by expire time. */
 typedef uint64_t RedisModuleTimerID;
 
-/* CommandFilter Flags */
-
-/* Do filter RedisModule_Call() commands initiated by module itself. */
-#define REDISMODULE_CMDFILTER_NOSELF    (1<<0)
-
 /* ------------------------- End of common defines ------------------------ */
 
 #ifndef REDISMODULE_CORE
@@ -176,25 +147,20 @@ typedef struct RedisModuleBlockedClient RedisModuleBlockedClient;
 typedef struct RedisModuleClusterInfo RedisModuleClusterInfo;
 typedef struct RedisModuleDict RedisModuleDict;
 typedef struct RedisModuleDictIter RedisModuleDictIter;
-typedef struct RedisModuleCommandFilterCtx RedisModuleCommandFilterCtx;
-typedef struct RedisModuleCommandFilter RedisModuleCommandFilter;
 
 typedef int (*RedisModuleCmdFunc)(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
 typedef void (*RedisModuleDisconnectFunc)(RedisModuleCtx *ctx, RedisModuleBlockedClient *bc);
 typedef int (*RedisModuleNotificationFunc)(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key);
 typedef void *(*RedisModuleTypeLoadFunc)(RedisModuleIO *rdb, int encver);
 typedef void (*RedisModuleTypeSaveFunc)(RedisModuleIO *rdb, void *value);
-typedef int (*RedisModuleTypeAuxLoadFunc)(RedisModuleIO *rdb, int encver, int when);
-typedef void (*RedisModuleTypeAuxSaveFunc)(RedisModuleIO *rdb, int when);
 typedef void (*RedisModuleTypeRewriteFunc)(RedisModuleIO *aof, RedisModuleString *key, void *value);
 typedef size_t (*RedisModuleTypeMemUsageFunc)(const void *value);
 typedef void (*RedisModuleTypeDigestFunc)(RedisModuleDigest *digest, void *value);
 typedef void (*RedisModuleTypeFreeFunc)(void *value);
 typedef void (*RedisModuleClusterMessageReceiver)(RedisModuleCtx *ctx, const char *sender_id, uint8_t type, const unsigned char *payload, uint32_t len);
 typedef void (*RedisModuleTimerProc)(RedisModuleCtx *ctx, void *data);
-typedef void (*RedisModuleCommandFilterFunc) (RedisModuleCommandFilterCtx *filter);
 
-#define REDISMODULE_TYPE_METHOD_VERSION 2
+#define REDISMODULE_TYPE_METHOD_VERSION 1
 typedef struct RedisModuleTypeMethods {
     uint64_t version;
     RedisModuleTypeLoadFunc rdb_load;
@@ -203,9 +169,6 @@ typedef struct RedisModuleTypeMethods {
     RedisModuleTypeMemUsageFunc mem_usage;
     RedisModuleTypeDigestFunc digest;
     RedisModuleTypeFreeFunc free;
-    RedisModuleTypeAuxLoadFunc aux_load;
-    RedisModuleTypeAuxSaveFunc aux_save;
-    int aux_save_triggers;
 } RedisModuleTypeMethods;
 
 #define REDISMODULE_GET_API(name) \
@@ -251,7 +214,6 @@ int REDISMODULE_API_FUNC(RedisModule_ReplyWithSimpleString)(RedisModuleCtx *ctx,
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithArray)(RedisModuleCtx *ctx, long len);
 void REDISMODULE_API_FUNC(RedisModule_ReplySetArrayLength)(RedisModuleCtx *ctx, long len);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithStringBuffer)(RedisModuleCtx *ctx, const char *buf, size_t len);
-int REDISMODULE_API_FUNC(RedisModule_ReplyWithCString)(RedisModuleCtx *ctx, const char *buf);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithString)(RedisModuleCtx *ctx, RedisModuleString *str);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithNull)(RedisModuleCtx *ctx);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithDouble)(RedisModuleCtx *ctx, double d);
@@ -313,7 +275,6 @@ int REDISMODULE_API_FUNC(RedisModule_StringAppendBuffer)(RedisModuleCtx *ctx, Re
 void REDISMODULE_API_FUNC(RedisModule_RetainString)(RedisModuleCtx *ctx, RedisModuleString *str);
 int REDISMODULE_API_FUNC(RedisModule_StringCompare)(RedisModuleString *a, RedisModuleString *b);
 RedisModuleCtx *REDISMODULE_API_FUNC(RedisModule_GetContextFromIO)(RedisModuleIO *io);
-const RedisModuleString *REDISMODULE_API_FUNC(RedisModule_GetKeyNameFromIO)(RedisModuleIO *io);
 long long REDISMODULE_API_FUNC(RedisModule_Milliseconds)(void);
 void REDISMODULE_API_FUNC(RedisModule_DigestAddStringBuffer)(RedisModuleDigest *md, unsigned char *ele, size_t len);
 void REDISMODULE_API_FUNC(RedisModule_DigestAddLongLong)(RedisModuleDigest *md, long long ele);
@@ -371,15 +332,6 @@ void REDISMODULE_API_FUNC(RedisModule_GetRandomBytes)(unsigned char *dst, size_t
 void REDISMODULE_API_FUNC(RedisModule_GetRandomHexChars)(char *dst, size_t len);
 void REDISMODULE_API_FUNC(RedisModule_SetDisconnectCallback)(RedisModuleBlockedClient *bc, RedisModuleDisconnectFunc callback);
 void REDISMODULE_API_FUNC(RedisModule_SetClusterFlags)(RedisModuleCtx *ctx, uint64_t flags);
-int REDISMODULE_API_FUNC(RedisModule_ExportSharedAPI)(RedisModuleCtx *ctx, const char *apiname, void *func);
-void *REDISMODULE_API_FUNC(RedisModule_GetSharedAPI)(RedisModuleCtx *ctx, const char *apiname);
-RedisModuleCommandFilter *REDISMODULE_API_FUNC(RedisModule_RegisterCommandFilter)(RedisModuleCtx *ctx, RedisModuleCommandFilterFunc cb, int flags);
-int REDISMODULE_API_FUNC(RedisModule_UnregisterCommandFilter)(RedisModuleCtx *ctx, RedisModuleCommandFilter *filter);
-int REDISMODULE_API_FUNC(RedisModule_CommandFilterArgsCount)(RedisModuleCommandFilterCtx *fctx);
-const RedisModuleString *REDISMODULE_API_FUNC(RedisModule_CommandFilterArgGet)(RedisModuleCommandFilterCtx *fctx, int pos);
-int REDISMODULE_API_FUNC(RedisModule_CommandFilterArgInsert)(RedisModuleCommandFilterCtx *fctx, int pos, RedisModuleString *arg);
-int REDISMODULE_API_FUNC(RedisModule_CommandFilterArgReplace)(RedisModuleCommandFilterCtx *fctx, int pos, RedisModuleString *arg);
-int REDISMODULE_API_FUNC(RedisModule_CommandFilterArgDelete)(RedisModuleCommandFilterCtx *fctx, int pos);
 #endif
 
 /* This is included inline inside each Redis module. */
@@ -402,7 +354,6 @@ static int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int
     REDISMODULE_GET_API(ReplyWithArray);
     REDISMODULE_GET_API(ReplySetArrayLength);
     REDISMODULE_GET_API(ReplyWithStringBuffer);
-    REDISMODULE_GET_API(ReplyWithCString);
     REDISMODULE_GET_API(ReplyWithString);
     REDISMODULE_GET_API(ReplyWithNull);
     REDISMODULE_GET_API(ReplyWithCallReply);
@@ -486,7 +437,6 @@ static int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int
     REDISMODULE_GET_API(RetainString);
     REDISMODULE_GET_API(StringCompare);
     REDISMODULE_GET_API(GetContextFromIO);
-    REDISMODULE_GET_API(GetKeyNameFromIO);
     REDISMODULE_GET_API(Milliseconds);
     REDISMODULE_GET_API(DigestAddStringBuffer);
     REDISMODULE_GET_API(DigestAddLongLong);
@@ -542,15 +492,6 @@ static int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int
     REDISMODULE_GET_API(GetRandomBytes);
     REDISMODULE_GET_API(GetRandomHexChars);
     REDISMODULE_GET_API(SetClusterFlags);
-    REDISMODULE_GET_API(ExportSharedAPI);
-    REDISMODULE_GET_API(GetSharedAPI);
-    REDISMODULE_GET_API(RegisterCommandFilter);
-    REDISMODULE_GET_API(UnregisterCommandFilter);
-    REDISMODULE_GET_API(CommandFilterArgsCount);
-    REDISMODULE_GET_API(CommandFilterArgGet);
-    REDISMODULE_GET_API(CommandFilterArgInsert);
-    REDISMODULE_GET_API(CommandFilterArgReplace);
-    REDISMODULE_GET_API(CommandFilterArgDelete);
 #endif
 
     if (RedisModule_IsModuleNameBusy && RedisModule_IsModuleNameBusy(name)) return REDISMODULE_ERR;

src/replication.c

@@ -30,7 +30,6 @@
 
 
 #include "server.h"
-#include "cluster.h"
 
 #include <sys/time.h>
 #include <unistd.h>
@@ -594,7 +593,6 @@ int startBgsaveForReplication(int mincapa) {
             client *slave = ln->value;
 
             if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
-                slave->replstate = REPL_STATE_NONE;
                 slave->flags &= ~CLIENT_SLAVE;
                 listDelNode(server.slaves,ln);
                 addReplyError(slave,
@@ -823,9 +821,7 @@ void replconfCommand(client *c) {
             c->repl_ack_time = server.unixtime;
             /* If this was a diskless replication, we need to really put
              * the slave online when the first ACK is received (which
-             * confirms slave is online and ready to get more data). This
-             * allows for simpler and less CPU intensive EOF detection
-             * when streaming RDB files. */
+             * confirms slave is online and ready to get more data). */
             if (c->repl_put_online_on_ack && c->replstate == SLAVE_STATE_ONLINE)
                 putSlaveOnline(c);
             /* Note: this command does not reply anything! */
@@ -844,20 +840,18 @@ void replconfCommand(client *c) {
     addReply(c,shared.ok);
 }
 
-/* This function puts a replica in the online state, and should be called just
- * after a replica received the RDB file for the initial synchronization, and
+/* This function puts a slave in the online state, and should be called just
+ * after a slave received the RDB file for the initial synchronization, and
  * we are finally ready to send the incremental stream of commands.
  *
  * It does a few things:
  *
- * 1) Put the slave in ONLINE state. Note that the function may also be called
- *    for a replicas that are already in ONLINE state, but having the flag
- *    repl_put_online_on_ack set to true: we still have to install the write
- *    handler in that case. This function will take care of that.
+ * 1) Put the slave in ONLINE state (useless when the function is called
+ *    because state is already ONLINE but repl_put_online_on_ack is true).
  * 2) Make sure the writable event is re-installed, since calling the SYNC
  *    command disables it, so that we can accumulate output buffer without
- *    sending it to the replica.
- * 3) Update the count of "good replicas". */
+ *    sending it to the slave.
+ * 3) Update the count of good slaves. */
 void putSlaveOnline(client *slave) {
     slave->replstate = SLAVE_STATE_ONLINE;
     slave->repl_put_online_on_ack = 0;
@@ -969,31 +963,11 @@ void updateSlavesWaitingBgsave(int bgsaveerr, int type) {
                 serverLog(LL_NOTICE,
                     "Streamed RDB transfer with replica %s succeeded (socket). Waiting for REPLCONF ACK from slave to enable streaming",
                         replicationGetSlaveName(slave));
-                /* Note: we wait for a REPLCONF ACK message from the replica in
+                /* Note: we wait for a REPLCONF ACK message from slave in
                  * order to really put it online (install the write handler
                  * so that the accumulated data can be transferred). However
                  * we change the replication state ASAP, since our slave
-                 * is technically online now.
-                 *
-                 * So things work like that:
-                 *
-                 * 1. We end trasnferring the RDB file via socket.
-                 * 2. The replica is put ONLINE but the write handler
-                 *    is not installed.
-                 * 3. The replica however goes really online, and pings us
-                 *    back via REPLCONF ACK commands.
-                 * 4. Now we finally install the write handler, and send
-                 *    the buffers accumulated so far to the replica.
-                 *
-                 * But why we do that? Because the replica, when we stream
-                 * the RDB directly via the socket, must detect the RDB
-                 * EOF (end of file), that is a special random string at the
-                 * end of the RDB (for streamed RDBs we don't know the length
-                 * in advance). Detecting such final EOF string is much
-                 * simpler and less CPU intensive if no more data is sent
-                 * after such final EOF. So we don't want to glue the end of
-                 * the RDB trasfer with the start of the other replication
-                 * data. */
+                 * is technically online now. */
                 slave->replstate = SLAVE_STATE_ONLINE;
                 slave->repl_put_online_on_ack = 1;
                 slave->repl_ack_time = server.unixtime; /* Timeout otherwise. */
@@ -1115,23 +1089,14 @@ void replicationCreateMasterClient(int fd, int dbid) {
     if (dbid != -1) selectDb(server.master,dbid);
 }
 
-/* This function will try to re-enable the AOF file after the
- * master-replica synchronization: if it fails after multiple attempts
- * the replica cannot be considered reliable and exists with an
- * error. */
-void restartAOFAfterSYNC() {
-    unsigned int tries, max_tries = 10;
-    for (tries = 0; tries < max_tries; ++tries) {
-        if (startAppendOnly() == C_OK) break;
-        serverLog(LL_WARNING,
-            "Failed enabling the AOF after successful master synchronization! "
-            "Trying it again in one second.");
+void restartAOF() {
+    int retry = 10;
+    while (retry-- && startAppendOnly() == C_ERR) {
+        serverLog(LL_WARNING,"Failed enabling the AOF after successful master synchronization! Trying it again in one second.");
         sleep(1);
     }
-    if (tries == max_tries) {
-        serverLog(LL_WARNING,
-            "FATAL: this replica instance finished the synchronization with "
-            "its master, but the AOF can't be turned on. Exiting now.");
+    if (!retry) {
+        serverLog(LL_WARNING,"FATAL: this replica instance finished the synchronization with its master, but the AOF can't be turned on. Exiting now.");
         exit(1);
     }
 }
@@ -1280,18 +1245,6 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
     if (eof_reached) {
         int aof_is_enabled = server.aof_state != AOF_OFF;
 
-        /* Ensure background save doesn't overwrite synced data */
-        if (server.rdb_child_pid != -1) {
-            serverLog(LL_NOTICE,
-                "Replica is about to load the RDB file received from the "
-                "master, but there is a pending RDB child running. "
-                "Killing process %ld and removing its temp file to avoid "
-                "any race",
-                    (long) server.rdb_child_pid);
-            kill(server.rdb_child_pid,SIGUSR1);
-            rdbRemoveTempFile(server.rdb_child_pid);
-        }
-
         if (rename(server.repl_transfer_tmpfile,server.rdb_filename) == -1) {
             serverLog(LL_WARNING,"Failed trying to rename the temp DB into dump.rdb in MASTER <-> REPLICA synchronization: %s", strerror(errno));
             cancelReplicationHandshake();
@@ -1318,7 +1271,7 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
             cancelReplicationHandshake();
             /* Re-enable the AOF if we disabled it earlier, in order to restore
              * the original configuration. */
-            if (aof_is_enabled) restartAOFAfterSYNC();
+            if (aof_is_enabled) restartAOF();
             return;
         }
         /* Final setup of the connected slave <- master link */
@@ -1343,7 +1296,7 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
         /* Restart the AOF subsystem now that we finished the sync. This
          * will trigger an AOF rewrite, and when done will start appending
          * to the new file. */
-        if (aof_is_enabled) restartAOFAfterSYNC();
+        if (aof_is_enabled) restartAOF();
     }
     return;
 
@@ -1996,10 +1949,7 @@ void replicationSetMaster(char *ip, int port) {
     cancelReplicationHandshake();
     /* Before destroying our master state, create a cached master using
      * our own parameters, to later PSYNC with the new master. */
-    if (was_master) {
-        replicationDiscardCachedMaster();
-        replicationCacheMasterUsingMyself();
-    }
+    if (was_master) replicationCacheMasterUsingMyself();
     server.repl_state = REPL_STATE_CONNECT;
 }
 
@@ -2069,15 +2019,6 @@ void replicaofCommand(client *c) {
     } else {
         long port;
 
-        if (c->flags & CLIENT_SLAVE)
-        {
-            /* If a client is already a replica they cannot run this command,
-             * because it involves flushing all replicas (including this
-             * client) */
-            addReplyError(c, "Command is not valid when client is a replica.");
-            return;
-        }
-
         if ((getLongFromObjectOrReply(c, c->argv[2], &port, NULL) != C_OK))
             return;
 
@@ -2621,21 +2562,10 @@ void replicationCron(void) {
     if ((replication_cron_loops % server.repl_ping_slave_period) == 0 &&
         listLength(server.slaves))
     {
-        /* Note that we don't send the PING if the clients are paused during
-         * a Redis Cluster manual failover: the PING we send will otherwise
-         * alter the replication offsets of master and slave, and will no longer
-         * match the one stored into 'mf_master_offset' state. */
-        int manual_failover_in_progress =
-            server.cluster_enabled &&
-            server.cluster->mf_end &&
-            clientsArePaused();
-
-        if (!manual_failover_in_progress) {
-            ping_argv[0] = createStringObject("PING",4);
-            replicationFeedSlaves(server.slaves, server.slaveseldb,
-                ping_argv, 1);
-            decrRefCount(ping_argv[0]);
-        }
+        ping_argv[0] = createStringObject("PING",4);
+        replicationFeedSlaves(server.slaves, server.slaveseldb,
+            ping_argv, 1);
+        decrRefCount(ping_argv[0]);
     }
 
     /* Second, send a newline to all the slaves in pre-synchronization

src/scripting.c

@@ -443,11 +443,6 @@ int luaRedisGenericCommand(lua_State *lua, int raise_error) {
     c->argv = argv;
     c->argc = argc;
 
-    /* Process module hooks */
-    moduleCallCommandFilters(c);
-    argv = c->argv;
-    argc = c->argc;
-
     /* Log the command if debugging is active. */
     if (ldb.active && ldb.step) {
         sds cmdlog = sdsnew("<redis>");
@@ -565,7 +560,7 @@ int luaRedisGenericCommand(lua_State *lua, int raise_error) {
     }
 
     /* Run the command */
-    int call_flags = CMD_CALL_SLOWLOG | CMD_CALL_STATS;
+    int call_flags = CMD_CALL_SLOWLOG | CMD_CALL_STATS | CMD_CALL_NOQUEUE;
     if (server.lua_replicate_commands) {
         /* Set flags according to redis.set_repl() settings. */
         if (server.lua_repl & PROPAGATE_AOF)
@@ -1247,7 +1242,7 @@ void luaMaskCountHook(lua_State *lua, lua_Debug *ar) {
          * we need to mask the client executing the script from the event loop.
          * If we don't do that the client may disconnect and could no longer be
          * here when the EVAL command will return. */
-        protectClient(server.lua_caller);
+         aeDeleteFileEvent(server.el, server.lua_caller->fd, AE_READABLE);
     }
     if (server.lua_timedout) processEventsWhileBlocked();
     if (server.lua_kill) {
@@ -1375,9 +1370,10 @@ void evalGenericCommand(client *c, int evalsha) {
     if (delhook) lua_sethook(lua,NULL,0,0); /* Disable hook */
     if (server.lua_timedout) {
         server.lua_timedout = 0;
-        /* Restore the client that was protected when the script timeout
-         * was detected. */
-        unprotectClient(c);
+        /* Restore the readable handler that was unregistered when the
+         * script timeout was detected. */
+        aeCreateFileEvent(server.el,c->fd,AE_READABLE,
+                          readQueryFromClient,c);
         if (server.masterhost && server.master)
             queueClientForReprocessing(server.master);
     }
@@ -2213,7 +2209,6 @@ void ldbEval(lua_State *lua, sds *argv, int argc) {
             ldbLog(sdscatfmt(sdsempty(),"<error> %s",lua_tostring(lua,-1)));
             lua_pop(lua,1);
             sdsfree(code);
-            sdsfree(expr);
             return;
         }
     }

src/sds.c

@@ -257,12 +257,8 @@ sds sdsRemoveFreeSpace(sds s) {
     char type, oldtype = s[-1] & SDS_TYPE_MASK;
     int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
     size_t len = sdslen(s);
-    size_t avail = sdsavail(s);
     sh = (char*)s-oldhdrlen;
 
-    /* Return ASAP if there is no space left. */
-    if (avail == 0) return s;
-
     /* Check what would be the minimum SDS header that is just good enough to
      * fit this string. */
     type = sdsReqType(len);
@@ -699,7 +695,7 @@ sds sdscatfmt(sds s, char const *fmt, ...) {
  * s = sdstrim(s,"Aa. :");
  * printf("%s\n", s);
  *
- * Output will be just "HelloWorld".
+ * Output will be just "Hello World".
  */
 sds sdstrim(sds s, const char *cset) {
     char *start, *end, *sp, *ep;

src/sds.h

@@ -34,7 +34,7 @@
 #define __SDS_H
 
 #define SDS_MAX_PREALLOC (1024*1024)
-extern const char *SDS_NOINIT;
+const char *SDS_NOINIT;
 
 #include <sys/types.h>
 #include <stdarg.h>

src/sentinel.c

@@ -452,15 +452,13 @@ struct redisCommand sentinelcmds[] = {
     {"info",sentinelInfoCommand,-1,"",0,NULL,0,0,0,0,0},
     {"role",sentinelRoleCommand,1,"l",0,NULL,0,0,0,0,0},
     {"client",clientCommand,-2,"rs",0,NULL,0,0,0,0,0},
-    {"shutdown",shutdownCommand,-1,"",0,NULL,0,0,0,0,0},
-    {"auth",authCommand,2,"sltF",0,NULL,0,0,0,0,0}
+    {"shutdown",shutdownCommand,-1,"",0,NULL,0,0,0,0,0}
 };
 
 /* This function overwrites a few normal Redis config default with Sentinel
  * specific defaults. */
 void initSentinelConfig(void) {
     server.port = REDIS_SENTINEL_PORT;
-    server.protected_mode = 0; /* Sentinel must be exposed. */
 }
 
 /* Perform the Sentinel mode initialization. */
@@ -1943,25 +1941,12 @@ werr:
 /* Send the AUTH command with the specified master password if needed.
  * Note that for slaves the password set for the master is used.
  *
- * In case this Sentinel requires a password as well, via the "requirepass"
- * configuration directive, we assume we should use the local password in
- * order to authenticate when connecting with the other Sentinels as well.
- * So basically all the Sentinels share the same password and use it to
- * authenticate reciprocally.
- *
  * We don't check at all if the command was successfully transmitted
  * to the instance as if it fails Sentinel will detect the instance down,
  * will disconnect and reconnect the link and so forth. */
 void sentinelSendAuthIfNeeded(sentinelRedisInstance *ri, redisAsyncContext *c) {
-    char *auth_pass = NULL;
-
-    if (ri->flags & SRI_MASTER) {
-        auth_pass = ri->auth_pass;
-    } else if (ri->flags & SRI_SLAVE) {
-        auth_pass = ri->master->auth_pass;
-    } else if (ri->flags & SRI_SENTINEL) {
-        if (server.requirepass) auth_pass = server.requirepass;
-    }
+    char *auth_pass = (ri->flags & SRI_MASTER) ? ri->auth_pass :
+                                                 ri->master->auth_pass;
 
     if (auth_pass) {
         if (redisAsyncCommand(c, sentinelDiscardReplyCallback, ri, "%s %s",
@@ -4270,7 +4255,7 @@ void sentinelFailoverDetectEnd(sentinelRedisInstance *master) {
             sentinelRedisInstance *slave = dictGetVal(de);
             int retval;
 
-            if (slave->flags & (SRI_PROMOTED|SRI_RECONF_DONE|SRI_RECONF_SENT)) continue;
+            if (slave->flags & (SRI_RECONF_DONE|SRI_RECONF_SENT)) continue;
             if (slave->link->disconnected) continue;
 
             retval = sentinelSendSlaveOf(slave,

src/server.c

@@ -200,8 +200,8 @@ struct redisCommand redisCommandTable[] = {
     {"zscan",zscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
     {"zpopmin",zpopminCommand,-2,"wF",0,NULL,1,1,1,0,0},
     {"zpopmax",zpopmaxCommand,-2,"wF",0,NULL,1,1,1,0,0},
-    {"bzpopmin",bzpopminCommand,-3,"wsF",0,NULL,1,-2,1,0,0},
-    {"bzpopmax",bzpopmaxCommand,-3,"wsF",0,NULL,1,-2,1,0,0},
+    {"bzpopmin",bzpopminCommand,-2,"wsF",0,NULL,1,-2,1,0,0},
+    {"bzpopmax",bzpopmaxCommand,-2,"wsF",0,NULL,1,-2,1,0,0},
     {"hset",hsetCommand,-4,"wmF",0,NULL,1,1,1,0,0},
     {"hsetnx",hsetnxCommand,4,"wmF",0,NULL,1,1,1,0,0},
     {"hget",hgetCommand,3,"rF",0,NULL,1,1,1,0,0},
@@ -307,20 +307,19 @@ struct redisCommand redisCommandTable[] = {
     {"pfcount",pfcountCommand,-2,"r",0,NULL,1,-1,1,0,0},
     {"pfmerge",pfmergeCommand,-2,"wm",0,NULL,1,-1,1,0,0},
     {"pfdebug",pfdebugCommand,-3,"w",0,NULL,0,0,0,0,0},
-    {"xadd",xaddCommand,-5,"wmFR",0,NULL,1,1,1,0,0},
+    {"xadd",xaddCommand,-5,"wmF",0,NULL,1,1,1,0,0},
     {"xrange",xrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
     {"xrevrange",xrevrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
     {"xlen",xlenCommand,2,"rF",0,NULL,1,1,1,0,0},
     {"xread",xreadCommand,-4,"rs",0,xreadGetKeys,1,1,1,0,0},
     {"xreadgroup",xreadCommand,-7,"ws",0,xreadGetKeys,1,1,1,0,0},
     {"xgroup",xgroupCommand,-2,"wm",0,NULL,2,2,1,0,0},
-    {"xsetid",xsetidCommand,3,"wmF",0,NULL,1,1,1,0,0},
     {"xack",xackCommand,-4,"wF",0,NULL,1,1,1,0,0},
-    {"xpending",xpendingCommand,-3,"rR",0,NULL,1,1,1,0,0},
-    {"xclaim",xclaimCommand,-6,"wRF",0,NULL,1,1,1,0,0},
-    {"xinfo",xinfoCommand,-2,"rR",0,NULL,2,2,1,0,0},
+    {"xpending",xpendingCommand,-3,"r",0,NULL,1,1,1,0,0},
+    {"xclaim",xclaimCommand,-6,"wF",0,NULL,1,1,1,0,0},
+    {"xinfo",xinfoCommand,-2,"r",0,NULL,2,2,1,0,0},
     {"xdel",xdelCommand,-3,"wF",0,NULL,1,1,1,0,0},
-    {"xtrim",xtrimCommand,-2,"wFR",0,NULL,1,1,1,0,0},
+    {"xtrim",xtrimCommand,-2,"wF",0,NULL,1,1,1,0,0},
     {"post",securityWarningCommand,-1,"lt",0,NULL,0,0,0,0,0},
     {"host:",securityWarningCommand,-1,"lt",0,NULL,0,0,0,0,0},
     {"latency",latencyCommand,-2,"aslt",0,NULL,0,0,0,0,0},
@@ -779,11 +778,6 @@ void updateDictResizePolicy(void) {
         dictDisableResize();
 }
 
-int hasActiveChildProcess() {
-    return server.rdb_child_pid != -1 ||
-           server.aof_child_pid != -1;
-}
-
 /* ======================= Cron: called every 100 ms ======================== */
 
 /* Add a sample to the operations per second array of samples. */
@@ -821,7 +815,7 @@ int clientsCronHandleTimeout(client *c, mstime_t now_ms) {
     time_t now = now_ms/1000;
 
     if (server.maxidletime &&
-        !(c->flags & CLIENT_SLAVE) &&    /* no timeout for slaves and monitors */
+        !(c->flags & CLIENT_SLAVE) &&    /* no timeout for slaves */
         !(c->flags & CLIENT_MASTER) &&   /* no timeout for masters */
         !(c->flags & CLIENT_BLOCKED) &&  /* no timeout for BLPOP */
         !(c->flags & CLIENT_PUBSUB) &&   /* no timeout for Pub/Sub clients */
@@ -987,7 +981,7 @@ void clientsCron(void) {
         /* Rotate the list, take the current head, process.
          * This way if the client must be removed from the list it's the
          * first element and we don't incur into O(N) computation. */
-        listRotateTailToHead(server.clients);
+        listRotate(server.clients);
         head = listFirst(server.clients);
         c = listNodeValue(head);
         /* The following functions do different service checks on the client.
@@ -1005,12 +999,10 @@ void clientsCron(void) {
 void databasesCron(void) {
     /* Expire keys by random sampling. Not required for slaves
      * as master will synthesize DELs for us. */
-    if (server.active_expire_enabled) {
-        if (server.masterhost == NULL) {
-            activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
-        } else {
-            expireSlaveKeys();
-        }
+    if (server.active_expire_enabled && server.masterhost == NULL) {
+        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
+    } else if (server.masterhost != NULL) {
+        expireSlaveKeys();
     }
 
     /* Defrag keys gradually. */
@@ -1059,30 +1051,19 @@ void databasesCron(void) {
 /* 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
- * a lot faster than calling time(NULL).
- *
- * This function should be fast because it is called at every command execution
- * in call(), so it is possible to decide if to update the daylight saving
- * info or not using the 'update_daylight_info' argument. Normally we update
- * such info only when calling this function from serverCron() but not when
- * calling it from call(). */
-void updateCachedTime(int update_daylight_info) {
-    server.ustime = ustime();
-    server.mstime = server.ustime / 1000;
-    time_t unixtime = server.mstime / 1000;
+ * a lot faster than calling time(NULL) */
+void updateCachedTime(void) {
+    time_t unixtime = time(NULL);
     atomicSet(server.unixtime,unixtime);
+    server.mstime = mstime();
 
-    /* To get information about daylight saving time, we need to call
-     * localtime_r and cache the result. However calling localtime_r in this
-     * context is safe since we will never fork() while here, in the main
-     * thread. The logging function will call a thread safe version of
-     * localtime that has no locks. */
-    if (update_daylight_info) {
-        struct tm tm;
-        time_t ut = server.unixtime;
-        localtime_r(&ut,&tm);
-        server.daylight_active = tm.tm_isdst;
-    }
+    /* To get information about daylight saving time, we need to call localtime_r
+     * and cache the result. However calling localtime_r in this context is safe
+     * since we will never fork() while here, in the main thread. The logging
+     * function will call a thread safe version of localtime that has no locks. */
+    struct tm tm;
+    localtime_r(&server.unixtime,&tm);
+    server.daylight_active = tm.tm_isdst;
 }
 
 /* This is our timer interrupt, called server.hz times per second.
@@ -1115,7 +1096,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     if (server.watchdog_period) watchdogScheduleSignal(server.watchdog_period);
 
     /* Update the time cache. */
-    updateCachedTime(1);
+    updateCachedTime();
 
     server.hz = server.config_hz;
     /* Adapt the server.hz value to the number of configured clients. If we have
@@ -1539,15 +1520,15 @@ void initServerConfig(void) {
     pthread_mutex_init(&server.lruclock_mutex,NULL);
     pthread_mutex_init(&server.unixtime_mutex,NULL);
 
-    updateCachedTime(1);
+    updateCachedTime();
     getRandomHexChars(server.runid,CONFIG_RUN_ID_SIZE);
     server.runid[CONFIG_RUN_ID_SIZE] = '\0';
     changeReplicationId();
     clearReplicationId2();
-    server.timezone = getTimeZone(); /* Initialized by tzset(). */
+    server.timezone = timezone; /* Initialized by tzset(). */
     server.configfile = NULL;
     server.executable = NULL;
-    server.hz = server.config_hz = CONFIG_DEFAULT_HZ;
+    server.config_hz = CONFIG_DEFAULT_HZ;
     server.dynamic_hz = CONFIG_DEFAULT_DYNAMIC_HZ;
     server.arch_bits = (sizeof(long) == 8) ? 64 : 32;
     server.port = CONFIG_DEFAULT_SERVER_PORT;
@@ -1721,7 +1702,6 @@ void initServerConfig(void) {
     server.expireCommand = lookupCommandByCString("expire");
     server.pexpireCommand = lookupCommandByCString("pexpire");
     server.xclaimCommand = lookupCommandByCString("xclaim");
-    server.xgroupCommand = lookupCommandByCString("xgroup");
 
     /* Slow log */
     server.slowlog_log_slower_than = CONFIG_DEFAULT_SLOWLOG_LOG_SLOWER_THAN;
@@ -1976,13 +1956,9 @@ int listenToPort(int port, int *fds, int *count) {
         }
         if (fds[*count] == ANET_ERR) {
             serverLog(LL_WARNING,
-                "Could not create server TCP listening socket %s:%d: %s",
+                "Creating Server TCP listening socket %s:%d: %s",
                 server.bindaddr[j] ? server.bindaddr[j] : "*",
                 port, server.neterr);
-                if (errno == ENOPROTOOPT     || errno == EPROTONOSUPPORT ||
-                    errno == ESOCKTNOSUPPORT || errno == EPFNOSUPPORT ||
-                    errno == EAFNOSUPPORT    || errno == EADDRNOTAVAIL)
-                    continue;
             return C_ERR;
         }
         anetNonBlock(NULL,fds[*count]);
@@ -2043,7 +2019,6 @@ void initServer(void) {
     server.hz = server.config_hz;
     server.pid = getpid();
     server.current_client = NULL;
-    server.fixed_time_expire = 0;
     server.clients = listCreate();
     server.clients_index = raxNew();
     server.clients_to_close = listCreate();
@@ -2196,14 +2171,6 @@ void initServer(void) {
     scriptingInit(1);
     slowlogInit();
     latencyMonitorInit();
-}
-
-/* Some steps in server initialization need to be done last (after modules
- * are loaded).
- * Specifically, creation of threads due to a race bug in ld.so, in which
- * Thread Local Storage initialization collides with dlopen call.
- * see: https://sourceware.org/bugzilla/show_bug.cgi?id=19329 */
-void InitServerLast() {
     bioInit();
     server.initial_memory_usage = zmalloc_used_memory();
 }
@@ -2336,13 +2303,8 @@ struct redisCommand *lookupCommandOrOriginal(sds name) {
  * + PROPAGATE_AOF (propagate into the AOF file if is enabled)
  * + PROPAGATE_REPL (propagate into the replication link)
  *
- * This should not be used inside commands implementation since it will not
- * wrap the resulting commands in MULTI/EXEC. Use instead alsoPropagate(),
- * preventCommandPropagation(), forceCommandPropagation().
- *
- * However for functions that need to (also) propagate out of the context of a
- * command execution, for example when serving a blocked client, you
- * want to use propagate().
+ * This should not be used inside commands implementation. Use instead
+ * alsoPropagate(), preventCommandPropagation(), forceCommandPropagation().
  */
 void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
                int flags)
@@ -2444,14 +2406,11 @@ void preventCommandReplication(client *c) {
  *
  */
 void call(client *c, int flags) {
-    long long dirty;
-    ustime_t start, duration;
+    long long dirty, start, duration;
     int client_old_flags = c->flags;
     struct redisCommand *real_cmd = c->cmd;
 
-    server.fixed_time_expire++;
-
-    /* Sent the command to clients in MONITOR mode, only if the commands are
+    /* Send the command to clients in MONITOR mode, only if the commands are
      * not generated from reading an AOF. */
     if (listLength(server.monitors) &&
         !server.loading &&
@@ -2460,6 +2419,25 @@ void call(client *c, int flags) {
         replicationFeedMonitors(c,server.monitors,c->db->id,c->argv,c->argc);
     }
 
+    /* If the client is in the context of a transaction, reply with
+     * +QUEUED and just accumulate the command in the client transaction
+     * commands vector.
+     *
+     * Note that CALL_NOQUEUE can override this check and execute the command
+     * straight away even if the client is in "MULTI" state. This is useful
+     * every time we want to actually execute commands even if the client is
+     * in MULTI state, like in scripting.c or in the implementation of EXEC
+     * itself. */
+    if (!(flags & CMD_CALL_NOQUEUE) &&
+        c->flags & CLIENT_MULTI &&
+        c->cmd->proc != execCommand && c->cmd->proc != discardCommand &&
+        c->cmd->proc != multiCommand && c->cmd->proc != watchCommand)
+    {
+        queueMultiCommand(c);
+        addReply(c,shared.queued);
+        return;
+    }
+
     /* Initialization: clear the flags that must be set by the command on
      * demand, and initialize the array for additional commands propagation. */
     c->flags &= ~(CLIENT_FORCE_AOF|CLIENT_FORCE_REPL|CLIENT_PREVENT_PROP);
@@ -2468,8 +2446,7 @@ void call(client *c, int flags) {
 
     /* Call the command. */
     dirty = server.dirty;
-    updateCachedTime(0);
-    start = server.ustime;
+    start = ustime();
     c->cmd->proc(c);
     duration = ustime()-start;
     dirty = server.dirty-dirty;
@@ -2565,7 +2542,6 @@ void call(client *c, int flags) {
         redisOpArrayFree(&server.also_propagate);
     }
     server.also_propagate = prev_also_propagate;
-    server.fixed_time_expire--;
     server.stat_numcommands++;
 }
 
@@ -2578,8 +2554,6 @@ void call(client *c, int flags) {
  * other operations can be performed by the caller. Otherwise
  * if C_ERR is returned the client was destroyed (i.e. after QUIT). */
 int processCommand(client *c) {
-    moduleCallCommandFilters(c);
-
     /* The QUIT command is handled separately. Normal command procs will
      * go through checking for replication and QUIT will cause trouble
      * when FORCE_REPLICATION is enabled and would be implemented in
@@ -2646,23 +2620,24 @@ int processCommand(client *c) {
     }
 
     /* Handle the maxmemory directive.
+     *
+     * First we try to free some memory if possible (if there are volatile
+     * keys in the dataset). If there are not the only thing we can do
+     * is returning an error.
      *
      * Note that we do not want to reclaim memory if we are here re-entering
      * the event loop since there is a busy Lua script running in timeout
-     * condition, to avoid mixing the propagation of scripts with the
-     * propagation of DELs due to eviction. */
+     * condition, to avoid mixing the propagation of scripts with the propagation
+     * of DELs due to eviction. */
     if (server.maxmemory && !server.lua_timedout) {
-        int out_of_memory = freeMemoryIfNeededAndSafe() == C_ERR;
+        int out_of_memory = freeMemoryIfNeeded() == C_ERR;
         /* freeMemoryIfNeeded may flush slave output buffers. This may result
          * into a slave, that may be the active client, to be freed. */
         if (server.current_client == NULL) return C_ERR;
 
         /* It was impossible to free enough memory, and the command the client
-         * is trying to execute is denied during OOM conditions or the client
-         * is in MULTI/EXEC context? Error. */
-        if (out_of_memory &&
-            (c->cmd->flags & CMD_DENYOOM ||
-             (c->flags & CLIENT_MULTI && c->cmd->proc != execCommand))) {
+         * is trying to execute is denied during OOM conditions? Error. */
+        if ((c->cmd->flags & CMD_DENYOOM) && out_of_memory) {
             flagTransaction(c);
             addReply(c, shared.oomerr);
             return C_OK;
@@ -2758,18 +2733,9 @@ int processCommand(client *c) {
     }
 
     /* Exec the command */
-    if (c->flags & CLIENT_MULTI &&
-        c->cmd->proc != execCommand && c->cmd->proc != discardCommand &&
-        c->cmd->proc != multiCommand && c->cmd->proc != watchCommand)
-    {
-        queueMultiCommand(c);
-        addReply(c,shared.queued);
-    } else {
-        call(c,CMD_CALL_FULL);
-        c->woff = server.master_repl_offset;
-        if (listLength(server.ready_keys))
-            handleClientsBlockedOnKeys();
-    }
+    call(c,CMD_CALL_FULL);
+    c->woff = server.master_repl_offset;
+    if (listLength(server.ready_keys)) handleClientsBlockedOnKeys();
     return C_OK;
 }
 
@@ -3282,11 +3248,11 @@ sds genRedisInfoString(char *section) {
             "allocator_frag_ratio:%.2f\r\n"
             "allocator_frag_bytes:%zu\r\n"
             "allocator_rss_ratio:%.2f\r\n"
-            "allocator_rss_bytes:%zd\r\n"
+            "allocator_rss_bytes:%zu\r\n"
             "rss_overhead_ratio:%.2f\r\n"
-            "rss_overhead_bytes:%zd\r\n"
+            "rss_overhead_bytes:%zu\r\n"
             "mem_fragmentation_ratio:%.2f\r\n"
-            "mem_fragmentation_bytes:%zd\r\n"
+            "mem_fragmentation_bytes:%zu\r\n"
             "mem_not_counted_for_evict:%zu\r\n"
             "mem_replication_backlog:%zu\r\n"
             "mem_clients_slaves:%zu\r\n"
@@ -3842,7 +3808,6 @@ static void sigShutdownHandler(int sig) {
         rdbRemoveTempFile(getpid());
         exit(1); /* Exit with an error since this was not a clean shutdown. */
     } else if (server.loading) {
-        serverLogFromHandler(LL_WARNING, "Received shutdown signal during loading, exiting now.");
         exit(0);
     }
 
@@ -3899,14 +3864,12 @@ void loadDataFromDisk(void) {
                 (float)(ustime()-start)/1000000);
 
             /* Restore the replication ID / offset from the RDB file. */
-            if ((server.masterhost ||
-                (server.cluster_enabled &&
-                nodeIsSlave(server.cluster->myself))) &&
+            if (server.masterhost &&
                 rsi.repl_id_is_set &&
                 rsi.repl_offset != -1 &&
                 /* Note that older implementations may save a repl_stream_db
-                 * of -1 inside the RDB file in a wrong way, see more
-                 * information in function rdbPopulateSaveInfo. */
+                 * of -1 inside the RDB file in a wrong way, see more information
+                 * in function rdbPopulateSaveInfo. */
                 rsi.repl_stream_db != -1)
             {
                 memcpy(server.replid,rsi.repl_id,sizeof(server.replid));
@@ -4060,6 +4023,8 @@ int main(int argc, char **argv) {
             return sha1Test(argc, argv);
         } else if (!strcasecmp(argv[2], "util")) {
             return utilTest(argc, argv);
+        } else if (!strcasecmp(argv[2], "sds")) {
+            return sdsTest(argc, argv);
         } else if (!strcasecmp(argv[2], "endianconv")) {
             return endianconvTest(argc, argv);
         } else if (!strcasecmp(argv[2], "crc64")) {
@@ -4210,7 +4175,6 @@ int main(int argc, char **argv) {
         linuxMemoryWarnings();
     #endif
         moduleLoadFromQueue();
-        InitServerLast();
         loadDataFromDisk();
         if (server.cluster_enabled) {
             if (verifyClusterConfigWithData() == C_ERR) {
@@ -4225,7 +4189,6 @@ int main(int argc, char **argv) {
         if (server.sofd > 0)
             serverLog(LL_NOTICE,"The server is now ready to accept connections at %s", server.unixsocket);
     } else {
-        InitServerLast();
         sentinelIsRunning();
     }
 

src/server.h

@@ -50,7 +50,6 @@
 #include <signal.h>
 
 typedef long long mstime_t; /* millisecond time type. */
-typedef long long ustime_t; /* microsecond time type. */
 
 #include "ae.h"      /* Event driven programming library */
 #include "sds.h"     /* Dynamic safe strings */
@@ -257,7 +256,6 @@ typedef long long ustime_t; /* microsecond time type. */
 #define CLIENT_LUA_DEBUG (1<<25)  /* Run EVAL in debug mode. */
 #define CLIENT_LUA_DEBUG_SYNC (1<<26)  /* EVAL debugging without fork() */
 #define CLIENT_MODULE (1<<27) /* Non connected client used by some module. */
-#define CLIENT_PROTECTED (1<<28) /* Client should not be freed for now. */
 
 /* Client block type (btype field in client structure)
  * if CLIENT_BLOCKED flag is set. */
@@ -418,6 +416,9 @@ typedef long long ustime_t; /* microsecond time type. */
 #define CMD_CALL_PROPAGATE_REPL (1<<3)
 #define CMD_CALL_PROPAGATE (CMD_CALL_PROPAGATE_AOF|CMD_CALL_PROPAGATE_REPL)
 #define CMD_CALL_FULL (CMD_CALL_SLOWLOG | CMD_CALL_STATS | CMD_CALL_PROPAGATE)
+/* --- call() special semantics that can be requested by the caller
+ * --- but are not included in CALL_FULL. */
+#define CMD_CALL_NOQUEUE (1<<4)
 
 /* Command propagation flags, see propagate() function */
 #define PROPAGATE_NONE 0
@@ -490,10 +491,6 @@ typedef long long ustime_t; /* microsecond time type. */
 #define REDISMODULE_TYPE_ENCVER(id) (id & REDISMODULE_TYPE_ENCVER_MASK)
 #define REDISMODULE_TYPE_SIGN(id) ((id & ~((uint64_t)REDISMODULE_TYPE_ENCVER_MASK)) >>REDISMODULE_TYPE_ENCVER_BITS)
 
-/* Bit flags for moduleTypeAuxSaveFunc */
-#define REDISMODULE_AUX_BEFORE_RDB (1<<0)
-#define REDISMODULE_AUX_AFTER_RDB (1<<1)
-
 struct RedisModule;
 struct RedisModuleIO;
 struct RedisModuleDigest;
@@ -506,8 +503,6 @@ struct redisObject;
  * is deleted. */
 typedef void *(*moduleTypeLoadFunc)(struct RedisModuleIO *io, int encver);
 typedef void (*moduleTypeSaveFunc)(struct RedisModuleIO *io, void *value);
-typedef int (*moduleTypeAuxLoadFunc)(struct RedisModuleIO *rdb, int encver, int when);
-typedef void (*moduleTypeAuxSaveFunc)(struct RedisModuleIO *rdb, int when);
 typedef void (*moduleTypeRewriteFunc)(struct RedisModuleIO *io, struct redisObject *key, void *value);
 typedef void (*moduleTypeDigestFunc)(struct RedisModuleDigest *digest, void *value);
 typedef size_t (*moduleTypeMemUsageFunc)(const void *value);
@@ -524,9 +519,6 @@ typedef struct RedisModuleType {
     moduleTypeMemUsageFunc mem_usage;
     moduleTypeDigestFunc digest;
     moduleTypeFreeFunc free;
-    moduleTypeAuxLoadFunc aux_load;
-    moduleTypeAuxSaveFunc aux_save;
-    int aux_save_triggers;
     char name[10]; /* 9 bytes name + null term. Charset: A-Z a-z 0-9 _- */
 } moduleType;
 
@@ -561,18 +553,16 @@ typedef struct RedisModuleIO {
     int ver;            /* Module serialization version: 1 (old),
                          * 2 (current version with opcodes annotation). */
     struct RedisModuleCtx *ctx; /* Optional context, see RM_GetContextFromIO()*/
-    struct redisObject *key;    /* Optional name of key processed */
 } RedisModuleIO;
 
 /* Macro to initialize an IO context. Note that the 'ver' field is populated
  * inside rdb.c according to the version of the value to load. */
-#define moduleInitIOContext(iovar,mtype,rioptr,keyptr) do { \
+#define moduleInitIOContext(iovar,mtype,rioptr) do { \
     iovar.rio = rioptr; \
     iovar.type = mtype; \
     iovar.bytes = 0; \
     iovar.error = 0; \
     iovar.ver = 0; \
-    iovar.key = keyptr; \
     iovar.ctx = NULL; \
 } while(0);
 
@@ -666,9 +656,6 @@ typedef struct multiCmd {
 typedef struct multiState {
     multiCmd *commands;     /* Array of MULTI commands */
     int count;              /* Total number of MULTI commands */
-    int cmd_flags;          /* The accumulated command flags OR-ed together.
-                               So if at least a command has a given flag, it
-                               will be set in this field. */
     int minreplicas;        /* MINREPLICAS for synchronous replication */
     time_t minreplicas_timeout; /* MINREPLICAS timeout as unixtime. */
 } multiState;
@@ -749,7 +736,7 @@ typedef struct client {
     int flags;              /* Client flags: CLIENT_* macros. */
     int authenticated;      /* When requirepass is non-NULL. */
     int replstate;          /* Replication state if this is a slave. */
-    int repl_put_online_on_ack; /* Install slave write handler on first ACK. */
+    int repl_put_online_on_ack; /* Install slave write handler on ACK. */
     int repldbfd;           /* Replication DB file descriptor. */
     off_t repldboff;        /* Replication DB file offset. */
     off_t repldbsize;       /* Replication DB file size. */
@@ -879,11 +866,11 @@ struct redisMemOverhead {
     float dataset_perc;
     float peak_perc;
     float total_frag;
-    ssize_t total_frag_bytes;
+    size_t total_frag_bytes;
     float allocator_frag;
-    ssize_t allocator_frag_bytes;
+    size_t allocator_frag_bytes;
     float allocator_rss;
-    ssize_t allocator_rss_bytes;
+    size_t allocator_rss_bytes;
     float rss_extra;
     size_t rss_extra_bytes;
     size_t num_dbs;
@@ -966,9 +953,7 @@ struct redisServer {
     size_t initial_memory_usage; /* Bytes used after initialization. */
     int always_show_logo;       /* Show logo even for non-stdout logging. */
     /* Modules */
-    dict *moduleapi;            /* Exported core APIs dictionary for modules. */
-    dict *sharedapi;            /* Like moduleapi but containing the APIs that
-                                   modules share with each other. */
+    dict *moduleapi;            /* Exported APIs dictionary for modules. */
     list *loadmodule_queue;     /* List of modules to load at startup. */
     int module_blocked_pipe[2]; /* Pipe used to awake the event loop if a
                                    client blocked on a module command needs
@@ -989,8 +974,7 @@ struct redisServer {
     list *clients_to_close;     /* Clients to close asynchronously */
     list *clients_pending_write; /* There is to write or install handler. */
     list *slaves, *monitors;    /* List of slaves and MONITORs */
-    client *current_client;     /* Current client executing the command. */
-    long fixed_time_expire;     /* If > 0, expire keys against server.mstime. */
+    client *current_client; /* Current client, only used on crash report */
     rax *clients_index;         /* Active clients dictionary by client ID. */
     int clients_paused;         /* True if clients are currently paused */
     mstime_t clients_pause_end_time; /* Time when we undo clients_paused */
@@ -1008,8 +992,7 @@ struct redisServer {
     struct redisCommand *delCommand, *multiCommand, *lpushCommand,
                         *lpopCommand, *rpopCommand, *zpopminCommand,
                         *zpopmaxCommand, *sremCommand, *execCommand,
-                        *expireCommand, *pexpireCommand, *xclaimCommand,
-                        *xgroupCommand;
+                        *expireCommand, *pexpireCommand, *xclaimCommand;
     /* Fields used only for stats */
     time_t stat_starttime;          /* Server start time */
     long long stat_numcommands;     /* Number of processed commands */
@@ -1076,7 +1059,6 @@ struct redisServer {
     off_t aof_rewrite_min_size;     /* the AOF file is at least N bytes. */
     off_t aof_rewrite_base_size;    /* AOF size on latest startup or rewrite. */
     off_t aof_current_size;         /* AOF current size. */
-    off_t aof_fsync_offset;         /* AOF offset which is already synced to disk. */
     int aof_rewrite_scheduled;      /* Rewrite once BGSAVE terminates. */
     pid_t aof_child_pid;            /* PID if rewriting process */
     list *aof_rewrite_buf_blocks;   /* Hold changes during an AOF rewrite. */
@@ -1233,8 +1215,7 @@ struct redisServer {
     time_t unixtime;    /* Unix time sampled every cron cycle. */
     time_t timezone;    /* Cached timezone. As set by tzset(). */
     int daylight_active;    /* Currently in daylight saving time. */
-    mstime_t mstime;            /* 'unixtime' in milliseconds. */
-    ustime_t ustime;            /* 'unixtime' in microseconds. */
+    long long mstime;   /* Like 'unixtime' but with milliseconds resolution. */
     /* Pubsub */
     dict *pubsub_channels;  /* Map channels to list of subscribed clients */
     list *pubsub_patterns;  /* A list of pubsub_patterns */
@@ -1422,8 +1403,7 @@ size_t moduleCount(void);
 void moduleAcquireGIL(void);
 void moduleReleaseGIL(void);
 void moduleNotifyKeyspaceEvent(int type, const char *event, robj *key, int dbid);
-void moduleCallCommandFilters(client *c);
-ssize_t rdbSaveModulesAux(rio *rdb, int when);
+
 
 /* Utils */
 long long ustime(void);
@@ -1451,7 +1431,6 @@ void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 void acceptUnixHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask);
 void addReplyString(client *c, const char *s, size_t len);
-void AddReplyFromClient(client *c, client *src);
 void addReplyBulk(client *c, robj *obj);
 void addReplyBulkCString(client *c, const char *s);
 void addReplyBulkCBuffer(client *c, const void *p, size_t len);
@@ -1497,8 +1476,6 @@ int clientHasPendingReplies(client *c);
 void unlinkClient(client *c);
 int writeToClient(int fd, client *c, int handler_installed);
 void linkClient(client *c);
-void protectClient(client *c);
-void unprotectClient(client *c);
 
 #ifdef __GNUC__
 void addReplyErrorFormat(client *c, const char *fmt, ...)
@@ -1583,7 +1560,6 @@ int compareStringObjects(robj *a, robj *b);
 int collateStringObjects(robj *a, robj *b);
 int equalStringObjects(robj *a, robj *b);
 unsigned long long estimateObjectIdleTime(robj *o);
-void trimStringObjectIfNeeded(robj *o);
 #define sdsEncodedObject(objptr) (objptr->encoding == OBJ_ENCODING_RAW || objptr->encoding == OBJ_ENCODING_EMBSTR)
 
 /* Synchronous I/O with timeout */
@@ -1653,7 +1629,6 @@ void openChildInfoPipe(void);
 void closeChildInfoPipe(void);
 void sendChildInfo(int process_type);
 void receiveChildInfo(void);
-int hasActiveChildProcess();
 
 /* Sorted sets data type */
 
@@ -1723,7 +1698,6 @@ int zslLexValueLteMax(sds value, zlexrangespec *spec);
 int getMaxmemoryState(size_t *total, size_t *logical, size_t *tofree, float *level);
 size_t freeMemoryGetNotCountedMemory();
 int freeMemoryIfNeeded(void);
-int freeMemoryIfNeededAndSafe(void);
 int processCommand(client *c);
 void setupSignalHandlers(void);
 struct redisCommand *lookupCommand(sds name);
@@ -1732,8 +1706,6 @@ struct redisCommand *lookupCommandOrOriginal(sds name);
 void call(client *c, int flags);
 void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc, int flags);
 void alsoPropagate(struct redisCommand *cmd, int dbid, robj **argv, int argc, int target);
-void redisOpArrayInit(redisOpArray *oa);
-void redisOpArrayFree(redisOpArray *oa);
 void forceCommandPropagation(client *c, int flags);
 void preventCommandPropagation(client *c);
 void preventCommandAOF(client *c);
@@ -1754,7 +1726,7 @@ void populateCommandTable(void);
 void resetCommandTableStats(void);
 void adjustOpenFilesLimit(void);
 void closeListeningSockets(int unlink_unix_socket);
-void updateCachedTime(int update_daylight_info);
+void updateCachedTime(void);
 void resetServerStats(void);
 void activeDefragCycle(void);
 unsigned int getLRUClock(void);
@@ -2138,7 +2110,6 @@ void xrevrangeCommand(client *c);
 void xlenCommand(client *c);
 void xreadCommand(client *c);
 void xgroupCommand(client *c);
-void xsetidCommand(client *c);
 void xackCommand(client *c);
 void xpendingCommand(client *c);
 void xclaimCommand(client *c);

src/setproctitle.c

@@ -39,7 +39,7 @@
 #include <errno.h>	/* errno program_invocation_name program_invocation_short_name */
 
 #if !defined(HAVE_SETPROCTITLE)
-#if (defined __NetBSD__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __DragonFly__)
+#if (defined __NetBSD__ || defined __FreeBSD__ || defined __OpenBSD__)
 #define HAVE_SETPROCTITLE 1
 #else
 #define HAVE_SETPROCTITLE 0

src/stream.h

@@ -109,6 +109,5 @@ streamCG *streamCreateCG(stream *s, char *name, size_t namelen, streamID *id);
 streamNACK *streamCreateNACK(streamConsumer *consumer);
 void streamDecodeID(void *buf, streamID *id);
 int streamCompareID(streamID *a, streamID *b);
-void streamIncrID(streamID *id);
 
 #endif

src/t_hash.c

@@ -615,10 +615,6 @@ void hincrbyfloatCommand(client *c) {
     }
 
     value += incr;
-    if (isnan(value) || isinf(value)) {
-        addReplyError(c,"increment would produce NaN or Infinity");
-        return;
-    }
 
     char buf[MAX_LONG_DOUBLE_CHARS];
     int len = ld2string(buf,sizeof(buf),value,1);

src/t_list.c

@@ -520,7 +520,7 @@ void lremCommand(client *c) {
 
     if (removed) {
         signalModifiedKey(c->db,c->argv[1]);
-        notifyKeyspaceEvent(NOTIFY_LIST,"lrem",c->argv[1],c->db->id);
+        notifyKeyspaceEvent(NOTIFY_GENERIC,"lrem",c->argv[1],c->db->id);
     }
 
     if (listTypeLength(subject) == 0) {
@@ -617,7 +617,7 @@ void rpoplpushCommand(client *c) {
  *    the AOF and replication channel.
  *
  * The argument 'where' is LIST_TAIL or LIST_HEAD, and indicates if the
- * 'value' element was popped from the head (BLPOP) or tail (BRPOP) so that
+ * 'value' element was popped fron the head (BLPOP) or tail (BRPOP) so that
  * we can propagate the command properly.
  *
  * The function returns C_OK if we are able to serve the client, otherwise

src/t_stream.c

@@ -67,21 +67,6 @@ void freeStream(stream *s) {
     zfree(s);
 }
 
-/* Set 'id' to be its successor streamID */
-void streamIncrID(streamID *id) {
-    if (id->seq == UINT64_MAX) {
-        if (id->ms == UINT64_MAX) {
-            /* Special case where 'id' is the last possible streamID... */
-            id->ms = id->seq = 0;
-        } else {
-            id->ms++;
-            id->seq = 0;
-        }
-    } else {
-        id->seq++;
-    }
-}
-
 /* Generate the next stream item ID given the previous one. If the current
  * milliseconds Unix time is greater than the previous one, just use this
  * as time part and start with sequence part of zero. Otherwise we use the
@@ -92,8 +77,8 @@ void streamNextID(streamID *last_id, streamID *new_id) {
         new_id->ms = ms;
         new_id->seq = 0;
     } else {
-        *new_id = *last_id;
-        streamIncrID(new_id);
+        new_id->ms = last_id->ms;
+        new_id->seq = last_id->seq+1;
     }
 }
 
@@ -188,19 +173,9 @@ int streamCompareID(streamID *a, streamID *b) {
  * C_ERR if an ID was given via 'use_id', but adding it failed since the
  * current top ID is greater or equal. */
 int streamAppendItem(stream *s, robj **argv, int64_t numfields, streamID *added_id, streamID *use_id) {
-    
-    /* Generate the new entry ID. */
-    streamID id;
-    if (use_id)
-        id = *use_id;
-    else
-        streamNextID(&s->last_id,&id);
-
-    /* Check that the new ID is greater than the last entry ID
-     * or return an error. Automatically generated IDs might
-     * overflow (and wrap-around) when incrementing the sequence 
-       part. */
-    if (streamCompareID(&id,&s->last_id) <= 0) return C_ERR;
+    /* If an ID was given, check that it's greater than the last entry ID
+     * or return an error. */
+    if (use_id && streamCompareID(use_id,&s->last_id) <= 0) return C_ERR;
 
     /* Add the new entry. */
     raxIterator ri;
@@ -217,6 +192,13 @@ int streamAppendItem(stream *s, robj **argv, int64_t numfields, streamID *added_
     }
     raxStop(&ri);
 
+    /* Generate the new entry ID. */
+    streamID id;
+    if (use_id)
+        id = *use_id;
+    else
+        streamNextID(&s->last_id,&id);
+
     /* We have to add the key into the radix tree in lexicographic order,
      * to do so we consider the ID as a single 128 bit number written in
      * big endian, so that the most significant bytes are the first ones. */
@@ -260,17 +242,17 @@ int streamAppendItem(stream *s, robj **argv, int64_t numfields, streamID *added_
      * the current node is full. */
     if (lp != NULL) {
         if (server.stream_node_max_bytes &&
-            lp_bytes >= server.stream_node_max_bytes)
+            lp_bytes > server.stream_node_max_bytes)
         {
             lp = NULL;
         } else if (server.stream_node_max_entries) {
             int64_t count = lpGetInteger(lpFirst(lp));
-            if (count >= server.stream_node_max_entries) lp = NULL;
+            if (count > server.stream_node_max_entries) lp = NULL;
         }
     }
 
     int flags = STREAM_ITEM_FLAG_NONE;
-    if (lp == NULL || lp_bytes >= server.stream_node_max_bytes) {
+    if (lp == NULL || lp_bytes > server.stream_node_max_bytes) {
         master_id = id;
         streamEncodeID(rax_key,&id);
         /* Create the listpack having the master entry ID and fields. */
@@ -510,14 +492,14 @@ void streamIteratorStart(streamIterator *si, stream *s, streamID *start, streamI
         streamEncodeID(si->start_key,start);
     } else {
         si->start_key[0] = 0;
-        si->start_key[1] = 0;
+        si->start_key[0] = 0;
     }
 
     if (end) {
         streamEncodeID(si->end_key,end);
     } else {
         si->end_key[0] = UINT64_MAX;
-        si->end_key[1] = UINT64_MAX;
+        si->end_key[0] = UINT64_MAX;
     }
 
     /* Seek the correct node in the radix tree. */
@@ -791,22 +773,12 @@ int streamDeleteItem(stream *s, streamID *id) {
     return deleted;
 }
 
-/* Get the last valid (non-tombstone) streamID of 's'. */
-void streamLastValidID(stream *s, streamID *maxid)
-{
-    streamIterator si;
-    streamIteratorStart(&si,s,NULL,NULL,1);
-    int64_t numfields;
-    streamIteratorGetID(&si,maxid,&numfields);
-    streamIteratorStop(&si);
-}
-
 /* Emit a reply in the client output buffer by formatting a Stream ID
  * in the standard <ms>-<seq> format, using the simple string protocol
  * of REPL. */
 void addReplyStreamID(client *c, streamID *id) {
-    sds replyid = sdscatfmt(sdsempty(),"%U-%U",id->ms,id->seq);
-    addReplyBulkSds(c,replyid);
+    sds replyid = sdscatfmt(sdsempty(),"+%U-%U\r\n",id->ms,id->seq);
+    addReplySds(c,replyid);
 }
 
 /* Similar to the above function, but just creates an object, usually useful
@@ -819,18 +791,18 @@ robj *createObjectFromStreamID(streamID *id) {
 /* As a result of an explicit XCLAIM or XREADGROUP command, new entries
  * are created in the pending list of the stream and consumers. We need
  * to propagate this changes in the form of XCLAIM commands. */
-void streamPropagateXCLAIM(client *c, robj *key, streamCG *group, robj *groupname, robj *id, streamNACK *nack) {
+void streamPropagateXCLAIM(client *c, robj *key, robj *group, robj *id, streamNACK *nack) {
     /* We need to generate an XCLAIM that will work in a idempotent fashion:
      *
      * XCLAIM <key> <group> <consumer> 0 <id> TIME <milliseconds-unix-time>
-     *        RETRYCOUNT <count> FORCE JUSTID LASTID <id>.
+     *        RETRYCOUNT <count> FORCE JUSTID.
      *
      * Note that JUSTID is useful in order to avoid that XCLAIM will do
      * useless work in the slave side, trying to fetch the stream item. */
-    robj *argv[14];
+    robj *argv[12];
     argv[0] = createStringObject("XCLAIM",6);
     argv[1] = key;
-    argv[2] = groupname;
+    argv[2] = group;
     argv[3] = createStringObject(nack->consumer->name,sdslen(nack->consumer->name));
     argv[4] = createStringObjectFromLongLong(0);
     argv[5] = id;
@@ -840,9 +812,7 @@ void streamPropagateXCLAIM(client *c, robj *key, streamCG *group, robj *groupnam
     argv[9] = createStringObjectFromLongLong(nack->delivery_count);
     argv[10] = createStringObject("FORCE",5);
     argv[11] = createStringObject("JUSTID",6);
-    argv[12] = createStringObject("LASTID",6);
-    argv[13] = createObjectFromStreamID(&group->last_id);
-    propagate(server.xclaimCommand,c->db->id,argv,14,PROPAGATE_AOF|PROPAGATE_REPL);
+    propagate(server.xclaimCommand,c->db->id,argv,12,PROPAGATE_AOF|PROPAGATE_REPL);
     decrRefCount(argv[0]);
     decrRefCount(argv[3]);
     decrRefCount(argv[4]);
@@ -852,38 +822,13 @@ void streamPropagateXCLAIM(client *c, robj *key, streamCG *group, robj *groupnam
     decrRefCount(argv[9]);
     decrRefCount(argv[10]);
     decrRefCount(argv[11]);
-    decrRefCount(argv[12]);
-    decrRefCount(argv[13]);
 }
 
-/* We need this when we want to propoagate the new last-id of a consumer group
- * that was consumed by XREADGROUP with the NOACK option: in that case we can't
- * propagate the last ID just using the XCLAIM LASTID option, so we emit
- *
- *  XGROUP SETID <key> <groupname> <id>
- */
-void streamPropagateGroupID(client *c, robj *key, streamCG *group, robj *groupname) {
-    robj *argv[5];
-    argv[0] = createStringObject("XGROUP",6);
-    argv[1] = createStringObject("SETID",5);
-    argv[2] = key;
-    argv[3] = groupname;
-    argv[4] = createObjectFromStreamID(&group->last_id);
-    alsoPropagate(server.xgroupCommand,c->db->id,argv,5,PROPAGATE_AOF|PROPAGATE_REPL);
-    decrRefCount(argv[0]);
-    decrRefCount(argv[1]);
-    decrRefCount(argv[4]);
-}
-
-/* Send the stream items in the specified range to the client 'c'. The range
- * the client will receive is between start and end inclusive, if 'count' is
- * non zero, no more than 'count' elements are sent.
- *
- * The 'end' pointer can be NULL to mean that we want all the elements from
- * 'start' till the end of the stream. If 'rev' is non zero, elements are
- * produced in reversed order from end to start.
- *
- * The function returns the number of entries emitted.
+/* Send the specified range to the client 'c'. The range the client will
+ * receive is between start and end inclusive, if 'count' is non zero, no more
+ * than 'count' elemnets are sent. The 'end' pointer can be NULL to mean that
+ * we want all the elements from 'start' till the end of the stream. If 'rev'
+ * is non zero, elements are produced in reversed order from end to start.
  *
  * If group and consumer are not NULL, the function performs additional work:
  * 1. It updates the last delivered ID in the group in case we are
@@ -922,21 +867,22 @@ void streamPropagateGroupID(client *c, robj *key, streamCG *group, robj *groupna
 #define STREAM_RWR_NOACK (1<<0)         /* Do not create entries in the PEL. */
 #define STREAM_RWR_RAWENTRIES (1<<1)    /* Do not emit protocol for array
                                            boundaries, just the entries. */
-#define STREAM_RWR_HISTORY (1<<2)       /* Only serve consumer local PEL. */
 size_t streamReplyWithRange(client *c, stream *s, streamID *start, streamID *end, size_t count, int rev, streamCG *group, streamConsumer *consumer, int flags, streamPropInfo *spi) {
     void *arraylen_ptr = NULL;
     size_t arraylen = 0;
     streamIterator si;
     int64_t numfields;
     streamID id;
-    int propagate_last_id = 0;
 
-    /* If the client is asking for some history, we serve it using a
-     * different function, so that we return entries *solely* from its
-     * own PEL. This ensures each consumer will always and only see
-     * the history of messages delivered to it and not yet confirmed
+    /* If a group was passed, we check if the request is about messages
+     * never delivered so far (normally this happens when ">" ID is passed).
+     *
+     * If instead the client is asking for some history, we serve it
+     * using a different function, so that we return entries *solely*
+     * from its own PEL. This ensures each consumer will always and only
+     * see the history of messages delivered to it and not yet confirmed
      * as delivered. */
-    if (group && (flags & STREAM_RWR_HISTORY)) {
+    if (group && streamCompareID(start,&group->last_id) <= 0) {
         return streamReplyWithRangeFromConsumerPEL(c,s,start,end,count,
                                                    consumer);
     }
@@ -946,10 +892,8 @@ size_t streamReplyWithRange(client *c, stream *s, streamID *start, streamID *end
     streamIteratorStart(&si,s,start,end,rev);
     while(streamIteratorGetID(&si,&id,&numfields)) {
         /* Update the group last_id if needed. */
-        if (group && streamCompareID(&id,&group->last_id) > 0) {
+        if (group && streamCompareID(&id,&group->last_id) > 0)
             group->last_id = id;
-            propagate_last_id = 1;
-        }
 
         /* Emit a two elements array for each item. The first is
          * the ID, the second is an array of field-value pairs. */
@@ -1009,12 +953,9 @@ size_t streamReplyWithRange(client *c, stream *s, streamID *start, streamID *end
             /* Propagate as XCLAIM. */
             if (spi) {
                 robj *idarg = createObjectFromStreamID(&id);
-                streamPropagateXCLAIM(c,spi->keyname,group,spi->groupname,idarg,nack);
+                streamPropagateXCLAIM(c,spi->keyname,spi->groupname,idarg,nack);
                 decrRefCount(idarg);
             }
-        } else {
-            if (propagate_last_id)
-                streamPropagateGroupID(c,spi->keyname,group,spi->groupname);
         }
 
         arraylen++;
@@ -1053,7 +994,7 @@ size_t streamReplyWithRangeFromConsumerPEL(client *c, stream *s, streamID *start
         if (end && memcmp(ri.key,end,ri.key_len) > 0) break;
         streamID thisid;
         streamDecodeID(ri.key,&thisid);
-        if (streamReplyWithRange(c,s,&thisid,&thisid,1,0,NULL,NULL,
+        if (streamReplyWithRange(c,s,&thisid,NULL,1,0,NULL,NULL,
                                  STREAM_RWR_RAWENTRIES,NULL) == 0)
         {
             /* Note that we may have a not acknowledged entry in the PEL
@@ -1244,27 +1185,12 @@ void xaddCommand(client *c) {
         return;
     }
 
-    /* Return ASAP if minimal ID (0-0) was given so we avoid possibly creating
-     * a new stream and have streamAppendItem fail, leaving an empty key in the
-     * database. */
-    if (id_given && id.ms == 0 && id.seq == 0) {
-        addReplyError(c,"The ID specified in XADD must be greater than 0-0");
-        return;
-    }
-
     /* Lookup the stream at key. */
     robj *o;
     stream *s;
     if ((o = streamTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
     s = o->ptr;
 
-    /* Return ASAP if the stream has reached the last possible ID */
-    if (s->last_id.ms == UINT64_MAX && s->last_id.seq == UINT64_MAX) {
-        addReplyError(c,"The stream has exhausted the last possible ID, "
-                        "unable to add more items");
-        return;
-    }
-
     /* Append using the low level function and return the ID. */
     if (streamAppendItem(s,c->argv+field_pos,(c->argc-field_pos)/2,
         &id, id_given ? &id : NULL)
@@ -1305,7 +1231,7 @@ void xrangeGenericCommand(client *c, int rev) {
     robj *o;
     stream *s;
     streamID startid, endid;
-    long long count = -1;
+    long long count = 0;
     robj *startarg = rev ? c->argv[3] : c->argv[2];
     robj *endarg = rev ? c->argv[2] : c->argv[3];
 
@@ -1332,13 +1258,7 @@ void xrangeGenericCommand(client *c, int rev) {
     if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptymultibulk)) == NULL
         || checkType(c,o,OBJ_STREAM)) return;
     s = o->ptr;
-
-    if (count == 0) {
-        addReply(c,shared.nullmultibulk);
-    } else {
-        if (count == -1) count = 0;
-        streamReplyWithRange(c,s,&startid,&endid,count,rev,NULL,NULL,0,NULL);
-    }
+    streamReplyWithRange(c,s,&startid,&endid,count,rev,NULL,NULL,0,NULL);
 }
 
 /* XRANGE key start end [COUNT <n>] */
@@ -1515,10 +1435,8 @@ void xreadCommand(client *c) {
         stream *s = o->ptr;
         streamID *gt = ids+i; /* ID must be greater than this. */
         int serve_synchronously = 0;
-        int serve_history = 0; /* True for XREADGROUP with ID != ">". */
 
-        /* Check if there are the conditions to serve the client
-         * synchronously. */
+        /* Check if there are the conditions to serve the client synchronously. */
         if (groups) {
             /* If the consumer is blocked on a group, we always serve it
              * synchronously (serving its local history) if the ID specified
@@ -1527,24 +1445,20 @@ void xreadCommand(client *c) {
                 gt->seq != UINT64_MAX)
             {
                 serve_synchronously = 1;
-                serve_history = 1;
-            } else if (s->length) {
+            } else {
                 /* We also want to serve a consumer in a consumer group
                  * synchronously in case the group top item delivered is smaller
                  * than what the stream has inside. */
-                streamID maxid, *last = &groups[i]->last_id;
-                streamLastValidID(s, &maxid);
-                if (streamCompareID(&maxid, last) > 0) {
+                streamID *last = &groups[i]->last_id;
+                if (s->length && (streamCompareID(&s->last_id, last) > 0)) {
                     serve_synchronously = 1;
                     *gt = *last;
                 }
             }
-        } else if (s->length) {
+        } else {
             /* For consumers without a group, we serve synchronously if we can
              * actually provide at least one item from the stream. */
-            streamID maxid;
-            streamLastValidID(s, &maxid);
-            if (streamCompareID(&maxid, gt) > 0) {
+            if (s->length && (streamCompareID(&s->last_id, gt) > 0)) {
                 serve_synchronously = 1;
             }
         }
@@ -1556,7 +1470,7 @@ void xreadCommand(client *c) {
              * so start from the next ID, since we want only messages with
              * IDs greater than start. */
             streamID start = *gt;
-            streamIncrID(&start);
+            start.seq++; /* uint64_t can't overflow in this context. */
 
             /* Emit the two elements sub-array consisting of the name
              * of the stream and the data we extracted from it. */
@@ -1566,12 +1480,9 @@ void xreadCommand(client *c) {
             if (groups) consumer = streamLookupConsumer(groups[i],
                                                         consumername->ptr,1);
             streamPropInfo spi = {c->argv[i+streams_arg],groupname};
-            int flags = 0;
-            if (noack) flags |= STREAM_RWR_NOACK;
-            if (serve_history) flags |= STREAM_RWR_HISTORY;
             streamReplyWithRange(c,s,&start,NULL,count,0,
                                  groups ? groups[i] : NULL,
-                                 consumer, flags, &spi);
+                                 consumer, noack, &spi);
             if (groups) server.dirty++;
         }
     }
@@ -1743,14 +1654,13 @@ uint64_t streamDelConsumer(streamCG *cg, sds name) {
  * Consumer groups commands
  * ----------------------------------------------------------------------- */
 
-/* XGROUP CREATE <key> <groupname> <id or $> [MKSTREAM]
+/* XGROUP CREATE <key> <groupname> <id or $>
  * XGROUP SETID <key> <groupname> <id or $>
  * XGROUP DESTROY <key> <groupname>
  * XGROUP DELCONSUMER <key> <groupname> <consumername> */
 void xgroupCommand(client *c) {
     const char *help[] = {
-"CREATE      <key> <groupname> <id or $> [opt] -- Create a new consumer group.",
-"            option MKSTREAM: create the empty stream if it does not exist.",
+"CREATE      <key> <groupname> <id or $>  -- Create a new consumer group.",
 "SETID       <key> <groupname> <id or $>  -- Set the current group ID.",
 "DESTROY     <key> <groupname>            -- Remove the specified group.",
 "DELCONSUMER <key> <groupname> <consumer> -- Remove the specified consumer.",
@@ -1761,40 +1671,13 @@ NULL
     sds grpname = NULL;
     streamCG *cg = NULL;
     char *opt = c->argv[1]->ptr; /* Subcommand name. */
-    int mkstream = 0;
-    robj *o;
 
-    /* CREATE has an MKSTREAM option that creates the stream if it
-     * does not exist. */
-    if (c->argc == 6 && !strcasecmp(opt,"CREATE")) {
-        if (strcasecmp(c->argv[5]->ptr,"MKSTREAM")) {
-            addReplySubcommandSyntaxError(c);
-            return;
-        }
-        mkstream = 1;
-        grpname = c->argv[3]->ptr;
-    }
-
-    /* Everything but the "HELP" option requires a key and group name. */
+    /* Lookup the key now, this is common for all the subcommands but HELP. */
     if (c->argc >= 4) {
-        o = lookupKeyWrite(c->db,c->argv[2]);
-        if (o) {
-            if (checkType(c,o,OBJ_STREAM)) return;
-            s = o->ptr;
-        }
+        robj *o = lookupKeyWriteOrReply(c,c->argv[2],shared.nokeyerr);
+        if (o == NULL || checkType(c,o,OBJ_STREAM)) return;
+        s = o->ptr;
         grpname = c->argv[3]->ptr;
-    }
-
-    /* Check for missing key/group. */
-    if (c->argc >= 4 && !mkstream) {
-        /* At this point key must exist, or there is an error. */
-        if (s == NULL) {
-            addReplyError(c,
-                "The XGROUP subcommand requires the key to exist. "
-                "Note that for CREATE you may want to use the MKSTREAM "
-                "option to create an empty stream automatically.");
-            return;
-        }
 
         /* Certain subcommands require the group to exist. */
         if ((cg = streamLookupCG(s,grpname)) == NULL &&
@@ -1809,27 +1692,13 @@ NULL
     }
 
     /* Dispatch the different subcommands. */
-    if (!strcasecmp(opt,"CREATE") && (c->argc == 5 || c->argc == 6)) {
+    if (!strcasecmp(opt,"CREATE") && c->argc == 5) {
         streamID id;
         if (!strcmp(c->argv[4]->ptr,"$")) {
-            if (s) {
-                id = s->last_id;
-            } else {
-                id.ms = 0;
-                id.seq = 0;
-            }
+            id = s->last_id;
         } else if (streamParseStrictIDOrReply(c,c->argv[4],&id,0) != C_OK) {
             return;
         }
-
-        /* Handle the MKSTREAM option now that the command can no longer fail. */
-        if (s == NULL) {
-            serverAssert(mkstream);
-            o = createStreamObject();
-            dbAdd(c->db,c->argv[2],o);
-            s = o->ptr;
-        }
-
         streamCG *cg = streamCreateCG(s,grpname,sdslen(grpname),&id);
         if (cg) {
             addReply(c,shared.ok);
@@ -1877,36 +1746,6 @@ NULL
     }
 }
 
-/* XSETID <stream> <groupname> <id>
- *
- * Set the internal "last ID" of a stream. */
-void xsetidCommand(client *c) {
-    robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr);
-    if (o == NULL || checkType(c,o,OBJ_STREAM)) return;
-
-    stream *s = o->ptr;
-    streamID id;
-    if (streamParseStrictIDOrReply(c,c->argv[2],&id,0) != C_OK) return;
-
-    /* If the stream has at least one item, we want to check that the user
-     * is setting a last ID that is equal or greater than the current top
-     * item, otherwise the fundamental ID monotonicity assumption is violated. */
-    if (s->length > 0) {
-        streamID maxid;
-        streamLastValidID(s,&maxid);
-
-        if (streamCompareID(&id,&maxid) < 0) {
-            addReplyError(c,"The ID specified in XSETID is smaller than the "
-                            "target stream top item");
-            return;
-        }
-    }
-    s->last_id = id;
-    addReply(c,shared.ok);
-    server.dirty++;
-    notifyKeyspaceEvent(NOTIFY_STREAM,"xsetid",c->argv[1],c->db->id);
-}
-
 /* XACK <key> <group> <id> <id> ... <id>
  *
  * Acknowledge a message as processed. In practical terms we just check the
@@ -1952,7 +1791,7 @@ void xackCommand(client *c) {
     addReplyLongLong(c,acknowledged);
 }
 
-/* XPENDING <key> <group> [<start> <stop> <count> [<consumer>]]
+/* XPENDING <key> <group> [<start> <stop> <count>] [<consumer>]
  *
  * If start and stop are omitted, the command just outputs information about
  * the amount of pending messages for the key/group pair, together with
@@ -1981,7 +1820,6 @@ void xpendingCommand(client *c) {
     if (c->argc >= 6) {
         if (getLongLongFromObjectOrReply(c,c->argv[5],&count,NULL) == C_ERR)
             return;
-        if (count < 0) count = 0;
         if (streamParseIDOrReply(c,c->argv[3],&startid,0) == C_ERR)
             return;
         if (streamParseIDOrReply(c,c->argv[4],&endid,UINT64_MAX) == C_ERR)
@@ -2155,14 +1993,6 @@ void xpendingCommand(client *c) {
  *      Return just an array of IDs of messages successfully claimed,
  *      without returning the actual message.
  *
- * 6. LASTID <id>:
- *      Update the consumer group last ID with the specified ID if the
- *      current last ID is smaller than the provided one.
- *      This is used for replication / AOF, so that when we read from a
- *      consumer group, the XCLAIM that gets propagated to give ownership
- *      to the consumer, is also used in order to update the group current
- *      ID.
- *
  * The command returns an array of messages that the user
  * successfully claimed, so that the caller is able to understand
  * what messages it is now in charge of. */
@@ -2207,9 +2037,7 @@ void xclaimCommand(client *c) {
 
     /* If we stopped because some IDs cannot be parsed, perhaps they
      * are trailing options. */
-    mstime_t now = mstime();
-    streamID last_id = {0,0};
-    int propagate_last_id = 0;
+    time_t now = mstime();
     for (; j < c->argc; j++) {
         int moreargs = (c->argc-1) - j; /* Number of additional arguments. */
         char *opt = c->argv[j]->ptr;
@@ -2233,20 +2061,12 @@ void xclaimCommand(client *c) {
             if (getLongLongFromObjectOrReply(c,c->argv[j],&retrycount,
                 "Invalid RETRYCOUNT option argument for XCLAIM")
                 != C_OK) return;
-        } else if (!strcasecmp(opt,"LASTID") && moreargs) {
-            j++;
-            if (streamParseStrictIDOrReply(c,c->argv[j],&last_id,0) != C_OK) return;
         } else {
             addReplyErrorFormat(c,"Unrecognized XCLAIM option '%s'",opt);
             return;
         }
     }
 
-    if (streamCompareID(&last_id,&group->last_id) > 0) {
-        group->last_id = last_id;
-        propagate_last_id = 1;
-    }
-
     if (deliverytime != -1) {
         /* If a delivery time was passed, either with IDLE or TIME, we
          * do some sanity check on it, and set the deliverytime to now
@@ -2264,14 +2084,13 @@ void xclaimCommand(client *c) {
     }
 
     /* Do the actual claiming. */
-    streamConsumer *consumer = NULL;
+    streamConsumer *consumer = streamLookupConsumer(group,c->argv[3]->ptr,1);
     void *arraylenptr = addDeferredMultiBulkLength(c);
     size_t arraylen = 0;
     for (int j = 5; j <= last_id_arg; j++) {
         streamID id;
         unsigned char buf[sizeof(streamID)];
-        if (streamParseStrictIDOrReply(c,c->argv[j],&id,0) != C_OK)
-            serverPanic("StreamID invalid after check. Should not be possible.");
+        if (streamParseStrictIDOrReply(c,c->argv[j],&id,0) != C_OK) return;
         streamEncodeID(buf,&id);
 
         /* Lookup the ID in the group PEL. */
@@ -2301,12 +2120,8 @@ void xclaimCommand(client *c) {
 
         if (nack != raxNotFound) {
             /* We need to check if the minimum idle time requested
-             * by the caller is satisfied by this entry.
-             *
-             * Note that the nack could be created by FORCE, in this
-             * case there was no pre-existing entry and minidle should
-             * be ignored, but in that case nick->consumer is NULL. */
-            if (nack->consumer && minidle) {
+             * by the caller is satisfied by this entry. */
+            if (minidle) {
                 mstime_t this_idle = now - nack->delivery_time;
                 if (this_idle < minidle) continue;
             }
@@ -2316,39 +2131,26 @@ void xclaimCommand(client *c) {
             if (nack->consumer)
                 raxRemove(nack->consumer->pel,buf,sizeof(buf),NULL);
             /* Update the consumer and idle time. */
-            if (consumer == NULL)
-                consumer = streamLookupConsumer(group,c->argv[3]->ptr,1);
             nack->consumer = consumer;
             nack->delivery_time = deliverytime;
-            /* Set the delivery attempts counter if given, otherwise
-             * autoincrement unless JUSTID option provided */
-            if (retrycount >= 0) {
-                nack->delivery_count = retrycount;
-            } else if (!justid) {
-                nack->delivery_count++;
-            }
+            /* Set the delivery attempts counter if given. */
+            if (retrycount >= 0) nack->delivery_count = retrycount;
             /* Add the entry in the new consumer local PEL. */
             raxInsert(consumer->pel,buf,sizeof(buf),nack,NULL);
             /* Send the reply for this entry. */
             if (justid) {
                 addReplyStreamID(c,&id);
             } else {
-                size_t emitted = streamReplyWithRange(c,o->ptr,&id,&id,1,0,
-                                    NULL,NULL,STREAM_RWR_RAWENTRIES,NULL);
-                if (!emitted) addReply(c,shared.nullbulk);
+                streamReplyWithRange(c,o->ptr,&id,NULL,1,0,NULL,NULL,
+                                     STREAM_RWR_RAWENTRIES,NULL);
             }
             arraylen++;
 
             /* Propagate this change. */
-            streamPropagateXCLAIM(c,c->argv[1],group,c->argv[2],c->argv[j],nack);
-            propagate_last_id = 0; /* Will be propagated by XCLAIM itself. */
+            streamPropagateXCLAIM(c,c->argv[1],c->argv[3],c->argv[j],nack);
             server.dirty++;
         }
     }
-    if (propagate_last_id) {
-        streamPropagateGroupID(c,c->argv[1],group,c->argv[2]);
-        server.dirty++;
-    }
     setDeferredMultiBulkLength(c,arraylenptr,arraylen);
     preventCommandPropagation(c);
 }
@@ -2525,11 +2327,11 @@ NULL
             if (idle < 0) idle = 0;
 
             addReplyMultiBulkLen(c,6);
-            addReplyBulkCString(c,"name");
+            addReplyStatus(c,"name");
             addReplyBulkCBuffer(c,consumer->name,sdslen(consumer->name));
-            addReplyBulkCString(c,"pending");
+            addReplyStatus(c,"pending");
             addReplyLongLong(c,raxSize(consumer->pel));
-            addReplyBulkCString(c,"idle");
+            addReplyStatus(c,"idle");
             addReplyLongLong(c,idle);
         }
         raxStop(&ri);
@@ -2547,28 +2349,28 @@ NULL
         while(raxNext(&ri)) {
             streamCG *cg = ri.data;
             addReplyMultiBulkLen(c,8);
-            addReplyBulkCString(c,"name");
+            addReplyStatus(c,"name");
             addReplyBulkCBuffer(c,ri.key,ri.key_len);
-            addReplyBulkCString(c,"consumers");
+            addReplyStatus(c,"consumers");
             addReplyLongLong(c,raxSize(cg->consumers));
-            addReplyBulkCString(c,"pending");
+            addReplyStatus(c,"pending");
             addReplyLongLong(c,raxSize(cg->pel));
-            addReplyBulkCString(c,"last-delivered-id");
+            addReplyStatus(c,"last-delivered-id");
             addReplyStreamID(c,&cg->last_id);
         }
         raxStop(&ri);
     } else if (!strcasecmp(opt,"STREAM") && c->argc == 3) {
         /* XINFO STREAM <key> (or the alias XINFO <key>). */
         addReplyMultiBulkLen(c,14);
-        addReplyBulkCString(c,"length");
+        addReplyStatus(c,"length");
         addReplyLongLong(c,s->length);
-        addReplyBulkCString(c,"radix-tree-keys");
+        addReplyStatus(c,"radix-tree-keys");
         addReplyLongLong(c,raxSize(s->rax));
-        addReplyBulkCString(c,"radix-tree-nodes");
+        addReplyStatus(c,"radix-tree-nodes");
         addReplyLongLong(c,s->rax->numnodes);
-        addReplyBulkCString(c,"groups");
+        addReplyStatus(c,"groups");
         addReplyLongLong(c,s->cgroups ? raxSize(s->cgroups) : 0);
-        addReplyBulkCString(c,"last-generated-id");
+        addReplyStatus(c,"last-generated-id");
         addReplyStreamID(c,&s->last_id);
 
         /* To emit the first/last entry we us the streamReplyWithRange()
@@ -2577,11 +2379,11 @@ NULL
         streamID start, end;
         start.ms = start.seq = 0;
         end.ms = end.seq = UINT64_MAX;
-        addReplyBulkCString(c,"first-entry");
+        addReplyStatus(c,"first-entry");
         count = streamReplyWithRange(c,s,&start,&end,1,0,NULL,NULL,
                                      STREAM_RWR_RAWENTRIES,NULL);
         if (!count) addReply(c,shared.nullbulk);
-        addReplyBulkCString(c,"last-entry");
+        addReplyStatus(c,"last-entry");
         count = streamReplyWithRange(c,s,&start,&end,1,1,NULL,NULL,
                                      STREAM_RWR_RAWENTRIES,NULL);
         if (!count) addReply(c,shared.nullbulk);

src/t_string.c

@@ -301,22 +301,24 @@ void mgetCommand(client *c) {
 }
 
 void msetGenericCommand(client *c, int nx) {
-    int j;
+    int j, busykeys = 0;
 
     if ((c->argc % 2) == 0) {
         addReplyError(c,"wrong number of arguments for MSET");
         return;
     }
-
     /* Handle the NX flag. The MSETNX semantic is to return zero and don't
-     * set anything if at least one key alerady exists. */
+     * 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) {
-                addReply(c, shared.czero);
-                return;
+                busykeys++;
             }
         }
+        if (busykeys) {
+            addReply(c, shared.czero);
+            return;
+        }
     }
 
     for (j = 1; j < c->argc; j += 2) {

src/t_zset.c

@@ -574,12 +574,12 @@ int zslParseLexRangeItem(robj *item, sds *dest, int *ex) {
     switch(c[0]) {
     case '+':
         if (c[1] != '\0') return C_ERR;
-        *ex = 1;
+        *ex = 0;
         *dest = shared.maxstring;
         return C_OK;
     case '-':
         if (c[1] != '\0') return C_ERR;
-        *ex = 1;
+        *ex = 0;
         *dest = shared.minstring;
         return C_OK;
     case '(':
@@ -652,8 +652,9 @@ int zslIsInLexRange(zskiplist *zsl, zlexrangespec *range) {
     zskiplistNode *x;
 
     /* Test for ranges that will always be empty. */
-    int cmp = sdscmplex(range->min,range->max);
-    if (cmp > 0 || (cmp == 0 && (range->minex || range->maxex)))
+    if (sdscmplex(range->min,range->max) > 1 ||
+            (sdscmp(range->min,range->max) == 0 &&
+            (range->minex || range->maxex)))
         return 0;
     x = zsl->tail;
     if (x == NULL || !zslLexValueGteMin(x->ele,range))
@@ -926,8 +927,9 @@ int zzlIsInLexRange(unsigned char *zl, zlexrangespec *range) {
     unsigned char *p;
 
     /* Test for ranges that will always be empty. */
-    int cmp = sdscmplex(range->min,range->max);
-    if (cmp > 0 || (cmp == 0 && (range->minex || range->maxex)))
+    if (sdscmplex(range->min,range->max) > 1 ||
+            (sdscmp(range->min,range->max) == 0 &&
+            (range->minex || range->maxex)))
         return 0;
 
     p = ziplistIndex(zl,-2); /* Last element. */
@@ -1357,8 +1359,9 @@ int zsetAdd(robj *zobj, double score, sds ele, int *flags, double *newscore) {
             /* Optimize: check if the element is too large or the list
              * becomes too long *before* executing zzlInsert. */
             zobj->ptr = zzlInsert(zobj->ptr,ele,score);
-            if (zzlLength(zobj->ptr) > server.zset_max_ziplist_entries ||
-                sdslen(ele) > server.zset_max_ziplist_value)
+            if (zzlLength(zobj->ptr) > server.zset_max_ziplist_entries)
+                zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
+            if (sdslen(ele) > server.zset_max_ziplist_value)
                 zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
             if (newscore) *newscore = score;
             *flags |= ZADD_ADDED;
@@ -2906,10 +2909,7 @@ void genericZrangebylexCommand(client *c, int reverse) {
         while (remaining) {
             if (remaining >= 3 && !strcasecmp(c->argv[pos]->ptr,"limit")) {
                 if ((getLongFromObjectOrReply(c, c->argv[pos+1], &offset, NULL) != C_OK) ||
-                    (getLongFromObjectOrReply(c, c->argv[pos+2], &limit, NULL) != C_OK)) {
-                    zslFreeLexRange(&range);
-                    return;
-                }
+                    (getLongFromObjectOrReply(c, c->argv[pos+2], &limit, NULL) != C_OK)) return;
                 pos += 3; remaining -= 3;
             } else {
                 zslFreeLexRange(&range);
@@ -3143,10 +3143,7 @@ void genericZpopCommand(client *c, robj **keyv, int keyc, int where, int emitkey
     if (countarg) {
         if (getLongFromObjectOrReply(c,countarg,&count,NULL) != C_OK)
             return;
-        if (count <= 0) {
-            addReply(c,shared.emptymultibulk);
-            return;
-        }
+        if (count < 0) count = 1;
     }
 
     /* Check type and break on the first error, otherwise identify candidate. */

src/util.c

@@ -39,7 +39,6 @@
 #include <float.h>
 #include <stdint.h>
 #include <errno.h>
-#include <time.h>
 
 #include "util.h"
 #include "sha1.h"
@@ -48,7 +47,7 @@
 int stringmatchlen(const char *pattern, int patternLen,
         const char *string, int stringLen, int nocase)
 {
-    while(patternLen && stringLen) {
+    while(patternLen) {
         switch(pattern[0]) {
         case '*':
             while (pattern[1] == '*') {
@@ -171,22 +170,6 @@ int stringmatch(const char *pattern, const char *string, int nocase) {
     return stringmatchlen(pattern,strlen(pattern),string,strlen(string),nocase);
 }
 
-/* Fuzz stringmatchlen() trying to crash it with bad input. */
-int stringmatchlen_fuzz_test(void) {
-    char str[32];
-    char pat[32];
-    int cycles = 10000000;
-    int total_matches = 0;
-    while(cycles--) {
-        int strlen = rand() % sizeof(str);
-        int patlen = rand() % sizeof(pat);
-        for (int j = 0; j < strlen; j++) str[j] = rand() % 128;
-        for (int j = 0; j < patlen; j++) pat[j] = rand() % 128;
-        total_matches += stringmatchlen(pat, patlen, str, strlen, 0);
-    }
-    return total_matches;
-}
-
 /* Convert a string representing an amount of memory into the number of
  * bytes, so for instance memtoll("1Gb") will return 1073741824 that is
  * (1024*1024*1024).
@@ -447,7 +430,7 @@ int string2l(const char *s, size_t slen, long *lval) {
  * a double: no spaces or other characters before or after the string
  * representing the number are accepted. */
 int string2ld(const char *s, size_t slen, long double *dp) {
-    char buf[MAX_LONG_DOUBLE_CHARS];
+    char buf[256];
     long double value;
     char *eptr;
 
@@ -622,7 +605,7 @@ void getRandomHexChars(char *p, size_t len) {
  * already, this will be detected and handled correctly.
  *
  * The function does not try to normalize everything, but only the obvious
- * case of one or more "../" appearing at the start of "filename"
+ * case of one or more "../" appearning at the start of "filename"
  * relative path. */
 sds getAbsolutePath(char *filename) {
     char cwd[1024];
@@ -669,24 +652,6 @@ sds getAbsolutePath(char *filename) {
     return abspath;
 }
 
-/*
- * Gets the proper timezone in a more portable fashion
- * i.e timezone variables are linux specific.
- */
-
-unsigned long getTimeZone(void) {
-#ifdef __linux__
-    return timezone;
-#else
-    struct timeval tv;
-    struct timezone tz;
-
-    gettimeofday(&tv, &tz);
-
-    return tz.tz_minuteswest * 60UL;
-#endif
-}
-
 /* Return true if the specified path is just a file basename without any
  * relative or absolute path. This function just checks that no / or \
  * character exists inside the specified path, that's enough in the

src/util.h

@@ -40,7 +40,6 @@
 
 int stringmatchlen(const char *p, int plen, const char *s, int slen, int nocase);
 int stringmatch(const char *p, const char *s, int nocase);
-int stringmatchlen_fuzz_test(void);
 long long memtoll(const char *p, int *err);
 uint32_t digits10(uint64_t v);
 uint32_t sdigits10(int64_t v);
@@ -51,7 +50,6 @@ int string2ld(const char *s, size_t slen, long double *dp);
 int d2string(char *buf, size_t len, double value);
 int ld2string(char *buf, size_t len, long double value, int humanfriendly);
 sds getAbsolutePath(char *filename);
-unsigned long getTimeZone(void);
 int pathIsBaseName(char *path);
 
 #ifdef REDIS_TEST

src/version.h

@@ -1 +1 @@
-#define REDIS_VERSION "5.0.9"
+#define REDIS_VERSION "999.999.999"

src/ziplist.c

@@ -576,7 +576,7 @@ void zipEntry(unsigned char *p, zlentry *e) {
 
 /* Create a new empty ziplist. */
 unsigned char *ziplistNew(void) {
-    unsigned int bytes = ZIPLIST_HEADER_SIZE+ZIPLIST_END_SIZE;
+    unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
     unsigned char *zl = zmalloc(bytes);
     ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
     ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);

src/zmalloc.c

@@ -323,13 +323,6 @@ int zmalloc_get_allocator_info(size_t *allocated,
     je_mallctl("stats.allocated", allocated, &sz, NULL, 0);
     return 1;
 }
-
-void set_jemalloc_bg_thread(int enable) {
-    /* let jemalloc do purging asynchronously, required when there's no traffic 
-     * after flushdb */
-    char val = !!enable;
-    je_mallctl("background_thread", NULL, 0, &val, 1);
-}
 #else
 int zmalloc_get_allocator_info(size_t *allocated,
                                size_t *active,

tests/integration/psync2.tcl

@@ -166,15 +166,12 @@ start_server {} {
         # Pick a random slave
         set slave_id [expr {($master_id+1)%5}]
         set sync_count [status $R($master_id) sync_full]
-        set sync_partial [status $R($master_id) sync_partial_ok]
         catch {
             $R($slave_id) config rewrite
             $R($slave_id) debug restart
         }
-        # note: just waiting for connected_slaves==4 has a race condition since
-        # we might do the check before the master realized that the slave disconnected
         wait_for_condition 50 1000 {
-            [status $R($master_id) sync_partial_ok] == $sync_partial + 1
+            [status $R($master_id) connected_slaves] == 4
         } else {
             fail "Replica not reconnecting"
         }

tests/integration/replication-psync.tcl

@@ -79,32 +79,6 @@ proc test_psync {descr duration backlog_size backlog_ttl delay cond diskless rec
                 stop_bg_complex_data $load_handle0
                 stop_bg_complex_data $load_handle1
                 stop_bg_complex_data $load_handle2
-
-                # Wait for the slave to reach the "online"
-                # state from the POV of the master.
-                set retry 5000
-                while {$retry} {
-                    set info [$master info]
-                    if {[string match {*slave0:*state=online*} $info]} {
-                        break
-                    } else {
-                        incr retry -1
-                        after 100
-                    }
-                }
-                if {$retry == 0} {
-                    error "assertion:Slave not correctly synchronized"
-                }
-
-                # Wait that slave acknowledge it is online so
-                # we are sure that DBSIZE and DEBUG DIGEST will not
-                # fail because of timing issues. (-LOADING error)
-                wait_for_condition 5000 100 {
-                    [lindex [$slave role] 3] eq {connected}
-                } else {
-                    fail "Slave still not connected after some time"
-                }  
-
                 set retry 10
                 while {$retry && ([$master debug digest] ne [$slave debug digest])}\
                 {

tests/integration/replication.tcl

@@ -275,6 +275,7 @@ start_server {tags {"repl"}} {
     start_server {} {
         test "Master stream is correctly processed while the replica has a script in -BUSY state" {
             set slave [srv 0 client]
+            puts [srv 0 port]
             $slave config set lua-time-limit 500
             $slave slaveof $master_host $master_port
 

tests/modules/Makefile

@@ -1,28 +0,0 @@
-
-# find the OS
-uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
-
-# Compile flags for linux / osx
-ifeq ($(uname_S),Linux)
-	SHOBJ_CFLAGS ?= -W -Wall -fno-common -g -ggdb -std=c99 -O2
-	SHOBJ_LDFLAGS ?= -shared
-else
-	SHOBJ_CFLAGS ?= -W -Wall -dynamic -fno-common -g -ggdb -std=c99 -O2
-	SHOBJ_LDFLAGS ?= -bundle -undefined dynamic_lookup
-endif
-
-.SUFFIXES: .c .so .xo .o
-
-all: commandfilter.so testrdb.so
-
-.c.xo:
-	$(CC) -I../../src $(CFLAGS) $(SHOBJ_CFLAGS) -fPIC -c $< -o $@
-
-commandfilter.xo: ../../src/redismodule.h
-testrdb.xo: ../../src/redismodule.h
-
-commandfilter.so: commandfilter.xo
-	$(LD) -o $@ $< $(SHOBJ_LDFLAGS) $(LIBS) -lc
-
-testrdb.so: testrdb.xo
-	$(LD) -o $@ $< $(SHOBJ_LDFLAGS) $(LIBS) -lc

tests/modules/commandfilter.c

@@ -1,149 +0,0 @@
-#define REDISMODULE_EXPERIMENTAL_API
-#include "redismodule.h"
-
-#include <string.h>
-
-static RedisModuleString *log_key_name;
-
-static const char log_command_name[] = "commandfilter.log";
-static const char ping_command_name[] = "commandfilter.ping";
-static const char unregister_command_name[] = "commandfilter.unregister";
-static int in_log_command = 0;
-
-static RedisModuleCommandFilter *filter = NULL;
-
-int CommandFilter_UnregisterCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    (void) argc;
-    (void) argv;
-
-    RedisModule_ReplyWithLongLong(ctx,
-            RedisModule_UnregisterCommandFilter(ctx, filter));
-
-    return REDISMODULE_OK;
-}
-
-int CommandFilter_PingCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    (void) argc;
-    (void) argv;
-
-    RedisModuleCallReply *reply = RedisModule_Call(ctx, "ping", "c", "@log");
-    if (reply) {
-        RedisModule_ReplyWithCallReply(ctx, reply);
-        RedisModule_FreeCallReply(reply);
-    } else {
-        RedisModule_ReplyWithSimpleString(ctx, "Unknown command or invalid arguments");
-    }
-
-    return REDISMODULE_OK;
-}
-
-int CommandFilter_LogCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    RedisModuleString *s = RedisModule_CreateString(ctx, "", 0);
-
-    int i;
-    for (i = 1; i < argc; i++) {
-        size_t arglen;
-        const char *arg = RedisModule_StringPtrLen(argv[i], &arglen);
-
-        if (i > 1) RedisModule_StringAppendBuffer(ctx, s, " ", 1);
-        RedisModule_StringAppendBuffer(ctx, s, arg, arglen);
-    }
-
-    RedisModuleKey *log = RedisModule_OpenKey(ctx, log_key_name, REDISMODULE_WRITE|REDISMODULE_READ);
-    RedisModule_ListPush(log, REDISMODULE_LIST_HEAD, s);
-    RedisModule_CloseKey(log);
-    RedisModule_FreeString(ctx, s);
-
-    in_log_command = 1;
-
-    size_t cmdlen;
-    const char *cmdname = RedisModule_StringPtrLen(argv[1], &cmdlen);
-    RedisModuleCallReply *reply = RedisModule_Call(ctx, cmdname, "v", &argv[2], argc - 2);
-    if (reply) {
-        RedisModule_ReplyWithCallReply(ctx, reply);
-        RedisModule_FreeCallReply(reply);
-    } else {
-        RedisModule_ReplyWithSimpleString(ctx, "Unknown command or invalid arguments");
-    }
-
-    in_log_command = 0;
-
-    return REDISMODULE_OK;
-}
-
-void CommandFilter_CommandFilter(RedisModuleCommandFilterCtx *filter)
-{
-    if (in_log_command) return;  /* don't process our own RM_Call() from CommandFilter_LogCommand() */
-
-    /* Fun manipulations:
-     * - Remove @delme
-     * - Replace @replaceme
-     * - Append @insertbefore or @insertafter
-     * - Prefix with Log command if @log encounterd
-     */
-    int log = 0;
-    int pos = 0;
-    while (pos < RedisModule_CommandFilterArgsCount(filter)) {
-        const RedisModuleString *arg = RedisModule_CommandFilterArgGet(filter, pos);
-        size_t arg_len;
-        const char *arg_str = RedisModule_StringPtrLen(arg, &arg_len);
-
-        if (arg_len == 6 && !memcmp(arg_str, "@delme", 6)) {
-            RedisModule_CommandFilterArgDelete(filter, pos);
-            continue;
-        } 
-        if (arg_len == 10 && !memcmp(arg_str, "@replaceme", 10)) {
-            RedisModule_CommandFilterArgReplace(filter, pos,
-                    RedisModule_CreateString(NULL, "--replaced--", 12));
-        } else if (arg_len == 13 && !memcmp(arg_str, "@insertbefore", 13)) {
-            RedisModule_CommandFilterArgInsert(filter, pos,
-                    RedisModule_CreateString(NULL, "--inserted-before--", 19));
-            pos++;
-        } else if (arg_len == 12 && !memcmp(arg_str, "@insertafter", 12)) {
-            RedisModule_CommandFilterArgInsert(filter, pos + 1,
-                    RedisModule_CreateString(NULL, "--inserted-after--", 18));
-            pos++;
-        } else if (arg_len == 4 && !memcmp(arg_str, "@log", 4)) {
-            log = 1;
-        }
-        pos++;
-    }
-
-    if (log) RedisModule_CommandFilterArgInsert(filter, 0,
-            RedisModule_CreateString(NULL, log_command_name, sizeof(log_command_name)-1));
-}
-
-int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-    if (RedisModule_Init(ctx,"commandfilter",1,REDISMODULE_APIVER_1)
-            == REDISMODULE_ERR) return REDISMODULE_ERR;
-
-    if (argc != 2) {
-        RedisModule_Log(ctx, "warning", "Log key name not specified");
-        return REDISMODULE_ERR;
-    }
-
-    long long noself = 0;
-    log_key_name = RedisModule_CreateStringFromString(ctx, argv[0]);
-    RedisModule_StringToLongLong(argv[1], &noself);
-
-    if (RedisModule_CreateCommand(ctx,log_command_name,
-                CommandFilter_LogCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
-            return REDISMODULE_ERR;
-
-    if (RedisModule_CreateCommand(ctx,ping_command_name,
-                CommandFilter_PingCommand,"deny-oom",1,1,1) == REDISMODULE_ERR)
-            return REDISMODULE_ERR;
-
-    if (RedisModule_CreateCommand(ctx,unregister_command_name,
-                CommandFilter_UnregisterCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
-            return REDISMODULE_ERR;
-
-    if ((filter = RedisModule_RegisterCommandFilter(ctx, CommandFilter_CommandFilter, 
-                    noself ? REDISMODULE_CMDFILTER_NOSELF : 0))
-            == NULL) return REDISMODULE_ERR;
-
-    return REDISMODULE_OK;
-}

tests/modules/testrdb.c

@@ -1,229 +0,0 @@
-#include "redismodule.h"
-
-#include <string.h>
-#include <assert.h>
-
-/* Module configuration, save aux or not? */
-long long conf_aux_count = 0;
-
-/* Registered type */
-RedisModuleType *testrdb_type = NULL;
-
-/* Global values to store and persist to aux */
-RedisModuleString *before_str = NULL;
-RedisModuleString *after_str = NULL;
-
-void *testrdb_type_load(RedisModuleIO *rdb, int encver) {
-    int count = RedisModule_LoadSigned(rdb);
-    assert(count==1);
-    assert(encver==1);
-    RedisModuleString *str = RedisModule_LoadString(rdb);
-    return str;
-}
-
-void testrdb_type_save(RedisModuleIO *rdb, void *value) {
-    RedisModuleString *str = (RedisModuleString*)value;
-    RedisModule_SaveSigned(rdb, 1);
-    RedisModule_SaveString(rdb, str);
-}
-
-void testrdb_aux_save(RedisModuleIO *rdb, int when) {
-    if (conf_aux_count==1) assert(when == REDISMODULE_AUX_AFTER_RDB);
-    if (conf_aux_count==0) assert(0);
-    if (when == REDISMODULE_AUX_BEFORE_RDB) {
-        if (before_str) {
-            RedisModule_SaveSigned(rdb, 1);
-            RedisModule_SaveString(rdb, before_str);
-        } else {
-            RedisModule_SaveSigned(rdb, 0);
-        }
-    } else {
-        if (after_str) {
-            RedisModule_SaveSigned(rdb, 1);
-            RedisModule_SaveString(rdb, after_str);
-        } else {
-            RedisModule_SaveSigned(rdb, 0);
-        }
-    }
-}
-
-int testrdb_aux_load(RedisModuleIO *rdb, int encver, int when) {
-    assert(encver == 1);
-    if (conf_aux_count==1) assert(when == REDISMODULE_AUX_AFTER_RDB);
-    if (conf_aux_count==0) assert(0);
-    RedisModuleCtx *ctx = RedisModule_GetContextFromIO(rdb);
-    if (when == REDISMODULE_AUX_BEFORE_RDB) {
-        if (before_str)
-            RedisModule_FreeString(ctx, before_str);
-        before_str = NULL;
-        int count = RedisModule_LoadSigned(rdb);
-        if (count)
-            before_str = RedisModule_LoadString(rdb);
-    } else {
-        if (after_str)
-            RedisModule_FreeString(ctx, after_str);
-        after_str = NULL;
-        int count = RedisModule_LoadSigned(rdb);
-        if (count)
-            after_str = RedisModule_LoadString(rdb);
-    }
-    return REDISMODULE_OK;
-}
-
-void testrdb_type_free(void *value) {
-    RedisModule_FreeString(NULL, (RedisModuleString*)value);
-}
-
-int testrdb_set_before(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    if (argc != 2) {
-        RedisModule_WrongArity(ctx);
-        return REDISMODULE_OK;
-    }
-
-    if (before_str)
-        RedisModule_FreeString(ctx, before_str);
-    before_str = argv[1];
-    RedisModule_RetainString(ctx, argv[1]);
-    RedisModule_ReplyWithLongLong(ctx, 1);
-    return REDISMODULE_OK;
-}
-
-int testrdb_get_before(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    REDISMODULE_NOT_USED(argv);
-    if (argc != 1){
-        RedisModule_WrongArity(ctx);
-        return REDISMODULE_OK;
-    }
-    if (before_str)
-        RedisModule_ReplyWithString(ctx, before_str);
-    else
-        RedisModule_ReplyWithStringBuffer(ctx, "", 0);
-    return REDISMODULE_OK;
-}
-
-int testrdb_set_after(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    if (argc != 2){
-        RedisModule_WrongArity(ctx);
-        return REDISMODULE_OK;
-    }
-
-    if (after_str)
-        RedisModule_FreeString(ctx, after_str);
-    after_str = argv[1];
-    RedisModule_RetainString(ctx, argv[1]);
-    RedisModule_ReplyWithLongLong(ctx, 1);
-    return REDISMODULE_OK;
-}
-
-int testrdb_get_after(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    REDISMODULE_NOT_USED(argv);
-    if (argc != 1){
-        RedisModule_WrongArity(ctx);
-        return REDISMODULE_OK;
-    }
-    if (after_str)
-        RedisModule_ReplyWithString(ctx, after_str);
-    else
-        RedisModule_ReplyWithStringBuffer(ctx, "", 0);
-    return REDISMODULE_OK;
-}
-
-int testrdb_set_key(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    if (argc != 3){
-        RedisModule_WrongArity(ctx);
-        return REDISMODULE_OK;
-    }
-
-    RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_WRITE);
-    RedisModuleString *str = RedisModule_ModuleTypeGetValue(key);
-    if (str)
-        RedisModule_FreeString(ctx, str);
-    RedisModule_ModuleTypeSetValue(key, testrdb_type, argv[2]);
-    RedisModule_RetainString(ctx, argv[2]);
-    RedisModule_CloseKey(key);
-    RedisModule_ReplyWithLongLong(ctx, 1);
-    return REDISMODULE_OK;
-}
-
-int testrdb_get_key(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
-{
-    if (argc != 2){
-        RedisModule_WrongArity(ctx);
-        return REDISMODULE_OK;
-    }
-
-    RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_WRITE);
-    RedisModuleString *str = RedisModule_ModuleTypeGetValue(key);
-    RedisModule_CloseKey(key);
-    RedisModule_ReplyWithString(ctx, str);
-    return REDISMODULE_OK;
-}
-
-int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-    REDISMODULE_NOT_USED(argv);
-    REDISMODULE_NOT_USED(argc);
-
-    if (RedisModule_Init(ctx,"testrdb",1,REDISMODULE_APIVER_1) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
-
-    if (argc > 0)
-        RedisModule_StringToLongLong(argv[0], &conf_aux_count);
-
-    if (conf_aux_count==0) {
-        RedisModuleTypeMethods datatype_methods = {
-            .version = 1,
-            .rdb_load = testrdb_type_load,
-            .rdb_save = testrdb_type_save,
-            .aof_rewrite = NULL,
-            .digest = NULL,
-            .free = testrdb_type_free,
-        };
-
-        testrdb_type = RedisModule_CreateDataType(ctx, "test__rdb", 1, &datatype_methods);
-        if (testrdb_type == NULL)
-            return REDISMODULE_ERR;
-    } else {
-        RedisModuleTypeMethods datatype_methods = {
-            .version = REDISMODULE_TYPE_METHOD_VERSION,
-            .rdb_load = testrdb_type_load,
-            .rdb_save = testrdb_type_save,
-            .aof_rewrite = NULL,
-            .digest = NULL,
-            .free = testrdb_type_free,
-            .aux_load = testrdb_aux_load,
-            .aux_save = testrdb_aux_save,
-            .aux_save_triggers = (conf_aux_count == 1 ?
-                                  REDISMODULE_AUX_AFTER_RDB :
-                                  REDISMODULE_AUX_BEFORE_RDB | REDISMODULE_AUX_AFTER_RDB)
-        };
-
-        testrdb_type = RedisModule_CreateDataType(ctx, "test__rdb", 1, &datatype_methods);
-        if (testrdb_type == NULL)
-            return REDISMODULE_ERR;
-    }
-
-    if (RedisModule_CreateCommand(ctx,"testrdb.set.before", testrdb_set_before,"deny-oom",0,0,0) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
-
-    if (RedisModule_CreateCommand(ctx,"testrdb.get.before", testrdb_get_before,"",0,0,0) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
-
-    if (RedisModule_CreateCommand(ctx,"testrdb.set.after", testrdb_set_after,"deny-oom",0,0,0) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
-
-    if (RedisModule_CreateCommand(ctx,"testrdb.get.after", testrdb_get_after,"",0,0,0) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
-
-    if (RedisModule_CreateCommand(ctx,"testrdb.set.key", testrdb_set_key,"deny-oom",1,1,1) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
-
-    if (RedisModule_CreateCommand(ctx,"testrdb.get.key", testrdb_get_key,"",1,1,1) == REDISMODULE_ERR)
-        return REDISMODULE_ERR;
-
-    return REDISMODULE_OK;
-}

tests/support/server.tcl

@@ -4,7 +4,7 @@ set ::valgrind_errors {}
 
 proc start_server_error {config_file error} {
     set err {}
-    append err "Cant' start the Redis server\n"
+    append err "Can't start the Redis server\n"
     append err "CONFIGURATION:"
     append err [exec cat $config_file]
     append err "\nERROR:"

tests/support/util.tcl

@@ -91,14 +91,6 @@ proc wait_for_sync r {
     }
 }
 
-proc wait_for_ofs_sync {r1 r2} {
-    wait_for_condition 50 100 {
-        [status $r1 master_repl_offset] eq [status $r2 master_repl_offset]
-    } else {
-        fail "replica didn't sync in time"
-    }
-}
-
 # Random integer between 0 and max (excluded).
 proc randomInt {max} {
     expr {int(rand()*$max)}

tests/test_helper.tcl

@@ -502,7 +502,7 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
     } elseif {$opt eq {--only}} {
         lappend ::only_tests $arg
         incr j
-    } elseif {$opt eq {--skip-till}} {
+    } elseif {$opt eq {--skiptill}} {
         set ::skip_till $arg
         incr j
     } elseif {$opt eq {--list-tests}} {

tests/unit/dump.tcl

@@ -33,7 +33,7 @@ start_server {tags {"dump"}} {
         set now [clock milliseconds]
         r restore foo [expr $now+3000] $encoded absttl
         set ttl [r pttl foo]
-        assert {$ttl >= 2900 && $ttl <= 3100}
+        assert {$ttl >= 2990 && $ttl <= 3000}
         r get foo
     } {bar}
     

tests/unit/hyperloglog.tcl

@@ -115,34 +115,6 @@ start_server {tags {"hll"}} {
         set e
     } {*WRONGTYPE*}
 
-    test {Fuzzing dense/sparse encoding: Redis should always detect errors} {
-        for {set j 0} {$j < 1000} {incr j} {
-            r del hll
-            set items {}
-            set numitems [randomInt 3000]
-            for {set i 0} {$i < $numitems} {incr i} {
-                lappend items [expr {rand()}]
-            }
-            r pfadd hll {*}$items
-
-            # Corrupt it in some random way.
-            for {set i 0} {$i < 5} {incr i} {
-                set len [r strlen hll]
-                set pos [randomInt $len]
-                set byte [randstring 1 1 binary]
-                r setrange hll $pos $byte
-                # Don't modify more bytes 50% of times
-                if {rand() < 0.5} break
-            }
-
-            # Use the hyperloglog to check if it crashes
-            # Redis in some way.
-            catch {
-                r pfcount hll
-            }
-        }
-    }
-
     test {PFADD, PFCOUNT, PFMERGE type checking works} {
         r set foo bar
         catch {r pfadd foo 1} e

tests/unit/maxmemory.tcl

@@ -161,7 +161,7 @@ proc test_slave_buffers {test_name cmd_count payload_len limit_memory pipeline}
             }
 
             # make sure master doesn't disconnect slave because of timeout
-            $master config set repl-timeout 1200 ;# 20 minutes (for valgrind and slow machines)
+            $master config set repl-timeout 300 ;# 5 minutes
             $master config set maxmemory-policy allkeys-random
             $master config set client-output-buffer-limit "replica 100000000 100000000 300"
             $master config set repl-backlog-size [expr {10*1024}]
@@ -212,8 +212,7 @@ proc test_slave_buffers {test_name cmd_count payload_len limit_memory pipeline}
 
             assert {[$master dbsize] == 100}
             assert {$slave_buf > 2*1024*1024} ;# some of the data may have been pushed to the OS buffers
-            set delta_max [expr {$cmd_count / 2}] ;# 1 byte unaccounted for, with 1M commands will consume some 1MB
-            assert {$delta < $delta_max && $delta > -$delta_max}
+            assert {$delta < 50*1024 && $delta > -50*1024} ;# 1 byte unaccounted for, with 1M commands will consume some 1MB
 
             $master client kill type slave
             set killed_used [s -1 used_memory]
@@ -222,7 +221,7 @@ proc test_slave_buffers {test_name cmd_count payload_len limit_memory pipeline}
             set killed_used_no_repl [expr {$killed_used - $killed_mem_not_counted_for_evict}]
             set delta_no_repl [expr {$killed_used_no_repl - $used_no_repl}]
             assert {$killed_slave_buf == 0}
-            assert {$delta_no_repl > -$delta_max && $delta_no_repl < $delta_max}
+            assert {$delta_no_repl > -50*1024 && $delta_no_repl < 50*1024} ;# 1 byte unaccounted for, with 1M commands will consume some 1MB
 
         }
         # unfreeze slave process (after the 'test' succeeded or failed, but before we attempt to terminate the server

tests/unit/memefficiency.tcl

@@ -90,7 +90,6 @@ start_server {tags {"defrag"}} {
         test "Active defrag big keys" {
             r flushdb
             r config resetstat
-            r config set save "" ;# prevent bgsave from interfereing with save below
             r config set activedefrag no
             r config set active-defrag-max-scan-fields 1000
             r config set active-defrag-threshold-lower 5

tests/unit/moduleapi/commandfilter.tcl

@@ -1,84 +0,0 @@
-set testmodule [file normalize tests/modules/commandfilter.so]
-
-start_server {tags {"modules"}} {
-    r module load $testmodule log-key 0
-
-    test {Command Filter handles redirected commands} {
-        r set mykey @log
-        r lrange log-key 0 -1
-    } "{set mykey @log}"
-
-    test {Command Filter can call RedisModule_CommandFilterArgDelete} {
-        r rpush mylist elem1 @delme elem2
-        r lrange mylist 0 -1
-    } {elem1 elem2}
-
-    test {Command Filter can call RedisModule_CommandFilterArgInsert} {
-        r del mylist
-        r rpush mylist elem1 @insertbefore elem2 @insertafter elem3
-        r lrange mylist 0 -1
-    } {elem1 --inserted-before-- @insertbefore elem2 @insertafter --inserted-after-- elem3}
-
-    test {Command Filter can call RedisModule_CommandFilterArgReplace} {
-        r del mylist
-        r rpush mylist elem1 @replaceme elem2
-        r lrange mylist 0 -1
-    } {elem1 --replaced-- elem2}
-
-    test {Command Filter applies on RM_Call() commands} {
-        r del log-key
-        r commandfilter.ping
-        r lrange log-key 0 -1
-    } "{ping @log}"
-
-    test {Command Filter applies on Lua redis.call()} {
-        r del log-key
-        r eval "redis.call('ping', '@log')" 0
-        r lrange log-key 0 -1
-    } "{ping @log}"
-
-    test {Command Filter applies on Lua redis.call() that calls a module} {
-        r del log-key
-        r eval "redis.call('commandfilter.ping')" 0
-        r lrange log-key 0 -1
-    } "{ping @log}"
-
-    test {Command Filter is unregistered implicitly on module unload} {
-        r del log-key
-        r module unload commandfilter
-        r set mykey @log
-        r lrange log-key 0 -1
-    } {}
-
-    r module load $testmodule log-key 0
-
-    test {Command Filter unregister works as expected} {
-        # Validate reloading succeeded
-        r del log-key
-        r set mykey @log
-        assert_equal "{set mykey @log}" [r lrange log-key 0 -1]
-
-        # Unregister
-        r commandfilter.unregister
-        r del log-key
-
-        r set mykey @log
-        r lrange log-key 0 -1
-    } {}
-
-    r module unload commandfilter
-    r module load $testmodule log-key 1
-
-    test {Command Filter REDISMODULE_CMDFILTER_NOSELF works as expected} {
-        r set mykey @log
-        assert_equal "{set mykey @log}" [r lrange log-key 0 -1]
-
-        r del log-key
-        r commandfilter.ping
-        assert_equal {} [r lrange log-key 0 -1]
-
-        r eval "redis.call('commandfilter.ping')" 0
-        assert_equal {} [r lrange log-key 0 -1]
-    }
-
-} 

tests/unit/moduleapi/testrdb.tcl

@@ -1,62 +0,0 @@
-set testmodule [file normalize tests/modules/testrdb.so]
-
-proc restart_and_wait {} {
-    catch {
-        r debug restart
-    }
-
-    # wait for the server to come back up
-    set retry 50
-    while {$retry} {
-        if {[catch { r ping }]} {
-            after 100
-        } else {
-            break
-        }
-        incr retry -1
-    }
-}
-
-tags "modules" {
-    start_server [list overrides [list loadmodule "$testmodule"]] {
-        test {modules are able to persist types} {
-            r testrdb.set.key key1 value1
-            assert_equal "value1" [r testrdb.get.key key1]
-            r debug reload
-            assert_equal "value1" [r testrdb.get.key key1]
-        }
-
-        test {modules global are lost without aux} {
-            r testrdb.set.before global1
-            assert_equal "global1" [r testrdb.get.before]
-            restart_and_wait
-            assert_equal "" [r testrdb.get.before]
-        }
-    }
-
-    start_server [list overrides [list loadmodule "$testmodule 2"]] {
-        test {modules are able to persist globals before and after} {
-            r testrdb.set.before global1
-            r testrdb.set.after global2
-            assert_equal "global1" [r testrdb.get.before]
-            assert_equal "global2" [r testrdb.get.after]
-            restart_and_wait
-            assert_equal "global1" [r testrdb.get.before]
-            assert_equal "global2" [r testrdb.get.after]
-        }
-
-    }
-
-    start_server [list overrides [list loadmodule "$testmodule 1"]] {
-        test {modules are able to persist globals just after} {
-            r testrdb.set.after global2
-            assert_equal "global2" [r testrdb.get.after]
-            restart_and_wait
-            assert_equal "global2" [r testrdb.get.after]
-        }
-    }
-
-
-    # TODO: test short read handling
-
-}

tests/unit/slowlog.tcl

@@ -80,11 +80,9 @@ start_server {tags {"slowlog"} overrides {slowlog-log-slower-than 1000000}} {
     }
 
     test {SLOWLOG - can be disabled} {
-        r config set slowlog-max-len 1
         r config set slowlog-log-slower-than 1
         r slowlog reset
-        r debug sleep 0.2
-        assert_equal [r slowlog len] 1
+        assert_equal [r slowlog len] 1 
         r config set slowlog-log-slower-than -1
         r slowlog reset
         r debug sleep 0.2

tests/unit/type/stream-cgroups.tcl

@@ -9,17 +9,6 @@ start_server {
         set err
     } {BUSYGROUP*}
 
-    test {XGROUP CREATE: automatic stream creation fails without MKSTREAM} {
-        r DEL mystream
-        catch {r XGROUP CREATE mystream mygroup $} err
-        set err
-    } {ERR*}
-
-    test {XGROUP CREATE: automatic stream creation works with MKSTREAM} {
-        r DEL mystream
-        r XGROUP CREATE mystream mygroup $ MKSTREAM
-    } {OK}
-
     test {XREADGROUP will return only new elements} {
         r XADD mystream * a 1
         r XADD mystream * b 2
@@ -107,199 +96,4 @@ start_server {
         set c [llength [lindex [r xreadgroup group g1 c2 streams events >] 0 1]]
         assert {$c == 5}
     }
-
-    test {XREADGROUP will not report data on empty history. Bug #5577} {
-        r del events
-        r xadd events * a 1
-        r xadd events * b 2
-        r xadd events * c 3
-        r xgroup create events mygroup 0
-
-        # Current local PEL should be empty
-        set res [r xpending events mygroup - + 10]
-        assert {[llength $res] == 0}
-
-        # So XREADGROUP should read an empty history as well
-        set res [r xreadgroup group mygroup myconsumer count 3 streams events 0]
-        assert {[llength [lindex $res 0 1]] == 0}
-
-        # We should fetch all the elements in the stream asking for >
-        set res [r xreadgroup group mygroup myconsumer count 3 streams events >]
-        assert {[llength [lindex $res 0 1]] == 3}
-
-        # Now the history is populated with three not acked entries
-        set res [r xreadgroup group mygroup myconsumer count 3 streams events 0]
-        assert {[llength [lindex $res 0 1]] == 3}
-    }
-
-    test {XREADGROUP history reporting of deleted entries. Bug #5570} {
-        r del mystream
-        r XGROUP CREATE mystream mygroup $ MKSTREAM
-        r XADD mystream 1 field1 A
-        r XREADGROUP GROUP mygroup myconsumer STREAMS mystream >
-        r XADD mystream MAXLEN 1 2 field1 B
-        r XREADGROUP GROUP mygroup myconsumer STREAMS mystream >
-
-        # Now we have two pending entries, however one should be deleted
-        # and one should be ok (we should only see "B")
-        set res [r XREADGROUP GROUP mygroup myconsumer STREAMS mystream 0-1]
-        assert {[lindex $res 0 1 0] == {1-0 {}}}
-        assert {[lindex $res 0 1 1] == {2-0 {field1 B}}}
-    }
-
-    test {Blocking XREADGROUP will not reply with an empty array} {
-        r del mystream
-        r XGROUP CREATE mystream mygroup $ MKSTREAM
-        r XADD mystream 666 f v
-        set res [r XREADGROUP GROUP mygroup Alice BLOCK 10 STREAMS mystream ">"]
-        assert {[lindex $res 0 1 0] == {666-0 {f v}}}
-        r XADD mystream 667 f2 v2
-        r XDEL mystream 667
-        set rd [redis_deferring_client]
-        $rd XREADGROUP GROUP mygroup Alice BLOCK 10 STREAMS mystream ">"
-        after 20
-        assert {[$rd read] == {}} ;# before the fix, client didn't even block, but was served synchronously with {mystream {}}
-    }
-
-    test {XCLAIM can claim PEL items from another consumer} {
-        # Add 3 items into the stream, and create a consumer group
-        r del mystream
-        set id1 [r XADD mystream * a 1]
-        set id2 [r XADD mystream * b 2]
-        set id3 [r XADD mystream * c 3]
-        r XGROUP CREATE mystream mygroup 0
-
-        # Client 1 reads item 1 from the stream without acknowledgements.
-        # Client 2 then claims pending item 1 from the PEL of client 1
-        set reply [
-            r XREADGROUP GROUP mygroup client1 count 1 STREAMS mystream >
-        ]
-        assert {[llength [lindex $reply 0 1 0 1]] == 2}
-        assert {[lindex $reply 0 1 0 1] eq {a 1}}
-        r debug sleep 0.2
-        set reply [
-            r XCLAIM mystream mygroup client2 10 $id1
-        ]
-        assert {[llength [lindex $reply 0 1]] == 2}
-        assert {[lindex $reply 0 1] eq {a 1}}
-
-        # Client 1 reads another 2 items from stream
-        r XREADGROUP GROUP mygroup client1 count 2 STREAMS mystream >
-        r debug sleep 0.2
-
-        # Delete item 2 from the stream. Now client 1 has PEL that contains
-        # only item 3. Try to use client 2 to claim the deleted item 2
-        # from the PEL of client 1, this should return nil
-        r XDEL mystream $id2
-        set reply [
-            r XCLAIM mystream mygroup client2 10 $id2
-        ]
-        assert {[llength $reply] == 1}
-        assert_equal "" [lindex $reply 0]
-
-        # Delete item 3 from the stream. Now client 1 has PEL that is empty.
-        # Try to use client 2 to claim the deleted item 3 from the PEL
-        # of client 1, this should return nil
-        r debug sleep 0.2
-        r XDEL mystream $id3
-        set reply [
-            r XCLAIM mystream mygroup client2 10 $id3
-        ]
-        assert {[llength $reply] == 1}
-        assert_equal "" [lindex $reply 0]
-    }
-
-    test {XCLAIM without JUSTID increments delivery count} {
-        # Add 3 items into the stream, and create a consumer group
-        r del mystream
-        set id1 [r XADD mystream * a 1]
-        set id2 [r XADD mystream * b 2]
-        set id3 [r XADD mystream * c 3]
-        r XGROUP CREATE mystream mygroup 0
-
-        # Client 1 reads item 1 from the stream without acknowledgements.
-        # Client 2 then claims pending item 1 from the PEL of client 1
-        set reply [
-            r XREADGROUP GROUP mygroup client1 count 1 STREAMS mystream >
-        ]
-        assert {[llength [lindex $reply 0 1 0 1]] == 2}
-        assert {[lindex $reply 0 1 0 1] eq {a 1}}
-        r debug sleep 0.2
-        set reply [
-            r XCLAIM mystream mygroup client2 10 $id1
-        ]
-        assert {[llength [lindex $reply 0 1]] == 2}
-        assert {[lindex $reply 0 1] eq {a 1}}
-
-        set reply [
-            r XPENDING mystream mygroup - + 10
-        ]
-        assert {[llength [lindex $reply 0]] == 4}
-        assert {[lindex $reply 0 3] == 2}
-
-        # Client 3 then claims pending item 1 from the PEL of client 2 using JUSTID
-        r debug sleep 0.2
-        set reply [
-            r XCLAIM mystream mygroup client3 10 $id1 JUSTID
-        ]
-        assert {[llength $reply] == 1}
-        assert {[lindex $reply 0] eq $id1}
-
-        set reply [
-            r XPENDING mystream mygroup - + 10
-        ]
-        assert {[llength [lindex $reply 0]] == 4}
-        assert {[lindex $reply 0 3] == 2}
-    }
-
-    start_server {} {
-        set master [srv -1 client]
-        set master_host [srv -1 host]
-        set master_port [srv -1 port]
-        set slave [srv 0 client]
-
-        foreach noack {0 1} {
-            test "Consumer group last ID propagation to slave (NOACK=$noack)" {
-                $slave slaveof $master_host $master_port
-                wait_for_condition 50 100 {
-                    [s 0 master_link_status] eq {up}
-                } else {
-                    fail "Replication not started."
-                }
-
-                $master del stream
-                $master xadd stream * a 1
-                $master xadd stream * a 2
-                $master xadd stream * a 3
-                $master xgroup create stream mygroup 0
-
-                # Consume the first two items on the master
-                for {set j 0} {$j < 2} {incr j} {
-                    if {$noack} {
-                        set item [$master xreadgroup group mygroup \
-                                  myconsumer COUNT 1 NOACK STREAMS stream >]
-                    } else {
-                        set item [$master xreadgroup group mygroup \
-                                  myconsumer COUNT 1 STREAMS stream >]
-                    }
-                    set id [lindex $item 0 1 0 0]
-                    if {$noack == 0} {
-                        assert {[$master xack stream mygroup $id] eq "1"}
-                    }
-                }
-
-                wait_for_ofs_sync $master $slave
-
-                # Turn slave into master
-                $slave slaveof no one
-
-                set item [$slave xreadgroup group mygroup myconsumer \
-                          COUNT 1 STREAMS stream >]
-
-                # The consumed enty should be the third
-                set myentry [lindex $item 0 1 0 1]
-                assert {$myentry eq {a 3}}
-            }
-        }
-    }
 }

tests/unit/type/stream.tcl

@@ -79,12 +79,6 @@ start_server {
         assert {[streamCompareID $id2 $id3] == -1}
     }
 
-    test {XADD IDs correctly report an error when overflowing} {
-        r DEL mystream
-        r xadd mystream 18446744073709551615-18446744073709551615 a b
-        assert_error ERR* {r xadd mystream * c d}
-    }
-
     test {XADD with MAXLEN option} {
         r DEL mystream
         for {set j 0} {$j < 1000} {incr j} {
@@ -123,12 +117,6 @@ start_server {
         assert {[r xlen mystream] == $j}
     }
 
-    test {XADD with ID 0-0} {
-        r DEL otherstream
-        catch {r XADD otherstream 0-0 k v} err
-        assert {[r EXISTS otherstream] == 0}
-    }
-
     test {XRANGE COUNT works as expected} {
         assert {[llength [r xrange mystream - + COUNT 10]] == 10}
     }
@@ -191,17 +179,6 @@ start_server {
         assert {[lindex $res 0 1 0 1] eq {old abcd1234}}
     }
 
-    test {Blocking XREAD will not reply with an empty array} {
-        r del s1
-        r XADD s1 666 f v
-        r XADD s1 667 f2 v2
-        r XDEL s1 667
-        set rd [redis_deferring_client]
-        $rd XREAD BLOCK 10 STREAMS s1 666
-        after 20
-        assert {[$rd read] == {}} ;# before the fix, client didn't even block, but was served synchronously with {s1 {}}
-    }
-
     test "XREAD: XADD + DEL should not awake client" {
         set rd [redis_deferring_client]
         r del s1
@@ -339,33 +316,6 @@ start_server {
 
         assert_equal [r xrevrange teststream2 1234567891245 -] {{1234567891240-0 {key1 value2}} {1234567891230-0 {key1 value1}}}
     }
-
-    test {XREAD streamID edge (no-blocking)} {
-        r del x
-        r XADD x 1-1 f v
-        r XADD x 1-18446744073709551615 f v
-        r XADD x 2-1 f v
-        set res [r XREAD BLOCK 0 STREAMS x 1-18446744073709551615]
-        assert {[lindex $res 0 1 0] == {2-1 {f v}}}
-    }
-
-    test {XREAD streamID edge (blocking)} {
-        r del x
-        set rd [redis_deferring_client]
-        $rd XREAD BLOCK 0 STREAMS x 1-18446744073709551615
-        r XADD x 1-1 f v
-        r XADD x 1-18446744073709551615 f v
-        r XADD x 2-1 f v
-        set res [$rd read]
-        assert {[lindex $res 0 1 0] == {2-1 {f v}}}
-    }
-
-    test {XADD streamID edge} {
-        r del x
-        r XADD x 2577343934890-18446744073709551615 f v ;# we need the timestamp to be in the future
-        r XADD x * f2 v2
-        assert_equal [r XRANGE x - +] {{2577343934890-18446744073709551615 {f v}} {2577343934891-0 {f2 v2}}}
-    }
 }
 
 start_server {tags {"stream"} overrides {appendonly yes}} {
@@ -405,59 +355,11 @@ start_server {tags {"stream"} overrides {appendonly yes stream-node-max-entries
             r XADD mystream * xitem v
         }
         r XTRIM mystream MAXLEN ~ 85
-        assert {[r xlen mystream] == 90}
+        assert {[r xlen mystream] == 89}
         r config set stream-node-max-entries 1
         r debug loadaof
         r XADD mystream * xitem v
         incr j
-        assert {[r xlen mystream] == 91}
-    }
-}
-
-start_server {tags {"xsetid"}} {
-    test {XADD can CREATE an empty stream} {
-        r XADD mystream MAXLEN 0 * a b
-        assert {[dict get [r xinfo stream mystream] length] == 0}
-    }
-
-    test {XSETID can set a specific ID} {
-        r XSETID mystream "200-0"
-        assert {[dict get [r xinfo stream mystream] last-generated-id] == "200-0"}
-    }
-
-    test {XSETID cannot SETID with smaller ID} {
-        r XADD mystream * a b
-        catch {r XSETID mystream "1-1"} err
-        r XADD mystream MAXLEN 0 * a b
-        set err
-    } {ERR*smaller*}
-
-    test {XSETID cannot SETID on non-existent key} {
-        catch {r XSETID stream 1-1} err
-        set _ $err
-    } {ERR no such key}
-}
-
-start_server {tags {"stream"} overrides {appendonly yes aof-use-rdb-preamble no}} {
-    test {Empty stream can be rewrite into AOF correctly} {
-        r XADD mystream MAXLEN 0 * a b
-        assert {[dict get [r xinfo stream mystream] length] == 0}
-        r bgrewriteaof
-        waitForBgrewriteaof r
-        r debug loadaof
-        assert {[dict get [r xinfo stream mystream] length] == 0}
-    }
-
-    test {Stream can be rewrite into AOF correctly after XDEL lastid} {
-        r XSETID mystream 0-0
-        r XADD mystream 1-1 a b
-        r XADD mystream 2-2 a b
-        assert {[dict get [r xinfo stream mystream] length] == 2}
-        r XDEL mystream 2-2
-        r bgrewriteaof
-        waitForBgrewriteaof r
-        r debug loadaof
-        assert {[dict get [r xinfo stream mystream] length] == 1}
-        assert {[dict get [r xinfo stream mystream] last-generated-id] == "2-2"}
+        assert {[r xlen mystream] == 90}
     }
 }

tests/unit/type/zset.tcl

@@ -388,7 +388,7 @@ start_server {tags {"zset"}} {
                               0 omega}
         }
 
-        test "ZRANGEBYLEX/ZREVRANGEBYLEX/ZLEXCOUNT basics" {
+        test "ZRANGEBYLEX/ZREVRANGEBYLEX/ZCOUNT basics" {
             create_default_lex_zset
 
             # inclusive range
@@ -416,22 +416,6 @@ start_server {tags {"zset"}} {
             assert_equal {} [r zrevrangebylex zset \[elez \[elex]
             assert_equal {} [r zrevrangebylex zset (hill (omega]
         }
-        
-        test "ZLEXCOUNT advanced" {
-            create_default_lex_zset
-    
-            assert_equal 9 [r zlexcount zset - +]
-            assert_equal 0 [r zlexcount zset + -]
-            assert_equal 0 [r zlexcount zset + \[c]
-            assert_equal 0 [r zlexcount zset \[c -]
-            assert_equal 8 [r zlexcount zset \[bar +]
-            assert_equal 5 [r zlexcount zset \[bar \[foo]
-            assert_equal 4 [r zlexcount zset \[bar (foo]
-            assert_equal 4 [r zlexcount zset (bar \[foo]
-            assert_equal 3 [r zlexcount zset (bar (foo]
-            assert_equal 5 [r zlexcount zset - (foo]
-            assert_equal 1 [r zlexcount zset (maxstring +]
-        }
 
         test "ZRANGEBYSLEX with LIMIT" {
             create_default_lex_zset

utils/corrupt_rdb.c

@@ -21,9 +21,8 @@ int main(int argc, char **argv) {
     }
 
     srand(time(NULL));
-    char *filename = argv[1];
     cycles = atoi(argv[2]);
-    fd = open(filename,O_RDWR);
+    fd = open("dump.rdb",O_RDWR);
     if (fd == -1) {
         perror("open");
         exit(1);

utils/releasetools/changelog.tcl

@@ -1,17 +1,12 @@
 #!/usr/bin/env tclsh
 
-if {[llength $::argv] != 2 && [llength $::argv] != 3} {
-    puts "Usage: $::argv0 <branch> <version> \[<num-commits>\]"
+if {[llength $::argv] != 2} {
+    puts "Usage: $::argv0 <branch> <version>"
     exit 1
 }
 
 set branch [lindex $::argv 0]
 set ver [lindex $::argv 1]
-if {[llength $::argv] == 3} {
-    set count [lindex ::$argv 2]
-} else {
-    set count 100
-}
 
 set template {
 ================================================================================
@@ -26,7 +21,7 @@ append template "\n\n"
 set date [clock format [clock seconds]]
 set template [string map [list %ver% $ver %date% $date] $template]
 
-append template [exec git log $branch~$count..$branch "--format=format:%an in commit %h:%n %s" --shortstat]
+append template [exec git log $branch~100..$branch "--format=format:%an in commit %h:%n %s" --shortstat]
 
 #Older, more verbose version.
 #