diff --git a/src/server.c b/src/server.c
new file mode 100644
index 000000000..3e83e5ebd
--- /dev/null
+++ b/src/server.c
@@ -0,0 +1,7160 @@
+/*
+ * Copyright (c) 2009-2016, Redis Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "server.h"
+#include "monotonic.h"
+#include "cluster.h"
+#include "cluster_slot_stats.h"
+#include "commandlog.h"
+#include "bio.h"
+#include "latency.h"
+#include "mt19937-64.h"
+#include "functions.h"
+#include "hdr_histogram.h"
+#include "syscheck.h"
+#include "threads_mngr.h"
+#include "fmtargs.h"
+#include "io_threads.h"
+#include "sds.h"
+#include "module.h"
+#include "scripting_engine.h"
+
+#include <time.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <arpa/inet.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/file.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <limits.h>
+#include <float.h>
+#include <math.h>
+#include <sys/utsname.h>
+#include <locale.h>
+#include <sys/socket.h>
+
+#ifdef __linux__
+#include <sys/mman.h>
+#endif
+
+#if defined(HAVE_SYSCTL_KIPC_SOMAXCONN) || defined(HAVE_SYSCTL_KERN_SOMAXCONN)
+#include <sys/sysctl.h>
+#endif
+
+#ifdef __GNUC__
+#define GNUC_VERSION_STR STRINGIFY(__GNUC__) "." STRINGIFY(__GNUC_MINOR__) "." STRINGIFY(__GNUC_PATCHLEVEL__)
+#else
+#define GNUC_VERSION_STR "0.0.0"
+#endif
+
+/* Our shared "common" objects */
+
+struct sharedObjectsStruct shared;
+
+/* Global vars that are actually used as constants. The following double
+ * values are used for double on-disk serialization, and are initialized
+ * at runtime to avoid strange compiler optimizations. */
+
+double R_Zero, R_PosInf, R_NegInf, R_Nan;
+
+/*================================= Globals ================================= */
+
+/* Global vars */
+struct valkeyServer server; /* Server global state */
+
+/*============================ Internal prototypes ========================== */
+
+static inline int isShutdownInitiated(void);
+int isReadyToShutdown(void);
+int finishShutdown(void);
+const char *replstateToString(int replstate);
+
+/*============================ Utility functions ============================ */
+
+/* This macro tells if we are in the context of loading an AOF. */
+#define isAOFLoadingContext() ((server.current_client && server.current_client->id == CLIENT_ID_AOF) ? 1 : 0)
+
+/* We use a private localtime implementation which is fork-safe. The logging
+ * function of the server may be called from other threads. */
+void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst);
+
+/* Formats the timezone offset into a string. daylight_active indicates whether dst is active (1)
+ * or not (0). */
+void formatTimezone(char *buf, size_t buflen, int timezone, int daylight_active) {
+    serverAssert(buflen >= 7);
+    serverAssert(timezone >= -50400 && timezone <= 43200);
+    // Adjust the timezone for daylight saving, if active
+    int total_offset = (-1) * timezone + 3600 * daylight_active;
+    int hours = abs(total_offset / 3600);
+    int minutes = abs(total_offset % 3600) / 60;
+    buf[0] = total_offset >= 0 ? '+' : '-';
+    buf[1] = '0' + hours / 10;
+    buf[2] = '0' + hours % 10;
+    buf[3] = ':';
+    buf[4] = '0' + minutes / 10;
+    buf[5] = '0' + minutes % 10;
+    buf[6] = '\0';
+}
+
+bool hasInvalidLogfmtChar(const char *msg) {
+    if (msg == NULL) return false;
+
+    for (int i = 0; msg[i] != '\0'; i++) {
+        if (msg[i] == '"' || msg[i] == '\n' || msg[i] == '\r') {
+            return true;
+        }
+    }
+    return false;
+}
+
+/* Modifies the input string by:
+ *      replacing \r and \n with whitespace
+ *      replacing " with '
+ *
+ * Parameters:
+ *   safemsg    - A char pointer where the modified message will be stored
+ *   safemsglen - size of safemsg
+ *   msg        - The original message */
+void filterInvalidLogfmtChar(char *safemsg, size_t safemsglen, const char *msg) {
+    serverAssert(safemsglen == LOG_MAX_LEN);
+    if (msg == NULL) return;
+
+    size_t index = 0;
+    while (index < safemsglen - 1 && msg[index] != '\0') {
+        if (msg[index] == '"') {
+            safemsg[index] = '\'';
+        } else if (msg[index] == '\n' || msg[index] == '\r') {
+            safemsg[index] = ' ';
+        } else {
+            safemsg[index] = msg[index];
+        }
+        index++;
+    }
+    safemsg[index] = '\0';
+}
+
+/* Low level logging. To use only for very big messages, otherwise
+ * serverLog() is to prefer. */
+void serverLogRaw(int level, const char *msg) {
+    const int syslogLevelMap[] = {LOG_DEBUG, LOG_INFO, LOG_NOTICE, LOG_WARNING};
+    const char *c = ".-*#";
+    const char *verbose_level[] = {"debug", "info", "notice", "warning"};
+    const char *roles[] = {"sentinel", "RDB/AOF", "replica", "primary"};
+    const char *role_chars = "XCSM";
+    FILE *fp;
+    char buf[64];
+    int rawmode = (level & LL_RAW);
+    int log_to_stdout = server.logfile[0] == '\0';
+
+    level &= 0xff; /* clear flags */
+    if (level < server.verbosity) return;
+
+    /* We open and close the log file in every call to support log rotation.
+     * This allows external processes to move or truncate the log file without
+     * disrupting logging. */
+    fp = log_to_stdout ? stdout : fopen(server.logfile, "a");
+    if (!fp) return;
+
+    if (rawmode) {
+        fprintf(fp, "%s", msg);
+    } else {
+        int off;
+        struct timeval tv;
+        pid_t pid = getpid();
+        int daylight_active = atomic_load_explicit(&server.daylight_active, memory_order_relaxed);
+
+        gettimeofday(&tv, NULL);
+        struct tm tm;
+        nolocks_localtime(&tm, tv.tv_sec, server.timezone, daylight_active);
+        switch (server.log_timestamp_format) {
+        case LOG_TIMESTAMP_LEGACY:
+            off = strftime(buf, sizeof(buf), "%d %b %Y %H:%M:%S.", &tm);
+            snprintf(buf + off, sizeof(buf) - off, "%03d", (int)tv.tv_usec / 1000);
+            break;
+
+        case LOG_TIMESTAMP_ISO8601:
+            off = strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S.", &tm);
+            char tzbuf[7];
+            formatTimezone(tzbuf, sizeof(tzbuf), server.timezone, server.daylight_active);
+            snprintf(buf + off, sizeof(buf) - off, "%03d%s", (int)tv.tv_usec / 1000, tzbuf);
+            break;
+
+        case LOG_TIMESTAMP_MILLISECONDS:
+            snprintf(buf, sizeof(buf), "%lld", (long long)tv.tv_sec * 1000 + (long long)tv.tv_usec / 1000);
+            break;
+        }
+        int role_index;
+        if (server.sentinel_mode) {
+            role_index = 0; /* Sentinel. */
+        } else if (pid != server.pid) {
+            role_index = 1; /* RDB / AOF writing child. */
+        } else {
+            role_index = (server.primary_host ? 2 : 3); /* Replica or Primary. */
+        }
+        switch (server.log_format) {
+        case LOG_FORMAT_LOGFMT:
+            if (hasInvalidLogfmtChar(msg)) {
+                char safemsg[LOG_MAX_LEN];
+                filterInvalidLogfmtChar(safemsg, LOG_MAX_LEN, msg);
+                fprintf(fp, "pid=%d role=%s timestamp=\"%s\" level=%s message=\"%s\"\n", (int)getpid(), roles[role_index],
+                        buf, verbose_level[level], safemsg);
+            } else {
+                fprintf(fp, "pid=%d role=%s timestamp=\"%s\" level=%s message=\"%s\"\n", (int)getpid(), roles[role_index],
+                        buf, verbose_level[level], msg);
+            }
+            break;
+
+        case LOG_FORMAT_LEGACY:
+            fprintf(fp, "%d:%c %s %c %s\n", (int)getpid(), role_chars[role_index], buf, c[level], msg);
+            break;
+        }
+    }
+    fflush(fp);
+
+    if (!log_to_stdout) fclose(fp);
+    if (server.syslog_enabled) syslog(syslogLevelMap[level], "%s", msg);
+}
+
+/* Like serverLogRaw() but with printf-alike support. This is the function that
+ * is used across the code. The raw version is only used in order to dump
+ * the INFO output on crash. */
+void _serverLog(int level, const char *fmt, ...) {
+    va_list ap;
+    char msg[LOG_MAX_LEN];
+
+    va_start(ap, fmt);
+    vsnprintf(msg, sizeof(msg), fmt, ap);
+    va_end(ap);
+
+    serverLogRaw(level, msg);
+}
+
+/* Low level logging from signal handler. Should be used with pre-formatted strings.
+   See serverLogFromHandler. */
+void serverLogRawFromHandler(int level, const char *msg) {
+    int fd;
+    int log_to_stdout = server.logfile[0] == '\0';
+    char buf[64];
+
+    if ((level & 0xff) < server.verbosity || (log_to_stdout && server.daemonize)) return;
+    fd = log_to_stdout ? STDOUT_FILENO : open(server.logfile, O_APPEND | O_CREAT | O_WRONLY, 0644);
+    if (fd == -1) return;
+    if (level & LL_RAW) {
+        if (write(fd, msg, strlen(msg)) == -1) goto err;
+    } else {
+        ll2string(buf, sizeof(buf), getpid());
+        if (write(fd, buf, strlen(buf)) == -1) goto err;
+        if (write(fd, ":signal-handler (", 17) == -1) goto err;
+        ll2string(buf, sizeof(buf), time(NULL));
+        if (write(fd, buf, strlen(buf)) == -1) goto err;
+        if (write(fd, ") ", 2) == -1) goto err;
+        if (write(fd, msg, strlen(msg)) == -1) goto err;
+        if (write(fd, "\n", 1) == -1) goto err;
+    }
+err:
+    if (!log_to_stdout) close(fd);
+}
+
+/* An async-signal-safe version of serverLog. if LL_RAW is not included in level flags,
+ * The message format is: <pid>:signal-handler (<time>) <msg> \n
+ * with LL_RAW flag only the msg is printed (with no new line at the end)
+ *
+ * We actually use this only for signals that are not fatal from the point
+ * of view of the server. Signals that are going to kill the server anyway and
+ * where we need printf-alike features are served by serverLog(). */
+void serverLogFromHandler(int level, const char *fmt, ...) {
+    va_list ap;
+    char msg[LOG_MAX_LEN];
+
+    va_start(ap, fmt);
+    vsnprintf_async_signal_safe(msg, sizeof(msg), fmt, ap);
+    va_end(ap);
+
+    serverLogRawFromHandler(level, msg);
+}
+
+/* Return the UNIX time in microseconds */
+long long ustime(void) {
+    struct timeval tv;
+    long long ust;
+
+    gettimeofday(&tv, NULL);
+    ust = ((long long)tv.tv_sec) * 1000000;
+    ust += tv.tv_usec;
+    return ust;
+}
+
+/* Return the UNIX time in milliseconds */
+mstime_t mstime(void) {
+    return ustime() / 1000;
+}
+
+/* Return the command time snapshot in milliseconds.
+ * The time the command started is the logical time it runs,
+ * and all the time readings during the execution time should
+ * reflect the same time.
+ * More details can be found in the comments below. */
+mstime_t commandTimeSnapshot(void) {
+    /* When we are in the middle of a command execution, we 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.
+     * This is specifically important in the context of scripts, where we
+     * pretend that time freezes. 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 replicas / AOF consistent. See issue #1525 for more info.
+     * Note that we cannot use the cached server.mstime because it can change
+     * in processEventsWhileBlocked etc. */
+    return server.cmd_time_snapshot;
+}
+
+/* After an RDB dump or AOF rewrite we exit from children using _exit() instead of
+ * exit(), because the latter may interact with the same file objects used by
+ * the parent process. However if we are testing the coverage normal exit() is
+ * used in order to obtain the right coverage information. */
+void exitFromChild(int retcode) {
+#ifdef COVERAGE_TEST
+    exit(retcode);
+#else
+    _exit(retcode);
+#endif
+}
+
+/*====================== Hash table type implementation  ==================== */
+
+/* This is a hash table type that uses the SDS dynamic strings library as
+ * keys and Objects as values (Objects can hold SDS strings,
+ * lists, sets). */
+
+void dictVanillaFree(void *val) {
+    zfree(val);
+}
+
+void dictListDestructor(void *val) {
+    listRelease((list *)val);
+}
+
+void dictDictDestructor(void *val) {
+    dictRelease((dict *)val);
+}
+
+/* Returns 1 when keys match */
+int dictSdsKeyCompare(const void *key1, const void *key2) {
+    int l1, l2;
+    l1 = sdslen((sds)key1);
+    l2 = sdslen((sds)key2);
+    if (l1 != l2) return 0;
+    return memcmp(key1, key2, l1) == 0;
+}
+
+/* Returns 0 when keys match */
+int hashtableSdsKeyCompare(const void *key1, const void *key2) {
+    const sds sds1 = (const sds)key1, sds2 = (const sds)key2;
+    return sdslen(sds1) != sdslen(sds2) || sdscmp(sds1, sds2);
+}
+
+size_t dictSdsEmbedKey(unsigned char *buf, size_t buf_len, const void *key, uint8_t *key_offset) {
+    return sdscopytobuffer(buf, buf_len, (sds)key, key_offset);
+}
+
+/* A case insensitive version used for the command lookup table and other
+ * places where case insensitive non binary-safe comparison is needed. */
+int dictSdsKeyCaseCompare(const void *key1, const void *key2) {
+    return strcasecmp(key1, key2) == 0;
+}
+
+/* Case insensitive key comparison */
+int hashtableStringKeyCaseCompare(const void *key1, const void *key2) {
+    return strcasecmp(key1, key2);
+}
+
+void dictObjectDestructor(void *val) {
+    if (val == NULL) return; /* Lazy freeing will set value to NULL. */
+    decrRefCount(val);
+}
+
+void dictSdsDestructor(void *val) {
+    sdsfree(val);
+}
+
+void *dictSdsDup(const void *key) {
+    return sdsdup((const sds)key);
+}
+
+int dictObjKeyCompare(const void *key1, const void *key2) {
+    const robj *o1 = key1, *o2 = key2;
+    return dictSdsKeyCompare(o1->ptr, o2->ptr);
+}
+
+uint64_t dictObjHash(const void *key) {
+    const robj *o = key;
+    return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
+}
+
+uint64_t dictSdsHash(const void *key) {
+    return dictGenHashFunction((unsigned char *)key, sdslen((char *)key));
+}
+
+uint64_t dictSdsCaseHash(const void *key) {
+    return dictGenCaseHashFunction((unsigned char *)key, sdslen((char *)key));
+}
+
+/* Dict hash function for null terminated string */
+uint64_t dictCStrHash(const void *key) {
+    return dictGenHashFunction((unsigned char *)key, strlen((char *)key));
+}
+
+/* Dict hash function for null terminated string */
+uint64_t dictCStrCaseHash(const void *key) {
+    return dictGenCaseHashFunction((unsigned char *)key, strlen((char *)key));
+}
+
+/* Dict hash function for client */
+uint64_t dictClientHash(const void *key) {
+    return ((client *)key)->id;
+}
+
+/* Dict compare function for client */
+int dictClientKeyCompare(const void *key1, const void *key2) {
+    return ((client *)key1)->id == ((client *)key2)->id;
+}
+
+/* Dict compare function for null terminated string */
+int dictCStrKeyCompare(const void *key1, const void *key2) {
+    int l1, l2;
+    l1 = strlen((char *)key1);
+    l2 = strlen((char *)key2);
+    if (l1 != l2) return 0;
+    return memcmp(key1, key2, l1) == 0;
+}
+
+/* Dict case insensitive compare function for null terminated string */
+int dictCStrKeyCaseCompare(const void *key1, const void *key2) {
+    return strcasecmp(key1, key2) == 0;
+}
+
+int dictEncObjKeyCompare(const void *key1, const void *key2) {
+    robj *o1 = (robj *)key1, *o2 = (robj *)key2;
+    int cmp;
+
+    if (o1->encoding == OBJ_ENCODING_INT && o2->encoding == OBJ_ENCODING_INT) return o1->ptr == o2->ptr;
+
+    /* Due to OBJ_STATIC_REFCOUNT, we avoid calling getDecodedObject() without
+     * good reasons, because it would incrRefCount() the object, which
+     * is invalid. So we check to make sure dictFind() works with static
+     * objects as well. */
+    if (o1->refcount != OBJ_STATIC_REFCOUNT) o1 = getDecodedObject(o1);
+    if (o2->refcount != OBJ_STATIC_REFCOUNT) o2 = getDecodedObject(o2);
+    cmp = dictSdsKeyCompare(o1->ptr, o2->ptr);
+    if (o1->refcount != OBJ_STATIC_REFCOUNT) decrRefCount(o1);
+    if (o2->refcount != OBJ_STATIC_REFCOUNT) decrRefCount(o2);
+    return cmp;
+}
+
+uint64_t dictEncObjHash(const void *key) {
+    robj *o = (robj *)key;
+
+    if (sdsEncodedObject(o)) {
+        return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
+    } else if (o->encoding == OBJ_ENCODING_INT) {
+        char buf[32];
+        int len;
+
+        len = ll2string(buf, 32, (long)o->ptr);
+        return dictGenHashFunction((unsigned char *)buf, len);
+    } else {
+        serverPanic("Unknown string encoding");
+    }
+}
+
+/* Return 1 if we allow a hash table to expand. It may allocate a huge amount of
+ * memory to contain hash buckets when it expands, that may lead the server to
+ * reject user's requests or evict some keys. We can prevent expansion
+ * provisionally if used memory will be over maxmemory after it expands,
+ * but to guarantee the performance of the server, we still allow it to expand
+ * if the load factor exceeds the hard limit defined in hashtable.c. */
+int hashtableResizeAllowed(size_t moreMem, double usedRatio) {
+    UNUSED(usedRatio);
+
+    /* For debug purposes, not allowed to be resized. */
+    if (!server.dict_resizing) return 0;
+
+    /* Avoid resizing over max memory. */
+    return !overMaxmemoryAfterAlloc(moreMem);
+}
+
+const void *hashtableCommandGetKey(const void *element) {
+    struct serverCommand *command = (struct serverCommand *)element;
+    return command->fullname;
+}
+
+const void *hashtableSubcommandGetKey(const void *element) {
+    struct serverCommand *command = (struct serverCommand *)element;
+    return command->declared_name;
+}
+
+/* Generic hash table type where keys are Objects, Values
+ * dummy pointers. */
+dictType objectKeyPointerValueDictType = {
+    dictEncObjHash,       /* hash function */
+    NULL,                 /* key dup */
+    dictEncObjKeyCompare, /* key compare */
+    dictObjectDestructor, /* key destructor */
+    NULL,                 /* val destructor */
+    NULL                  /* allow to expand */
+};
+
+/* Like objectKeyPointerValueDictType(), but values can be destroyed, if
+ * not NULL, calling zfree(). */
+dictType objectKeyHeapPointerValueDictType = {
+    dictEncObjHash,       /* hash function */
+    NULL,                 /* key dup */
+    dictEncObjKeyCompare, /* key compare */
+    dictObjectDestructor, /* key destructor */
+    dictVanillaFree,      /* val destructor */
+    NULL                  /* allow to expand */
+};
+
+/* Set hashtable type. Items are SDS strings */
+hashtableType setHashtableType = {
+    .hashFunction = dictSdsHash,
+    .keyCompare = hashtableSdsKeyCompare,
+    .entryDestructor = dictSdsDestructor};
+
+const void *zsetHashtableGetKey(const void *element) {
+    const zskiplistNode *node = element;
+    return node->ele;
+}
+
+/* Sorted sets hash (note: a skiplist is used in addition to the hash table) */
+hashtableType zsetHashtableType = {
+    .hashFunction = dictSdsHash,
+    .entryGetKey = zsetHashtableGetKey,
+    .keyCompare = hashtableSdsKeyCompare,
+};
+
+uint64_t hashtableSdsHash(const void *key) {
+    return hashtableGenHashFunction((const char *)key, sdslen((char *)key));
+}
+
+const void *hashtableObjectGetKey(const void *entry) {
+    return objectGetKey(entry);
+}
+
+/* Prefetch the value if it's not embedded. */
+void hashtableObjectPrefetchValue(const void *entry) {
+    const robj *obj = entry;
+    if (obj->encoding != OBJ_ENCODING_EMBSTR &&
+        obj->encoding != OBJ_ENCODING_INT) {
+        valkey_prefetch(obj->ptr);
+    }
+}
+
+int hashtableObjKeyCompare(const void *key1, const void *key2) {
+    const robj *o1 = key1, *o2 = key2;
+    return hashtableSdsKeyCompare(o1->ptr, o2->ptr);
+}
+
+void hashtableObjectDestructor(void *val) {
+    if (val == NULL) return; /* Lazy freeing will set value to NULL. */
+    decrRefCount(val);
+}
+
+/* Kvstore->keys, keys are sds strings, vals are Objects. */
+hashtableType kvstoreKeysHashtableType = {
+    .entryPrefetchValue = hashtableObjectPrefetchValue,
+    .entryGetKey = hashtableObjectGetKey,
+    .hashFunction = hashtableSdsHash,
+    .keyCompare = hashtableSdsKeyCompare,
+    .entryDestructor = hashtableObjectDestructor,
+    .resizeAllowed = hashtableResizeAllowed,
+    .rehashingStarted = kvstoreHashtableRehashingStarted,
+    .rehashingCompleted = kvstoreHashtableRehashingCompleted,
+    .trackMemUsage = kvstoreHashtableTrackMemUsage,
+    .getMetadataSize = kvstoreHashtableMetadataSize,
+};
+
+/* Kvstore->expires */
+hashtableType kvstoreExpiresHashtableType = {
+    .entryPrefetchValue = hashtableObjectPrefetchValue,
+    .entryGetKey = hashtableObjectGetKey,
+    .hashFunction = hashtableSdsHash,
+    .keyCompare = hashtableSdsKeyCompare,
+    .entryDestructor = NULL, /* shared with keyspace table */
+    .resizeAllowed = hashtableResizeAllowed,
+    .rehashingStarted = kvstoreHashtableRehashingStarted,
+    .rehashingCompleted = kvstoreHashtableRehashingCompleted,
+    .trackMemUsage = kvstoreHashtableTrackMemUsage,
+    .getMetadataSize = kvstoreHashtableMetadataSize,
+};
+
+/* Command set, hashed by sds string, stores serverCommand structs. */
+hashtableType commandSetType = {.entryGetKey = hashtableCommandGetKey,
+                                .hashFunction = dictSdsCaseHash,
+                                .keyCompare = hashtableStringKeyCaseCompare,
+                                .instant_rehashing = 1};
+
+/* Sub-command set, hashed by char* string, stores serverCommand structs. */
+hashtableType subcommandSetType = {.entryGetKey = hashtableSubcommandGetKey,
+                                   .hashFunction = dictCStrCaseHash,
+                                   .keyCompare = hashtableStringKeyCaseCompare,
+                                   .instant_rehashing = 1};
+
+/* Hash type hash table (note that small hashes are represented with listpacks) */
+const void *hashHashtableTypeGetKey(const void *entry) {
+    const hashTypeEntry *hash_entry = entry;
+    return (const void *)hashTypeEntryGetField(hash_entry);
+}
+
+void hashHashtableTypeDestructor(void *entry) {
+    hashTypeEntry *hash_entry = entry;
+    freeHashTypeEntry(hash_entry);
+}
+
+hashtableType hashHashtableType = {
+    .hashFunction = dictSdsHash,
+    .entryGetKey = hashHashtableTypeGetKey,
+    .keyCompare = hashtableSdsKeyCompare,
+    .entryDestructor = hashHashtableTypeDestructor,
+};
+
+/* Hash type hash table (note that small hashes are represented with listpacks) */
+dictType hashDictType = {
+    dictSdsHash,       /* hash function */
+    NULL,              /* key dup */
+    dictSdsKeyCompare, /* key compare */
+    dictSdsDestructor, /* key destructor */
+    dictSdsDestructor, /* val destructor */
+    NULL,              /* allow to expand */
+};
+
+/* Dict type without destructor */
+dictType sdsReplyDictType = {
+    dictSdsHash,       /* hash function */
+    NULL,              /* key dup */
+    dictSdsKeyCompare, /* key compare */
+    NULL,              /* key destructor */
+    NULL,              /* val destructor */
+    NULL               /* allow to expand */
+};
+
+/* Hashtable type without destructor */
+hashtableType sdsReplyHashtableType = {
+    .hashFunction = dictSdsCaseHash,
+    .keyCompare = hashtableSdsKeyCompare};
+
+/* Keylist hash table type has unencoded Objects as keys and
+ * lists as values. It's used for blocking operations (BLPOP) and to
+ * map swapped keys to a list of clients waiting for this keys to be loaded. */
+dictType keylistDictType = {
+    dictObjHash,          /* hash function */
+    NULL,                 /* key dup */
+    dictObjKeyCompare,    /* key compare */
+    dictObjectDestructor, /* key destructor */
+    dictListDestructor,   /* val destructor */
+    NULL                  /* allow to expand */
+};
+
+/* KeyDict hash table type has unencoded Objects as keys and
+ * dicts as values. It's used for PUBSUB command to track clients subscribing the patterns. */
+dictType objToDictDictType = {
+    dictObjHash,          /* hash function */
+    NULL,                 /* key dup */
+    dictObjKeyCompare,    /* key compare */
+    dictObjectDestructor, /* key destructor */
+    dictDictDestructor,   /* val destructor */
+    NULL                  /* allow to expand */
+};
+
+/* Callback used for hash tables where the entries are dicts and the key
+ * (channel name) is stored in each dict's metadata. */
+const void *hashtableChannelsDictGetKey(const void *entry) {
+    const dict *d = entry;
+    return *((const void **)dictMetadata(d));
+}
+
+void hashtableChannelsDictDestructor(void *entry) {
+    dict *d = entry;
+    robj *channel = *((void **)dictMetadata(d));
+    decrRefCount(channel);
+    dictRelease(d);
+}
+
+/* Similar to objToDictDictType, but changed to hashtable and added some kvstore
+ * callbacks, it's used for PUBSUB command to track clients subscribing the
+ * channels. The elements are dicts where the keys are clients. The metadata in
+ * each dict stores a pointer to the channel name. */
+hashtableType kvstoreChannelHashtableType = {
+    .entryGetKey = hashtableChannelsDictGetKey,
+    .hashFunction = dictObjHash,
+    .keyCompare = hashtableObjKeyCompare,
+    .entryDestructor = hashtableChannelsDictDestructor,
+    .rehashingStarted = kvstoreHashtableRehashingStarted,
+    .rehashingCompleted = kvstoreHashtableRehashingCompleted,
+    .trackMemUsage = kvstoreHashtableTrackMemUsage,
+    .getMetadataSize = kvstoreHashtableMetadataSize,
+};
+
+/* Modules system dictionary type. Keys are module name,
+ * values are pointer to ValkeyModule struct. */
+dictType modulesDictType = {
+    dictSdsCaseHash,       /* hash function */
+    NULL,                  /* key dup */
+    dictSdsKeyCaseCompare, /* key compare */
+    dictSdsDestructor,     /* key destructor */
+    NULL,                  /* val destructor */
+    NULL                   /* allow to expand */
+};
+
+/* Migrate cache dict type. */
+dictType migrateCacheDictType = {
+    dictSdsHash,       /* hash function */
+    NULL,              /* key dup */
+    dictSdsKeyCompare, /* key compare */
+    dictSdsDestructor, /* key destructor */
+    NULL,              /* val destructor */
+    NULL               /* allow to expand */
+};
+
+/* Dict for for case-insensitive search using null terminated C strings.
+ * The keys stored in dict are sds though. */
+dictType stringSetDictType = {
+    dictCStrCaseHash,       /* hash function */
+    NULL,                   /* key dup */
+    dictCStrKeyCaseCompare, /* key compare */
+    dictSdsDestructor,      /* key destructor */
+    NULL,                   /* val destructor */
+    NULL                    /* allow to expand */
+};
+
+/* Dict for for case-insensitive search using null terminated C strings.
+ * The key and value do not have a destructor. */
+dictType externalStringType = {
+    dictCStrCaseHash,       /* hash function */
+    NULL,                   /* key dup */
+    dictCStrKeyCaseCompare, /* key compare */
+    NULL,                   /* key destructor */
+    NULL,                   /* val destructor */
+    NULL                    /* allow to expand */
+};
+
+/* Dict for case-insensitive search using sds objects with a zmalloc
+ * allocated object as the value. */
+dictType sdsHashDictType = {
+    dictSdsCaseHash,       /* hash function */
+    NULL,                  /* key dup */
+    dictSdsKeyCaseCompare, /* key compare */
+    dictSdsDestructor,     /* key destructor */
+    dictVanillaFree,       /* val destructor */
+    NULL                   /* allow to expand */
+};
+
+size_t clientSetDictTypeMetadataBytes(dict *d) {
+    UNUSED(d);
+    return sizeof(void *);
+}
+
+/* Client Set dictionary type. Keys are client, values are not used. */
+dictType clientDictType = {
+    dictClientHash,       /* hash function */
+    NULL,                 /* key dup */
+    dictClientKeyCompare, /* key compare */
+    .dictMetadataBytes = clientSetDictTypeMetadataBytes,
+    .no_value = 1 /* no values in this dict */
+};
+
+/* This function is called once a background process of some kind terminates,
+ * as we want to avoid resizing the hash tables when there is a child in order
+ * to play well with copy-on-write (otherwise when a resize happens lots of
+ * memory pages are copied). The goal of this function is to update the ability
+ * for dict.c to resize or rehash the tables accordingly to the fact we have an
+ * active fork child running. */
+void updateDictResizePolicy(void) {
+    if (server.in_fork_child != CHILD_TYPE_NONE) {
+        dictSetResizeEnabled(DICT_RESIZE_FORBID);
+        hashtableSetResizePolicy(HASHTABLE_RESIZE_FORBID);
+    } else if (hasActiveChildProcess()) {
+        dictSetResizeEnabled(DICT_RESIZE_AVOID);
+        hashtableSetResizePolicy(HASHTABLE_RESIZE_AVOID);
+    } else {
+        dictSetResizeEnabled(DICT_RESIZE_ENABLE);
+        hashtableSetResizePolicy(HASHTABLE_RESIZE_ALLOW);
+    }
+}
+
+const char *strChildType(int type) {
+    switch (type) {
+    case CHILD_TYPE_RDB: return "RDB";
+    case CHILD_TYPE_AOF: return "AOF";
+    case CHILD_TYPE_LDB: return "LDB";
+    case CHILD_TYPE_MODULE: return "MODULE";
+    default: return "Unknown";
+    }
+}
+
+/* Return true if there are active children processes doing RDB saving,
+ * AOF rewriting, or some side process spawned by a loaded module. */
+int hasActiveChildProcess(void) {
+    return server.child_pid != -1;
+}
+
+void resetChildState(void) {
+    server.child_type = CHILD_TYPE_NONE;
+    server.child_pid = -1;
+    server.stat_current_cow_peak = 0;
+    server.stat_current_cow_bytes = 0;
+    server.stat_current_cow_updated = 0;
+    server.stat_current_save_keys_processed = 0;
+    server.stat_module_progress = 0;
+    server.stat_current_save_keys_total = 0;
+    updateDictResizePolicy();
+    closeChildInfoPipe();
+    moduleFireServerEvent(VALKEYMODULE_EVENT_FORK_CHILD, VALKEYMODULE_SUBEVENT_FORK_CHILD_DIED, NULL);
+}
+
+/* Return if child type is mutually exclusive with other fork children */
+int isMutuallyExclusiveChildType(int type) {
+    return type == CHILD_TYPE_RDB || type == CHILD_TYPE_AOF || type == CHILD_TYPE_MODULE;
+}
+
+/* Returns true when we're inside a long command that yielded to the event loop. */
+int isInsideYieldingLongCommand(void) {
+    return scriptIsTimedout() || server.busy_module_yield_flags;
+}
+
+/* Return true if this instance has persistence completely turned off:
+ * both RDB and AOF are disabled. */
+int allPersistenceDisabled(void) {
+    return server.saveparamslen == 0 && server.aof_state == AOF_OFF;
+}
+
+/* ======================= Cron: called every 100 ms ======================== */
+
+/* Add a sample to the instantaneous metric. This function computes the quotient
+ * of the increment of value and base, which is useful to record operation count
+ * per second, or the average time consumption of an operation.
+ *
+ * current_value - The dividend
+ * current_base - The divisor
+ * */
+void trackInstantaneousMetric(int metric, long long current_value, long long current_base, long long factor) {
+    if (server.inst_metric[metric].last_sample_base > 0) {
+        long long base = current_base - server.inst_metric[metric].last_sample_base;
+        long long value = current_value - server.inst_metric[metric].last_sample_value;
+        long long avg = base > 0 ? (value * factor / base) : 0;
+        server.inst_metric[metric].samples[server.inst_metric[metric].idx] = avg;
+        server.inst_metric[metric].idx++;
+        server.inst_metric[metric].idx %= STATS_METRIC_SAMPLES;
+    }
+    server.inst_metric[metric].last_sample_base = current_base;
+    server.inst_metric[metric].last_sample_value = current_value;
+}
+
+/* Return the mean of all the samples. */
+long long getInstantaneousMetric(int metric) {
+    int j;
+    long long sum = 0;
+
+    for (j = 0; j < STATS_METRIC_SAMPLES; j++) sum += server.inst_metric[metric].samples[j];
+    return sum / STATS_METRIC_SAMPLES;
+}
+
+/* The client query buffer is an sds.c string that can end with a lot of
+ * free space not used, this function reclaims space if needed.
+ *
+ * The function always returns 0 as it never terminates the client. */
+int clientsCronResizeQueryBuffer(client *c) {
+    /* If the client query buffer is NULL, it is using the shared query buffer and there is nothing to do. */
+    if (c->querybuf == NULL) return 0;
+    size_t querybuf_size = sdsalloc(c->querybuf);
+    time_t idletime = server.unixtime - c->last_interaction;
+
+    /* Only resize the query buffer if the buffer is actually wasting at least a
+     * few kbytes */
+    if (sdsavail(c->querybuf) > 1024 * 4) {
+        /* There are two conditions to resize the query buffer: */
+        if (idletime > 2) {
+            /* 1) Query is idle for a long time. */
+            size_t remaining = sdslen(c->querybuf) - c->qb_pos;
+            if (!c->flag.primary && !remaining) {
+                /* If the client is not a primary and no data is pending,
+                 * The client can safely use the shared query buffer in the next read - free the client's querybuf. */
+                sdsfree(c->querybuf);
+                /* By setting the querybuf to NULL, the client will use the shared query buffer in the next read.
+                 * We don't move the client to the shared query buffer immediately, because if we allocated a private
+                 * query buffer for the client, it's likely that the client will use it again soon. */
+                c->querybuf = NULL;
+            } else {
+                c->querybuf = sdsRemoveFreeSpace(c->querybuf, 1);
+            }
+        } else if (querybuf_size > PROTO_RESIZE_THRESHOLD && querybuf_size / 2 > c->querybuf_peak) {
+            /* 2) Query buffer is too big for latest peak and is larger than
+             *    resize threshold. Trim excess space but only up to a limit,
+             *    not below the recent peak and current c->querybuf (which will
+             *    be soon get used). If we're in the middle of a bulk then make
+             *    sure not to resize to less than the bulk length. */
+            size_t resize = sdslen(c->querybuf);
+            if (resize < c->querybuf_peak) resize = c->querybuf_peak;
+            if (c->bulklen != -1 && resize < (size_t)c->bulklen + 2) resize = c->bulklen + 2;
+            c->querybuf = sdsResize(c->querybuf, resize, 1);
+        }
+    }
+
+    /* Reset the peak again to capture the peak memory usage in the next
+     * cycle. */
+    c->querybuf_peak = c->querybuf ? sdslen(c->querybuf) : 0;
+    /* We reset to either the current used, or currently processed bulk size,
+     * which ever is bigger. */
+    if (c->bulklen != -1 && (size_t)c->bulklen + 2 > c->querybuf_peak) c->querybuf_peak = c->bulklen + 2;
+    return 0;
+}
+
+/* The client output buffer can be adjusted to better fit the memory requirements.
+ *
+ * the logic is:
+ * in case the last observed peak size of the buffer equals the buffer size - we double the size
+ * in case the last observed peak size of the buffer is less than half the buffer size - we shrink by half.
+ * The buffer peak will be reset back to the buffer position every server.reply_buffer_peak_reset_time milliseconds
+ * The function always returns 0 as it never terminates the client. */
+int clientsCronResizeOutputBuffer(client *c, mstime_t now_ms) {
+    if (c->io_write_state != CLIENT_IDLE) return 0;
+
+    size_t new_buffer_size = 0;
+    char *oldbuf = NULL;
+    const size_t buffer_target_shrink_size = c->buf_usable_size / 2;
+    const size_t buffer_target_expand_size = c->buf_usable_size * 2;
+
+    /* in case the resizing is disabled return immediately */
+    if (!server.reply_buffer_resizing_enabled) return 0;
+
+    if (buffer_target_shrink_size >= PROTO_REPLY_MIN_BYTES && c->buf_peak < buffer_target_shrink_size) {
+        new_buffer_size = max(PROTO_REPLY_MIN_BYTES, c->buf_peak + 1);
+        server.stat_reply_buffer_shrinks++;
+    } else if (buffer_target_expand_size < PROTO_REPLY_CHUNK_BYTES * 2 && c->buf_peak == c->buf_usable_size) {
+        new_buffer_size = min(PROTO_REPLY_CHUNK_BYTES, buffer_target_expand_size);
+        server.stat_reply_buffer_expands++;
+    }
+
+    serverAssertWithInfo(c, NULL, (!new_buffer_size) || (new_buffer_size >= (size_t)c->bufpos));
+
+    /* reset the peak value each server.reply_buffer_peak_reset_time seconds. in case the client will be idle
+     * it will start to shrink.
+     */
+    if (server.reply_buffer_peak_reset_time >= 0 &&
+        now_ms - c->buf_peak_last_reset_time >= server.reply_buffer_peak_reset_time) {
+        c->buf_peak = c->bufpos;
+        c->buf_peak_last_reset_time = now_ms;
+    }
+
+    if (new_buffer_size) {
+        oldbuf = c->buf;
+        size_t oldbuf_size = c->buf_usable_size;
+        c->buf = zmalloc_usable(new_buffer_size, &c->buf_usable_size);
+        memcpy(c->buf, oldbuf, c->bufpos);
+        zfree_with_size(oldbuf, oldbuf_size);
+    }
+    return 0;
+}
+
+/* This function is used in order to track clients using the biggest amount
+ * of memory in the latest few seconds. This way we can provide such information
+ * in the INFO output (clients section), without having to do an O(N) scan for
+ * all the clients.
+ *
+ * This is how it works. We have an array of CLIENTS_PEAK_MEM_USAGE_SLOTS slots
+ * where we track, for each, the biggest client output and input buffers we
+ * saw in that slot. Every slot corresponds to one of the latest seconds, since
+ * the array is indexed by doing UNIXTIME % CLIENTS_PEAK_MEM_USAGE_SLOTS.
+ *
+ * When we want to know what was recently the peak memory usage, we just scan
+ * such few slots searching for the maximum value. */
+#define CLIENTS_PEAK_MEM_USAGE_SLOTS 8
+size_t ClientsPeakMemInput[CLIENTS_PEAK_MEM_USAGE_SLOTS] = {0};
+size_t ClientsPeakMemOutput[CLIENTS_PEAK_MEM_USAGE_SLOTS] = {0};
+
+int clientsCronTrackExpansiveClients(client *c, int time_idx) {
+    size_t qb_size = c->querybuf ? sdsAllocSize(c->querybuf) : 0;
+    size_t argv_size = c->argv ? zmalloc_size(c->argv) : 0;
+    size_t in_usage = qb_size + c->argv_len_sum + argv_size;
+    size_t out_usage = getClientOutputBufferMemoryUsage(c);
+
+    /* Track the biggest values observed so far in this slot. */
+    if (in_usage > ClientsPeakMemInput[time_idx]) ClientsPeakMemInput[time_idx] = in_usage;
+    if (out_usage > ClientsPeakMemOutput[time_idx]) ClientsPeakMemOutput[time_idx] = out_usage;
+
+    return 0; /* This function never terminates the client. */
+}
+
+/* All normal clients are placed in one of the "mem usage buckets" according
+ * to how much memory they currently use. We use this function to find the
+ * appropriate bucket based on a given memory usage value. The algorithm simply
+ * does a log2(mem) to ge the bucket. This means, for examples, that if a
+ * client's memory usage doubles it's moved up to the next bucket, if it's
+ * halved we move it down a bucket.
+ * For more details see CLIENT_MEM_USAGE_BUCKETS documentation in server.h. */
+static inline clientMemUsageBucket *getMemUsageBucket(size_t mem) {
+    int size_in_bits = 8 * (int)sizeof(mem);
+    int clz = mem > 0 ? __builtin_clzl(mem) : size_in_bits;
+    int bucket_idx = size_in_bits - clz;
+    if (bucket_idx > CLIENT_MEM_USAGE_BUCKET_MAX_LOG)
+        bucket_idx = CLIENT_MEM_USAGE_BUCKET_MAX_LOG;
+    else if (bucket_idx < CLIENT_MEM_USAGE_BUCKET_MIN_LOG)
+        bucket_idx = CLIENT_MEM_USAGE_BUCKET_MIN_LOG;
+    bucket_idx -= CLIENT_MEM_USAGE_BUCKET_MIN_LOG;
+    return &server.client_mem_usage_buckets[bucket_idx];
+}
+
+/*
+ * This method updates the client memory usage and update the
+ * server stats for client type.
+ *
+ * This method is called from the clientsCron to have updated
+ * stats for non CLIENT_TYPE_NORMAL/PUBSUB clients to accurately
+ * provide information around clients memory usage.
+ *
+ * It is also used in updateClientMemUsageAndBucket to have latest
+ * client memory usage information to place it into appropriate client memory
+ * usage bucket.
+ */
+void updateClientMemoryUsage(client *c) {
+    serverAssert(c->conn);
+    size_t mem = getClientMemoryUsage(c, NULL);
+    int type = getClientType(c);
+    /* Now that we have the memory used by the client, remove the old
+     * value from the old category, and add it back. */
+    server.stat_clients_type_memory[c->last_memory_type] -= c->last_memory_usage;
+    server.stat_clients_type_memory[type] += mem;
+    /* Remember what we added and where, to remove it next time. */
+    c->last_memory_type = type;
+    c->last_memory_usage = mem;
+}
+
+int clientEvictionAllowed(client *c) {
+    if (server.maxmemory_clients == 0 || c->flag.no_evict || c->flag.fake) {
+        return 0;
+    }
+    serverAssert(c->conn);
+    int type = getClientType(c);
+    return (type == CLIENT_TYPE_NORMAL || type == CLIENT_TYPE_PUBSUB);
+}
+
+
+/* This function is used to cleanup the client's previously tracked memory usage.
+ * This is called during incremental client memory usage tracking as well as
+ * used to reset when client to bucket allocation is not required when
+ * client eviction is disabled.  */
+void removeClientFromMemUsageBucket(client *c, int allow_eviction) {
+    if (c->mem_usage_bucket) {
+        c->mem_usage_bucket->mem_usage_sum -= c->last_memory_usage;
+        /* If this client can't be evicted then remove it from the mem usage
+         * buckets */
+        if (!allow_eviction) {
+            listDelNode(c->mem_usage_bucket->clients, c->mem_usage_bucket_node);
+            c->mem_usage_bucket = NULL;
+            c->mem_usage_bucket_node = NULL;
+        }
+    }
+}
+
+/* This is called only if explicit clients when something changed their buffers,
+ * so we can track clients' memory and enforce clients' maxmemory in real time.
+ *
+ * This also adds the client to the correct memory usage bucket. Each bucket contains
+ * all clients with roughly the same amount of memory. This way we group
+ * together clients consuming about the same amount of memory and can quickly
+ * free them in case we reach maxmemory-clients (client eviction).
+ *
+ * Note: This function filters clients of type no-evict, primary or replica regardless
+ * of whether the eviction is enabled or not, so the memory usage we get from these
+ * types of clients via the INFO command may be out of date.
+ *
+ * returns 1 if client eviction for this client is allowed, 0 otherwise.
+ */
+int updateClientMemUsageAndBucket(client *c) {
+    int allow_eviction = clientEvictionAllowed(c);
+    removeClientFromMemUsageBucket(c, allow_eviction);
+
+    if (!allow_eviction) {
+        return 0;
+    }
+
+    /* Update client memory usage. */
+    updateClientMemoryUsage(c);
+
+    /* Update the client in the mem usage buckets */
+    clientMemUsageBucket *bucket = getMemUsageBucket(c->last_memory_usage);
+    bucket->mem_usage_sum += c->last_memory_usage;
+    if (bucket != c->mem_usage_bucket) {
+        if (c->mem_usage_bucket) listDelNode(c->mem_usage_bucket->clients, c->mem_usage_bucket_node);
+        c->mem_usage_bucket = bucket;
+        listAddNodeTail(bucket->clients, c);
+        c->mem_usage_bucket_node = listLast(bucket->clients);
+    }
+    return 1;
+}
+
+/* Return the max samples in the memory usage of clients tracked by
+ * the function clientsCronTrackExpansiveClients(). */
+void getExpansiveClientsInfo(size_t *in_usage, size_t *out_usage) {
+    size_t i = 0, o = 0;
+    for (int j = 0; j < CLIENTS_PEAK_MEM_USAGE_SLOTS; j++) {
+        if (ClientsPeakMemInput[j] > i) i = ClientsPeakMemInput[j];
+        if (ClientsPeakMemOutput[j] > o) o = ClientsPeakMemOutput[j];
+    }
+    *in_usage = i;
+    *out_usage = o;
+}
+
+/* This function is called by serverCron() and is used in order to perform
+ * operations on clients that are important to perform constantly. For instance
+ * we use this function in order to disconnect clients after a timeout, including
+ * clients blocked in some blocking command with a non-zero timeout.
+ *
+ * The function makes some effort to process all the clients every second, even
+ * if this cannot be strictly guaranteed, since serverCron() may be called with
+ * an actual frequency lower than server.hz in case of latency events like slow
+ * commands.
+ *
+ * It is very important for this function, and the functions it calls, to be
+ * very fast: sometimes the server has tens of hundreds of connected clients, and the
+ * default server.hz value is 10, so sometimes here we need to process thousands
+ * of clients per second, turning this function into a source of latency.
+ */
+#define CLIENTS_CRON_MIN_ITERATIONS 5
+void clientsCron(void) {
+    /* Try to process at least numclients/server.hz of clients
+     * per call. Since normally (if there are no big latency events) this
+     * function is called server.hz times per second, in the average case we
+     * process all the clients in 1 second. */
+    int numclients = listLength(server.clients);
+    int iterations = numclients / server.hz;
+    mstime_t now = mstime();
+
+    /* Process at least a few clients while we are at it, even if we need
+     * to process less than CLIENTS_CRON_MIN_ITERATIONS to meet our contract
+     * of processing each client once per second. */
+    if (iterations < CLIENTS_CRON_MIN_ITERATIONS)
+        iterations = (numclients < CLIENTS_CRON_MIN_ITERATIONS) ? numclients : CLIENTS_CRON_MIN_ITERATIONS;
+
+
+    int curr_peak_mem_usage_slot = server.unixtime % CLIENTS_PEAK_MEM_USAGE_SLOTS;
+    /* Always zero the next sample, so that when we switch to that second, we'll
+     * only register samples that are greater in that second without considering
+     * the history of such slot.
+     *
+     * Note: our index may jump to any random position if serverCron() is not
+     * called for some reason with the normal frequency, for instance because
+     * some slow command is called taking multiple seconds to execute. In that
+     * case our array may end containing data which is potentially older
+     * than CLIENTS_PEAK_MEM_USAGE_SLOTS seconds: however this is not a problem
+     * since here we want just to track if "recently" there were very expansive
+     * clients from the POV of memory usage. */
+    int zeroidx = (curr_peak_mem_usage_slot + 1) % CLIENTS_PEAK_MEM_USAGE_SLOTS;
+    ClientsPeakMemInput[zeroidx] = 0;
+    ClientsPeakMemOutput[zeroidx] = 0;
+
+
+    while (listLength(server.clients) && iterations--) {
+        client *c;
+        listNode *head;
+
+        /* Take the current head, process, and then rotate the head to tail.
+         * This way we can fairly iterate all clients step by step. */
+        head = listFirst(server.clients);
+        c = listNodeValue(head);
+        listRotateHeadToTail(server.clients);
+        if (c->io_read_state != CLIENT_IDLE || c->io_write_state != CLIENT_IDLE) continue;
+        /* The following functions do different service checks on the client.
+         * The protocol is that they return non-zero if the client was
+         * terminated. */
+        if (clientsCronHandleTimeout(c, now)) continue;
+        if (clientsCronResizeQueryBuffer(c)) continue;
+        if (clientsCronResizeOutputBuffer(c, now)) continue;
+
+        if (clientsCronTrackExpansiveClients(c, curr_peak_mem_usage_slot)) continue;
+
+        /* Iterating all the clients in getMemoryOverheadData() is too slow and
+         * in turn would make the INFO command too slow. So we perform this
+         * computation incrementally and track the (not instantaneous but updated
+         * to the second) total memory used by clients using clientsCron() in
+         * a more incremental way (depending on server.hz).
+         * If client eviction is enabled, update the bucket as well. */
+        if (!updateClientMemUsageAndBucket(c)) updateClientMemoryUsage(c);
+
+        if (closeClientOnOutputBufferLimitReached(c, 0)) continue;
+    }
+}
+
+/* This function handles 'background' operations we are required to do
+ * incrementally in the databases, such as active key expiring, resizing,
+ * rehashing. */
+void databasesCron(void) {
+    /* Expire keys by random sampling. Not required for replicas
+     * as primary will synthesize DELs for us. */
+    if (server.active_expire_enabled) {
+        if (!iAmPrimary()) {
+            expireReplicaKeys();
+        } else if (!server.import_mode) {
+            activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
+        }
+    }
+
+    /* Start active defrag cycle or adjust defrag CPU if needed. */
+    monitorActiveDefrag();
+
+    /* Perform hash tables rehashing if needed, but only if there are no
+     * other processes saving the DB on disk. Otherwise rehashing is bad
+     * as will cause a lot of copy-on-write of memory pages. */
+    if (!hasActiveChildProcess()) {
+        /* We use global counters so if we stop the computation at a given
+         * DB we'll be able to start from the successive in the next
+         * cron loop iteration. */
+        static unsigned int resize_db = 0;
+        static unsigned int rehash_db = 0;
+        int dbs_per_call = CRON_DBS_PER_CALL;
+        int j;
+
+        /* Don't test more DBs than we have. */
+        if (dbs_per_call > server.dbnum) dbs_per_call = server.dbnum;
+
+        for (j = 0; j < dbs_per_call; j++) {
+            serverDb *db = &server.db[resize_db % server.dbnum];
+            kvstoreTryResizeHashtables(db->keys, CRON_DICTS_PER_DB);
+            kvstoreTryResizeHashtables(db->expires, CRON_DICTS_PER_DB);
+            resize_db++;
+        }
+
+        /* Rehash */
+        if (server.activerehashing) {
+            uint64_t elapsed_us = 0;
+            uint64_t threshold_us = 1 * 1000000 / server.hz / 100;
+            for (j = 0; j < dbs_per_call; j++) {
+                serverDb *db = &server.db[rehash_db % server.dbnum];
+                elapsed_us += kvstoreIncrementallyRehash(db->keys, threshold_us - elapsed_us);
+                if (elapsed_us >= threshold_us) break;
+                elapsed_us += kvstoreIncrementallyRehash(db->expires, threshold_us - elapsed_us);
+                if (elapsed_us >= threshold_us) break;
+                rehash_db++;
+            }
+        }
+    }
+}
+
+static inline void updateCachedTimeWithUs(int update_daylight_info, const long long ustime) {
+    server.ustime = ustime;
+    server.mstime = server.ustime / 1000;
+    server.unixtime = server.mstime / 1000;
+
+    /* 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);
+        atomic_store_explicit(&server.daylight_active, tm.tm_isdst, memory_order_relaxed);
+    }
+}
+
+/* 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) {
+    const long long us = ustime();
+    updateCachedTimeWithUs(update_daylight_info, us);
+}
+
+/* Performing required operations in order to enter an execution unit.
+ * In general, if we are already inside an execution unit then there is nothing to do,
+ * otherwise we need to update cache times so the same cached time will be used all over
+ * the execution unit.
+ * update_cached_time - if 0, will not update the cached time even if required.
+ * us - if not zero, use this time for cached time, otherwise get current time. */
+void enterExecutionUnit(int update_cached_time, long long us) {
+    if (server.execution_nesting++ == 0 && update_cached_time) {
+        if (us == 0) {
+            us = ustime();
+        }
+        updateCachedTimeWithUs(0, us);
+        server.cmd_time_snapshot = server.mstime;
+    }
+}
+
+void exitExecutionUnit(void) {
+    --server.execution_nesting;
+}
+
+void checkChildrenDone(void) {
+    int statloc = 0;
+    pid_t pid;
+
+    if ((pid = waitpid(-1, &statloc, WNOHANG)) != 0) {
+        int exitcode = WIFEXITED(statloc) ? WEXITSTATUS(statloc) : -1;
+        int bysignal = 0;
+
+        if (WIFSIGNALED(statloc)) bysignal = WTERMSIG(statloc);
+
+        /* sigKillChildHandler catches the signal and calls exit(), but we
+         * must make sure not to flag lastbgsave_status, etc incorrectly.
+         * We could directly terminate the child process via SIGUSR1
+         * without handling it */
+        if (exitcode == SERVER_CHILD_NOERROR_RETVAL) {
+            bysignal = SIGUSR1;
+            exitcode = 1;
+        }
+
+        if (pid == -1) {
+            serverLog(LL_WARNING,
+                      "waitpid() returned an error: %s. "
+                      "child_type: %s, child_pid = %d",
+                      strerror(errno), strChildType(server.child_type), (int)server.child_pid);
+        } else if (pid == server.child_pid) {
+            if (server.child_type == CHILD_TYPE_RDB) {
+                backgroundSaveDoneHandler(exitcode, bysignal);
+            } else if (server.child_type == CHILD_TYPE_AOF) {
+                backgroundRewriteDoneHandler(exitcode, bysignal);
+            } else if (server.child_type == CHILD_TYPE_MODULE) {
+                ModuleForkDoneHandler(exitcode, bysignal);
+            } else {
+                serverPanic("Unknown child type %d for child pid %d", server.child_type, server.child_pid);
+                exit(1);
+            }
+            if (!bysignal && exitcode == 0) receiveChildInfo();
+            resetChildState();
+        } else {
+            if (!ldbRemoveChild(pid)) {
+                serverLog(LL_WARNING, "Warning, detected child with unmatched pid: %ld", (long)pid);
+            }
+        }
+
+        /* start any pending forks immediately. */
+        replicationStartPendingFork();
+    }
+}
+
+/* Called from serverCron and cronUpdateMemoryStats to update cached memory metrics. */
+void cronUpdateMemoryStats(void) {
+    /* Record the max memory used since the server was started. */
+    if (zmalloc_used_memory() > server.stat_peak_memory) server.stat_peak_memory = zmalloc_used_memory();
+
+    run_with_period(100) {
+        /* Sample the RSS and other metrics here since this is a relatively slow call.
+         * We must sample the zmalloc_used at the same time we take the rss, otherwise
+         * the frag ratio calculate may be off (ratio of two samples at different times) */
+        server.cron_malloc_stats.process_rss = zmalloc_get_rss();
+        server.cron_malloc_stats.zmalloc_used = zmalloc_used_memory();
+        /* Sampling the allocator info can be slow too.
+         * The fragmentation ratio it'll show is potentially more accurate
+         * it excludes other RSS pages such as: shared libraries, LUA and other non-zmalloc
+         * allocations, and allocator reserved pages that can be pursed (all not actual frag) */
+        zmalloc_get_allocator_info(
+            &server.cron_malloc_stats.allocator_allocated, &server.cron_malloc_stats.allocator_active,
+            &server.cron_malloc_stats.allocator_resident, NULL, &server.cron_malloc_stats.allocator_muzzy);
+        server.cron_malloc_stats.allocator_frag_smallbins_bytes = allocatorDefragGetFragSmallbins();
+        /* in case the allocator isn't providing these stats, fake them so that
+         * fragmentation info still shows some (inaccurate metrics) */
+        if (!server.cron_malloc_stats.allocator_resident) {
+            /* LUA memory isn't part of zmalloc_used, but it is part of the process RSS,
+             * so we must deduct it in order to be able to calculate correct
+             * "allocator fragmentation" ratio */
+            size_t lua_memory = evalMemory();
+            server.cron_malloc_stats.allocator_resident = server.cron_malloc_stats.process_rss - lua_memory;
+        }
+        if (!server.cron_malloc_stats.allocator_active)
+            server.cron_malloc_stats.allocator_active = server.cron_malloc_stats.allocator_resident;
+        if (!server.cron_malloc_stats.allocator_allocated)
+            server.cron_malloc_stats.allocator_allocated = server.cron_malloc_stats.zmalloc_used;
+    }
+}
+
+/* This is our timer interrupt, called server.hz times per second.
+ * Here is where we do a number of things that need to be done asynchronously.
+ * For instance:
+ *
+ * - Active expired keys collection (it is also performed in a lazy way on
+ *   lookup).
+ * - Software watchdog.
+ * - Update some statistic.
+ * - Incremental rehashing of the DBs hash tables.
+ * - Triggering BGSAVE / AOF rewrite, and handling of terminated children.
+ * - Clients timeout of different kinds.
+ * - Replication reconnection.
+ * - Many more...
+ *
+ * Everything directly called here will be called server.hz times per second,
+ * so in order to throttle execution of things we want to do less frequently
+ * a macro is used: run_with_period(milliseconds) { .... }
+ */
+
+long long serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
+    int j;
+    UNUSED(eventLoop);
+    UNUSED(id);
+    UNUSED(clientData);
+
+    /* Software watchdog: deliver the SIGALRM that will reach the signal
+     * handler if we don't return here fast enough. */
+    if (server.watchdog_period) watchdogScheduleSignal(server.watchdog_period);
+
+    server.hz = server.config_hz;
+    /* Adapt the server.hz value to the number of configured clients. If we have
+     * many clients, we want to call serverCron() with an higher frequency. */
+    if (server.dynamic_hz) {
+        while (listLength(server.clients) / server.hz > MAX_CLIENTS_PER_CLOCK_TICK) {
+            server.hz *= 2;
+            if (server.hz > CONFIG_MAX_HZ) {
+                server.hz = CONFIG_MAX_HZ;
+                break;
+            }
+        }
+    }
+
+    /* for debug purposes: skip actual cron work if pause_cron is on */
+    if (server.pause_cron) return 1000 / server.hz;
+
+    monotime cron_start = getMonotonicUs();
+
+    run_with_period(100) {
+        monotime current_time = getMonotonicUs();
+        long long factor = 1000000; // us
+        trackInstantaneousMetric(STATS_METRIC_COMMAND, server.stat_numcommands, current_time, factor);
+        trackInstantaneousMetric(STATS_METRIC_NET_INPUT, server.stat_net_input_bytes + server.stat_net_repl_input_bytes,
+                                 current_time, factor);
+        trackInstantaneousMetric(STATS_METRIC_NET_OUTPUT,
+                                 server.stat_net_output_bytes + server.stat_net_repl_output_bytes, current_time,
+                                 factor);
+        trackInstantaneousMetric(STATS_METRIC_NET_INPUT_REPLICATION, server.stat_net_repl_input_bytes, current_time,
+                                 factor);
+        trackInstantaneousMetric(STATS_METRIC_NET_OUTPUT_REPLICATION, server.stat_net_repl_output_bytes, current_time,
+                                 factor);
+        trackInstantaneousMetric(STATS_METRIC_EL_CYCLE, server.duration_stats[EL_DURATION_TYPE_EL].cnt, current_time,
+                                 factor);
+        trackInstantaneousMetric(STATS_METRIC_EL_DURATION, server.duration_stats[EL_DURATION_TYPE_EL].sum,
+                                 server.duration_stats[EL_DURATION_TYPE_EL].cnt, 1);
+    }
+
+    /* We have just LRU_BITS bits per object for LRU information.
+     * So we use an (eventually wrapping) LRU clock.
+     *
+     * Note that even if the counter wraps it's not a big problem,
+     * everything will still work but some object will appear younger
+     * to the server. However for this to happen a given object should never be
+     * touched for all the time needed to the counter to wrap, which is
+     * not likely.
+     *
+     * Note that you can change the resolution altering the
+     * LRU_CLOCK_RESOLUTION define. */
+    server.lruclock = getLRUClock();
+
+    cronUpdateMemoryStats();
+
+    /* We received a SIGTERM or SIGINT, shutting down here in a safe way, as it is
+     * not ok doing so inside the signal handler. */
+    if (server.shutdown_asap && !isShutdownInitiated()) {
+        int shutdownFlags = SHUTDOWN_NOFLAGS;
+        if (server.last_sig_received == SIGINT && server.shutdown_on_sigint)
+            shutdownFlags = server.shutdown_on_sigint;
+        else if (server.last_sig_received == SIGTERM && server.shutdown_on_sigterm)
+            shutdownFlags = server.shutdown_on_sigterm;
+
+        if (prepareForShutdown(NULL, shutdownFlags) == C_OK) exit(0);
+    } else if (isShutdownInitiated()) {
+        if (server.mstime >= server.shutdown_mstime || isReadyToShutdown()) {
+            if (finishShutdown() == C_OK) exit(0);
+            /* Shutdown failed. Continue running. An error has been logged. */
+        }
+    }
+
+    /* Show some info about non-empty databases */
+    if (server.verbosity <= LL_VERBOSE) {
+        run_with_period(5000) {
+            for (j = 0; j < server.dbnum; j++) {
+                long long size, used, vkeys;
+
+                size = kvstoreBuckets(server.db[j].keys);
+                used = kvstoreSize(server.db[j].keys);
+                vkeys = kvstoreSize(server.db[j].expires);
+                if (used || vkeys) {
+                    serverLog(LL_VERBOSE, "DB %d: %lld keys (%lld volatile) in %lld slots HT.", j, used, vkeys, size);
+                }
+            }
+        }
+    }
+
+    /* Show information about connected clients */
+    if (!server.sentinel_mode) {
+        run_with_period(5000) {
+            char hmem[64];
+            size_t zmalloc_used = zmalloc_used_memory();
+            bytesToHuman(hmem, sizeof(hmem), zmalloc_used);
+
+            serverLog(LL_DEBUG, "Total: %lu clients connected (%lu replicas), %zu (%s) bytes in use",
+                      listLength(server.clients) - listLength(server.replicas), listLength(server.replicas),
+                      zmalloc_used, hmem);
+        }
+    }
+
+    /* We need to do a few operations on clients asynchronously. */
+    clientsCron();
+
+    /* Handle background operations on databases. */
+    databasesCron();
+
+    /* Start a scheduled AOF rewrite if this was requested by the user while
+     * a BGSAVE was in progress. */
+    if (!hasActiveChildProcess() && server.aof_rewrite_scheduled && !aofRewriteLimited()) {
+        rewriteAppendOnlyFileBackground();
+    }
+
+    /* Check if a background saving or AOF rewrite in progress terminated. */
+    if (hasActiveChildProcess() || ldbPendingChildren()) {
+        run_with_period(1000) receiveChildInfo();
+        checkChildrenDone();
+    } else {
+        /* If there is not a background saving/rewrite in progress check if
+         * we have to save/rewrite now. */
+        for (j = 0; j < server.saveparamslen; j++) {
+            struct saveparam *sp = server.saveparams + j;
+
+            /* Save if we reached the given amount of changes,
+             * the given amount of seconds, and if the latest bgsave was
+             * successful or if, in case of an error, at least
+             * CONFIG_BGSAVE_RETRY_DELAY seconds already elapsed. */
+            if (server.dirty >= sp->changes && server.unixtime - server.lastsave > sp->seconds &&
+                (server.unixtime - server.lastbgsave_try > CONFIG_BGSAVE_RETRY_DELAY ||
+                 server.lastbgsave_status == C_OK)) {
+                serverLog(LL_NOTICE, "%d changes in %d seconds. Saving...", sp->changes, (int)sp->seconds);
+                rdbSaveInfo rsi, *rsiptr;
+                rsiptr = rdbPopulateSaveInfo(&rsi);
+                rdbSaveBackground(REPLICA_REQ_NONE, server.rdb_filename, rsiptr, RDBFLAGS_NONE);
+                break;
+            }
+        }
+
+        /* Trigger an AOF rewrite if needed. */
+        if (server.aof_state == AOF_ON && !hasActiveChildProcess() && server.aof_rewrite_perc &&
+            server.aof_current_size > server.aof_rewrite_min_size) {
+            long long base = server.aof_rewrite_base_size ? server.aof_rewrite_base_size : 1;
+            long long growth = (server.aof_current_size * 100 / base) - 100;
+            if (growth >= server.aof_rewrite_perc && !aofRewriteLimited()) {
+                serverLog(LL_NOTICE, "Starting automatic rewriting of AOF on %lld%% growth", growth);
+                rewriteAppendOnlyFileBackground();
+            }
+        }
+    }
+    /* Just for the sake of defensive programming, to avoid forgetting to
+     * call this function when needed. */
+    updateDictResizePolicy();
+
+    /* AOF postponed flush: Try at every cron cycle if the slow fsync
+     * completed. */
+    if ((server.aof_state == AOF_ON || server.aof_state == AOF_WAIT_REWRITE) && server.aof_flush_postponed_start) {
+        flushAppendOnlyFile(0);
+    }
+
+    /* AOF write errors: in this case we have a buffer to flush as well and
+     * clear the AOF error in case of success to make the DB writable again,
+     * however to try every second is enough in case of 'hz' is set to
+     * a higher frequency. */
+    run_with_period(1000) {
+        if ((server.aof_state == AOF_ON || server.aof_state == AOF_WAIT_REWRITE) &&
+            server.aof_last_write_status == C_ERR) {
+            flushAppendOnlyFile(0);
+        }
+    }
+
+    /* Clear the paused actions state if needed. */
+    updatePausedActions();
+
+    /* Replication cron function -- used to reconnect to primary,
+     * detect transfer failures, start background RDB transfers and so forth.
+     *
+     * If the server is trying to failover then run the replication cron faster so
+     * progress on the handshake happens more quickly. */
+    if (server.failover_state != NO_FAILOVER) {
+        run_with_period(100) replicationCron();
+    } else {
+        run_with_period(1000) replicationCron();
+    }
+
+    /* Run the Cluster cron. */
+    if (server.cluster_enabled) {
+        run_with_period(100) clusterCron();
+    }
+
+    /* Run the Sentinel timer if we are in sentinel mode. */
+    if (server.sentinel_mode) sentinelTimer();
+
+    /* Cleanup expired MIGRATE cached sockets. */
+    run_with_period(1000) {
+        migrateCloseTimedoutSockets();
+    }
+
+    /* Resize tracking keys table if needed. This is also done at every
+     * command execution, but we want to be sure that if the last command
+     * executed changes the value via CONFIG SET, the server will perform
+     * the operation even if completely idle. */
+    if (server.tracking_clients) trackingLimitUsedSlots();
+
+    /* Start a scheduled BGSAVE if the corresponding flag is set. This is
+     * useful when we are forced to postpone a BGSAVE because an AOF
+     * rewrite is in progress.
+     *
+     * Note: this code must be after the replicationCron() call above so
+     * make sure when refactoring this file to keep this order. This is useful
+     * because we want to give priority to RDB savings for replication. */
+    if (!hasActiveChildProcess() && server.rdb_bgsave_scheduled &&
+        (server.unixtime - server.lastbgsave_try > CONFIG_BGSAVE_RETRY_DELAY || server.lastbgsave_status == C_OK)) {
+        rdbSaveInfo rsi, *rsiptr;
+        rsiptr = rdbPopulateSaveInfo(&rsi);
+        if (rdbSaveBackground(REPLICA_REQ_NONE, server.rdb_filename, rsiptr, RDBFLAGS_NONE) == C_OK)
+            server.rdb_bgsave_scheduled = 0;
+    }
+
+    if (moduleCount()) {
+        run_with_period(100) modulesCron();
+    }
+
+    /* Fire the cron loop modules event. */
+    ValkeyModuleCronLoopV1 ei = {VALKEYMODULE_CRON_LOOP_VERSION, server.hz};
+    moduleFireServerEvent(VALKEYMODULE_EVENT_CRON_LOOP, 0, &ei);
+
+    server.cronloops++;
+
+    server.el_cron_duration = getMonotonicUs() - cron_start;
+
+    return 1000 / server.hz;
+}
+
+
+void blockingOperationStarts(void) {
+    if (!server.blocking_op_nesting++) {
+        updateCachedTime(0);
+        server.blocked_last_cron = server.mstime;
+    }
+}
+
+void blockingOperationEnds(void) {
+    if (!(--server.blocking_op_nesting)) {
+        server.blocked_last_cron = 0;
+    }
+}
+
+/* This function fills in the role of serverCron during RDB or AOF loading, and
+ * also during blocked scripts.
+ * It attempts to do its duties at a similar rate as the configured server.hz,
+ * and updates cronloops variable so that similarly to serverCron, the
+ * run_with_period can be used. */
+void whileBlockedCron(void) {
+    /* Here we may want to perform some cron jobs (normally done server.hz times
+     * per second). */
+
+    /* Since this function depends on a call to blockingOperationStarts, let's
+     * make sure it was done. */
+    serverAssert(server.blocked_last_cron);
+
+    /* In case we were called too soon, leave right away. This way one time
+     * jobs after the loop below don't need an if. and we don't bother to start
+     * latency monitor if this function is called too often. */
+    if (server.blocked_last_cron >= server.mstime) return;
+
+    /* Increment server.cronloops so that run_with_period works. */
+    long hz_ms = 1000 / server.hz;
+    int cronloops = (server.mstime - server.blocked_last_cron + (hz_ms - 1)) / hz_ms; // rounding up
+    server.blocked_last_cron += cronloops * hz_ms;
+    server.cronloops += cronloops;
+
+    mstime_t latency;
+    latencyStartMonitor(latency);
+
+    defragWhileBlocked();
+
+    /* Update memory stats during loading (excluding blocked scripts) */
+    if (server.loading) cronUpdateMemoryStats();
+
+    latencyEndMonitor(latency);
+    latencyAddSampleIfNeeded("while-blocked-cron", latency);
+
+    /* We received a SIGTERM during loading, shutting down here in a safe way,
+     * as it isn't ok doing so inside the signal handler. */
+    if (server.shutdown_asap && server.loading) {
+        if (prepareForShutdown(NULL, SHUTDOWN_NOSAVE) == C_OK) exit(0);
+        serverLog(LL_WARNING,
+                  "SIGTERM received but errors trying to shut down the server, check the logs for more information");
+        server.shutdown_asap = 0;
+        server.last_sig_received = 0;
+    }
+}
+
+static void sendGetackToReplicas(void) {
+    robj *argv[3];
+    argv[0] = shared.replconf;
+    argv[1] = shared.getack;
+    argv[2] = shared.special_asterisk; /* Not used argument. */
+    replicationFeedReplicas(-1, argv, 3);
+}
+
+extern int ProcessingEventsWhileBlocked;
+
+/* This function gets called every time the server is entering the
+ * main loop of the event driven library, that is, before to sleep
+ * for ready file descriptors.
+ *
+ * Note: This function is (currently) called from two functions:
+ * 1. aeMain - The main server loop
+ * 2. processEventsWhileBlocked - Process clients during RDB/AOF load
+ *
+ * If it was called from processEventsWhileBlocked we don't want
+ * to perform all actions (For example, we don't want to expire
+ * keys), but we do need to perform some actions.
+ *
+ * The most important is freeClientsInAsyncFreeQueue but we also
+ * call some other low-risk functions. */
+void beforeSleep(struct aeEventLoop *eventLoop) {
+    UNUSED(eventLoop);
+
+    /* When I/O threads are enabled and there are pending I/O jobs, the poll is offloaded to one of the I/O threads. */
+    trySendPollJobToIOThreads();
+
+    size_t zmalloc_used = zmalloc_used_memory();
+    if (zmalloc_used > server.stat_peak_memory) server.stat_peak_memory = zmalloc_used;
+
+    /* Just call a subset of vital functions in case we are re-entering
+     * the event loop from processEventsWhileBlocked(). Note that in this
+     * case we keep track of the number of events we are processing, since
+     * processEventsWhileBlocked() wants to stop ASAP if there are no longer
+     * events to handle. */
+    if (ProcessingEventsWhileBlocked) {
+        uint64_t processed = 0;
+        processed += processIOThreadsReadDone();
+        processed += connTypeProcessPendingData();
+        if (server.aof_state == AOF_ON || server.aof_state == AOF_WAIT_REWRITE) flushAppendOnlyFile(0);
+        processed += handleClientsWithPendingWrites();
+        int last_processed = 0;
+        do {
+            /* Try to process all the pending IO events. */
+            last_processed = processIOThreadsReadDone() + processIOThreadsWriteDone();
+            processed += last_processed;
+        } while (last_processed != 0);
+        processed += freeClientsInAsyncFreeQueue();
+        server.events_processed_while_blocked += processed;
+        return;
+    }
+
+    /* We should handle pending reads clients ASAP after event loop. */
+    processIOThreadsReadDone();
+
+    /* Handle pending data(typical TLS). (must be done before flushAppendOnlyFile) */
+    connTypeProcessPendingData();
+
+    /* If any connection type(typical TLS) still has pending unread data don't sleep at all. */
+    int dont_sleep = connTypeHasPendingData();
+
+    /* Call the Cluster before sleep function. Note that this function
+     * may change the state of Cluster (from ok to fail or vice versa),
+     * so it's a good idea to call it before serving the unblocked clients
+     * later in this function, must be done before blockedBeforeSleep. */
+    if (server.cluster_enabled) clusterBeforeSleep();
+
+    /* Handle blocked clients.
+     * must be done before flushAppendOnlyFile, in case of appendfsync=always,
+     * since the unblocked clients may write data. */
+    blockedBeforeSleep();
+
+    /* Record cron time in beforeSleep, which is the sum of active-expire, active-defrag and all other
+     * tasks done by cron and beforeSleep, but excluding read, write and AOF, that are counted by other
+     * sets of metrics. */
+    monotime cron_start_time_before_aof = getMonotonicUs();
+
+    /* Run a fast expire cycle (the called function will return
+     * ASAP if a fast cycle is not needed). */
+    if (server.active_expire_enabled && !server.import_mode && iAmPrimary()) activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);
+
+    if (moduleCount()) {
+        moduleFireServerEvent(VALKEYMODULE_EVENT_EVENTLOOP, VALKEYMODULE_SUBEVENT_EVENTLOOP_BEFORE_SLEEP, NULL);
+    }
+
+    /* Send all the replicas an ACK request if at least one client blocked
+     * during the previous event loop iteration. Note that we do this after
+     * processUnblockedClients(), so if there are multiple pipelined WAITs
+     * and the just unblocked WAIT gets blocked again, we don't have to wait
+     * a server cron cycle in absence of other event loop events. See #6623.
+     *
+     * We also don't send the ACKs while clients are paused, since it can
+     * increment the replication backlog, they'll be sent after the pause
+     * if we are still the primary. */
+    if (server.get_ack_from_replicas && !isPausedActionsWithUpdate(PAUSE_ACTION_REPLICA)) {
+        sendGetackToReplicas();
+        server.get_ack_from_replicas = 0;
+    }
+
+    /* We may have received updates from clients about their current offset. NOTE:
+     * this can't be done where the ACK is received since failover will disconnect
+     * our clients. */
+    updateFailoverStatus();
+
+    /* Since we rely on current_client to send scheduled invalidation messages
+     * we have to flush them after each command, so when we get here, the list
+     * must be empty. */
+    serverAssert(listLength(server.tracking_pending_keys) == 0);
+    serverAssert(listLength(server.pending_push_messages) == 0);
+
+    /* Send the invalidation messages to clients participating to the
+     * client side caching protocol in broadcasting (BCAST) mode. */
+    trackingBroadcastInvalidationMessages();
+
+    /* Record time consumption of AOF writing. */
+    monotime aof_start_time = getMonotonicUs();
+    /* Record cron time in beforeSleep. This does not include the time consumed by AOF writing and IO writing below. */
+    monotime duration_before_aof = aof_start_time - cron_start_time_before_aof;
+    /* Record the fsync'd offset before flushAppendOnly */
+    long long prev_fsynced_reploff = server.fsynced_reploff;
+
+    /* Write the AOF buffer on disk,
+     * must be done before handleClientsWithPendingWrites,
+     * in case of appendfsync=always. */
+    if (server.aof_state == AOF_ON || server.aof_state == AOF_WAIT_REWRITE) flushAppendOnlyFile(0);
+
+    /* Record time consumption of AOF writing. */
+    durationAddSample(EL_DURATION_TYPE_AOF, getMonotonicUs() - aof_start_time);
+
+    /* Update the fsynced replica offset.
+     * If an initial rewrite is in progress then not all data is guaranteed to have actually been
+     * persisted to disk yet, so we cannot update the field. We will wait for the rewrite to complete. */
+    if (server.aof_state == AOF_ON && server.fsynced_reploff != -1) {
+        long long fsynced_reploff_pending = atomic_load_explicit(&server.fsynced_reploff_pending, memory_order_relaxed);
+        server.fsynced_reploff = fsynced_reploff_pending;
+
+        /* If we have blocked [WAIT]AOF clients, and fsynced_reploff changed, we want to try to
+         * wake them up ASAP. */
+        if (listLength(server.clients_waiting_acks) && prev_fsynced_reploff != server.fsynced_reploff) dont_sleep = 1;
+    }
+
+    /* Handle writes with pending output buffers. */
+    handleClientsWithPendingWrites();
+
+    /* Try to process more IO reads that are ready to be processed. */
+    if (server.aof_fsync != AOF_FSYNC_ALWAYS) {
+        processIOThreadsReadDone();
+    }
+
+    processIOThreadsWriteDone();
+
+    /* Record cron time in beforeSleep. This does not include the time consumed by AOF writing and IO writing above. */
+    monotime cron_start_time_after_write = getMonotonicUs();
+
+    /* Close clients that need to be closed asynchronous */
+    freeClientsInAsyncFreeQueue();
+
+    /* Incrementally trim replication backlog, 10 times the normal speed is
+     * to free replication backlog as much as possible. */
+    if (server.repl_backlog) incrementalTrimReplicationBacklog(10 * REPL_BACKLOG_TRIM_BLOCKS_PER_CALL);
+
+    /* Disconnect some clients if they are consuming too much memory. */
+    evictClients();
+
+    /* Record cron time in beforeSleep. */
+    monotime duration_after_write = getMonotonicUs() - cron_start_time_after_write;
+
+    /* Record eventloop latency. */
+    if (server.el_start > 0) {
+        monotime el_duration = getMonotonicUs() - server.el_start;
+        durationAddSample(EL_DURATION_TYPE_EL, el_duration);
+    }
+    server.el_cron_duration += duration_before_aof + duration_after_write;
+    durationAddSample(EL_DURATION_TYPE_CRON, server.el_cron_duration);
+    server.el_cron_duration = 0;
+    /* Record max command count per cycle. */
+    if (server.stat_numcommands > server.el_cmd_cnt_start) {
+        long long el_command_cnt = server.stat_numcommands - server.el_cmd_cnt_start;
+        if (el_command_cnt > server.el_cmd_cnt_max) {
+            server.el_cmd_cnt_max = el_command_cnt;
+        }
+    }
+
+    /* Don't sleep at all before the next beforeSleep() if needed (e.g. a
+     * connection has pending data) */
+    aeSetDontWait(server.el, dont_sleep);
+
+    /* Before we are going to sleep, let the threads access the dataset by
+     * releasing the GIL. The server main thread will not touch anything at this
+     * time. */
+    if (moduleCount()) moduleReleaseGIL();
+    /********************* WARNING ********************
+     * Do NOT add anything below moduleReleaseGIL !!! *
+     ***************************** ********************/
+}
+
+/* This function is called immediately after the event loop multiplexing
+ * API returned, and the control is going to soon return to the server by invoking
+ * the different events callbacks. */
+void afterSleep(struct aeEventLoop *eventLoop, int numevents) {
+    UNUSED(eventLoop);
+    /********************* WARNING ********************
+     * Do NOT add anything above moduleAcquireGIL !!! *
+     ***************************** ********************/
+    if (!ProcessingEventsWhileBlocked) {
+        /* Acquire the modules GIL so that their threads won't touch anything. */
+        if (moduleCount()) {
+            mstime_t latency;
+            latencyStartMonitor(latency);
+            atomic_store_explicit(&server.module_gil_acquiring, 1, memory_order_relaxed);
+            moduleAcquireGIL();
+            atomic_store_explicit(&server.module_gil_acquiring, 0, memory_order_relaxed);
+            moduleFireServerEvent(VALKEYMODULE_EVENT_EVENTLOOP, VALKEYMODULE_SUBEVENT_EVENTLOOP_AFTER_SLEEP, NULL);
+            latencyEndMonitor(latency);
+            latencyAddSampleIfNeeded("module-acquire-GIL", latency);
+        }
+        /* Set the eventloop start time. */
+        server.el_start = getMonotonicUs();
+        /* Set the eventloop command count at start. */
+        server.el_cmd_cnt_start = server.stat_numcommands;
+    }
+
+    /* Update the time cache. */
+    updateCachedTime(1);
+
+    /* Update command time snapshot in case it'll be required without a command
+     * e.g. somehow used by module timers. Don't update it while yielding to a
+     * blocked command, call() will handle that and restore the original time. */
+    if (!ProcessingEventsWhileBlocked) {
+        server.cmd_time_snapshot = server.mstime;
+    }
+
+    adjustIOThreadsByEventLoad(numevents, 0);
+}
+
+/* =========================== Server initialization ======================== */
+
+/* These shared strings depend on the extended-redis-compatibility config and is
+ * called when the config changes. When the config is phased out, these
+ * initializations can be moved back inside createSharedObjects() below. */
+void createSharedObjectsWithCompat(void) {
+    const char *name = server.extended_redis_compat ? "Redis" : SERVER_TITLE;
+    if (shared.loadingerr) decrRefCount(shared.loadingerr);
+    shared.loadingerr =
+        createObject(OBJ_STRING, sdscatfmt(sdsempty(), "-LOADING %s is loading the dataset in memory\r\n", name));
+    if (shared.slowevalerr) decrRefCount(shared.slowevalerr);
+    shared.slowevalerr = createObject(
+        OBJ_STRING,
+        sdscatfmt(sdsempty(),
+                  "-BUSY %s is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.\r\n", name));
+    if (shared.slowscripterr) decrRefCount(shared.slowscripterr);
+    shared.slowscripterr = createObject(
+        OBJ_STRING,
+        sdscatfmt(sdsempty(),
+                  "-BUSY %s is busy running a script. You can only call FUNCTION KILL or SHUTDOWN NOSAVE.\r\n", name));
+    if (shared.slowmoduleerr) decrRefCount(shared.slowmoduleerr);
+    shared.slowmoduleerr =
+        createObject(OBJ_STRING, sdscatfmt(sdsempty(), "-BUSY %s is busy running a module command.\r\n", name));
+    if (shared.bgsaveerr) decrRefCount(shared.bgsaveerr);
+    shared.bgsaveerr =
+        createObject(OBJ_STRING, sdscatfmt(sdsempty(),
+                                           "-MISCONF %s is configured to save RDB snapshots, but it's currently"
+                                           " unable to persist to disk. Commands that may modify the data set are"
+                                           " disabled, because this instance is configured to report errors during"
+                                           " writes if RDB snapshotting fails (stop-writes-on-bgsave-error option)."
+                                           " Please check the %s logs for details about the RDB error.\r\n",
+                                           name, name));
+}
+
+void createSharedObjects(void) {
+    int j;
+
+    /* Shared command responses */
+    shared.ok = createObject(OBJ_STRING, sdsnew("+OK\r\n"));
+    shared.emptybulk = createObject(OBJ_STRING, sdsnew("$0\r\n\r\n"));
+    shared.czero = createObject(OBJ_STRING, sdsnew(":0\r\n"));
+    shared.cone = createObject(OBJ_STRING, sdsnew(":1\r\n"));
+    shared.emptyarray = createObject(OBJ_STRING, sdsnew("*0\r\n"));
+    shared.pong = createObject(OBJ_STRING, sdsnew("+PONG\r\n"));
+    shared.queued = createObject(OBJ_STRING, sdsnew("+QUEUED\r\n"));
+    shared.emptyscan = createObject(OBJ_STRING, sdsnew("*2\r\n$1\r\n0\r\n*0\r\n"));
+    shared.space = createObject(OBJ_STRING, sdsnew(" "));
+    shared.plus = createObject(OBJ_STRING, sdsnew("+"));
+
+    /* Shared command error responses */
+    shared.wrongtypeerr =
+        createObject(OBJ_STRING, sdsnew("-WRONGTYPE Operation against a key holding the wrong kind of value\r\n"));
+    shared.err = createObject(OBJ_STRING, sdsnew("-ERR\r\n"));
+    shared.nokeyerr = createObject(OBJ_STRING, sdsnew("-ERR no such key\r\n"));
+    shared.syntaxerr = createObject(OBJ_STRING, sdsnew("-ERR syntax error\r\n"));
+    shared.sameobjecterr = createObject(OBJ_STRING, sdsnew("-ERR source and destination objects are the same\r\n"));
+    shared.outofrangeerr = createObject(OBJ_STRING, sdsnew("-ERR index out of range\r\n"));
+    shared.noscripterr = createObject(OBJ_STRING, sdsnew("-NOSCRIPT No matching script.\r\n"));
+    createSharedObjectsWithCompat();
+    shared.primarydownerr = createObject(
+        OBJ_STRING, sdsnew("-MASTERDOWN Link with MASTER is down and replica-serve-stale-data is set to 'no'.\r\n"));
+    shared.roreplicaerr =
+        createObject(OBJ_STRING, sdsnew("-READONLY You can't write against a read only replica.\r\n"));
+    shared.noautherr = createObject(OBJ_STRING, sdsnew("-NOAUTH Authentication required.\r\n"));
+    shared.oomerr = createObject(OBJ_STRING, sdsnew("-OOM command not allowed when used memory > 'maxmemory'.\r\n"));
+    shared.execaborterr =
+        createObject(OBJ_STRING, sdsnew("-EXECABORT Transaction discarded because of previous errors.\r\n"));
+    shared.noreplicaserr = createObject(OBJ_STRING, sdsnew("-NOREPLICAS Not enough good replicas to write.\r\n"));
+    shared.busykeyerr = createObject(OBJ_STRING, sdsnew("-BUSYKEY Target key name already exists.\r\n"));
+
+    /* The shared NULL depends on the protocol version. */
+    shared.null[0] = NULL;
+    shared.null[1] = NULL;
+    shared.null[2] = createObject(OBJ_STRING, sdsnew("$-1\r\n"));
+    shared.null[3] = createObject(OBJ_STRING, sdsnew("_\r\n"));
+
+    shared.nullarray[0] = NULL;
+    shared.nullarray[1] = NULL;
+    shared.nullarray[2] = createObject(OBJ_STRING, sdsnew("*-1\r\n"));
+    shared.nullarray[3] = createObject(OBJ_STRING, sdsnew("_\r\n"));
+
+    shared.emptymap[0] = NULL;
+    shared.emptymap[1] = NULL;
+    shared.emptymap[2] = createObject(OBJ_STRING, sdsnew("*0\r\n"));
+    shared.emptymap[3] = createObject(OBJ_STRING, sdsnew("%0\r\n"));
+
+    shared.emptyset[0] = NULL;
+    shared.emptyset[1] = NULL;
+    shared.emptyset[2] = createObject(OBJ_STRING, sdsnew("*0\r\n"));
+    shared.emptyset[3] = createObject(OBJ_STRING, sdsnew("~0\r\n"));
+
+    for (j = 0; j < PROTO_SHARED_SELECT_CMDS; j++) {
+        char dictid_str[64];
+        int dictid_len;
+
+        dictid_len = ll2string(dictid_str, sizeof(dictid_str), j);
+        shared.select[j] = createObject(
+            OBJ_STRING, sdscatprintf(sdsempty(), "*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n", dictid_len, dictid_str));
+    }
+    shared.messagebulk = createStringObject("$7\r\nmessage\r\n", 13);
+    shared.pmessagebulk = createStringObject("$8\r\npmessage\r\n", 14);
+    shared.subscribebulk = createStringObject("$9\r\nsubscribe\r\n", 15);
+    shared.unsubscribebulk = createStringObject("$11\r\nunsubscribe\r\n", 18);
+    shared.ssubscribebulk = createStringObject("$10\r\nssubscribe\r\n", 17);
+    shared.sunsubscribebulk = createStringObject("$12\r\nsunsubscribe\r\n", 19);
+    shared.smessagebulk = createStringObject("$8\r\nsmessage\r\n", 14);
+    shared.psubscribebulk = createStringObject("$10\r\npsubscribe\r\n", 17);
+    shared.punsubscribebulk = createStringObject("$12\r\npunsubscribe\r\n", 19);
+
+    /* Shared command names */
+    shared.del = createStringObject("DEL", 3);
+    shared.unlink = createStringObject("UNLINK", 6);
+    shared.rpop = createStringObject("RPOP", 4);
+    shared.lpop = createStringObject("LPOP", 4);
+    shared.lpush = createStringObject("LPUSH", 5);
+    shared.rpoplpush = createStringObject("RPOPLPUSH", 9);
+    shared.lmove = createStringObject("LMOVE", 5);
+    shared.blmove = createStringObject("BLMOVE", 6);
+    shared.zpopmin = createStringObject("ZPOPMIN", 7);
+    shared.zpopmax = createStringObject("ZPOPMAX", 7);
+    shared.multi = createStringObject("MULTI", 5);
+    shared.exec = createStringObject("EXEC", 4);
+    shared.hset = createStringObject("HSET", 4);
+    shared.srem = createStringObject("SREM", 4);
+    shared.xgroup = createStringObject("XGROUP", 6);
+    shared.xclaim = createStringObject("XCLAIM", 6);
+    shared.script = createStringObject("SCRIPT", 6);
+    shared.replconf = createStringObject("REPLCONF", 8);
+    shared.pexpireat = createStringObject("PEXPIREAT", 9);
+    shared.pexpire = createStringObject("PEXPIRE", 7);
+    shared.persist = createStringObject("PERSIST", 7);
+    shared.set = createStringObject("SET", 3);
+    shared.eval = createStringObject("EVAL", 4);
+
+    /* Shared command argument */
+    shared.left = createStringObject("left", 4);
+    shared.right = createStringObject("right", 5);
+    shared.pxat = createStringObject("PXAT", 4);
+    shared.time = createStringObject("TIME", 4);
+    shared.retrycount = createStringObject("RETRYCOUNT", 10);
+    shared.force = createStringObject("FORCE", 5);
+    shared.justid = createStringObject("JUSTID", 6);
+    shared.entriesread = createStringObject("ENTRIESREAD", 11);
+    shared.lastid = createStringObject("LASTID", 6);
+    shared.default_username = createStringObject("default", 7);
+    shared.ping = createStringObject("ping", 4);
+    shared.setid = createStringObject("SETID", 5);
+    shared.keepttl = createStringObject("KEEPTTL", 7);
+    shared.absttl = createStringObject("ABSTTL", 6);
+    shared.load = createStringObject("LOAD", 4);
+    shared.createconsumer = createStringObject("CREATECONSUMER", 14);
+    shared.getack = createStringObject("GETACK", 6);
+    shared.special_asterisk = createStringObject("*", 1);
+    shared.special_equals = createStringObject("=", 1);
+    shared.redacted = makeObjectShared(createStringObject("(redacted)", 10));
+
+    for (j = 0; j < OBJ_SHARED_INTEGERS; j++) {
+        shared.integers[j] = makeObjectShared(createObject(OBJ_STRING, (void *)(long)j));
+        initObjectLRUOrLFU(shared.integers[j]);
+        shared.integers[j]->encoding = OBJ_ENCODING_INT;
+    }
+    for (j = 0; j < OBJ_SHARED_BULKHDR_LEN; j++) {
+        shared.mbulkhdr[j] = createObject(OBJ_STRING, sdscatprintf(sdsempty(), "*%d\r\n", j));
+        shared.bulkhdr[j] = createObject(OBJ_STRING, sdscatprintf(sdsempty(), "$%d\r\n", j));
+        shared.maphdr[j] = createObject(OBJ_STRING, sdscatprintf(sdsempty(), "%%%d\r\n", j));
+        shared.sethdr[j] = createObject(OBJ_STRING, sdscatprintf(sdsempty(), "~%d\r\n", j));
+    }
+    /* The following two shared objects, minstring and maxstring, are not
+     * actually used for their value but as a special object meaning
+     * respectively the minimum possible string and the maximum possible
+     * string in string comparisons for the ZRANGEBYLEX command. */
+    shared.minstring = sdsnew("minstring");
+    shared.maxstring = sdsnew("maxstring");
+}
+
+void initServerClientMemUsageBuckets(void) {
+    if (server.client_mem_usage_buckets) return;
+    server.client_mem_usage_buckets = zmalloc(sizeof(clientMemUsageBucket) * CLIENT_MEM_USAGE_BUCKETS);
+    for (int j = 0; j < CLIENT_MEM_USAGE_BUCKETS; j++) {
+        server.client_mem_usage_buckets[j].mem_usage_sum = 0;
+        server.client_mem_usage_buckets[j].clients = listCreate();
+    }
+}
+
+void freeServerClientMemUsageBuckets(void) {
+    if (!server.client_mem_usage_buckets) return;
+    for (int j = 0; j < CLIENT_MEM_USAGE_BUCKETS; j++) listRelease(server.client_mem_usage_buckets[j].clients);
+    zfree(server.client_mem_usage_buckets);
+    server.client_mem_usage_buckets = NULL;
+}
+
+void initServerConfig(void) {
+    int j;
+    char *default_bindaddr[CONFIG_DEFAULT_BINDADDR_COUNT] = CONFIG_DEFAULT_BINDADDR;
+
+    initConfigValues();
+    updateCachedTime(1);
+    server.cmd_time_snapshot = server.mstime;
+    getRandomHexChars(server.runid, CONFIG_RUN_ID_SIZE);
+    server.runid[CONFIG_RUN_ID_SIZE] = '\0';
+    changeReplicationId();
+    clearReplicationId2();
+    server.hz = CONFIG_DEFAULT_HZ;   /* Initialize it ASAP, even if it may get
+                                        updated later after loading the config.
+                                        This value may be used before the server
+                                        is initialized. */
+    server.timezone = getTimeZone(); /* Initialized by tzset(). */
+    server.configfile = NULL;
+    server.executable = NULL;
+    server.arch_bits = (sizeof(long) == 8) ? 64 : 32;
+    server.bindaddr_count = CONFIG_DEFAULT_BINDADDR_COUNT;
+    for (j = 0; j < CONFIG_DEFAULT_BINDADDR_COUNT; j++) server.bindaddr[j] = zstrdup(default_bindaddr[j]);
+    memset(server.listeners, 0x00, sizeof(server.listeners));
+    server.active_expire_enabled = 1;
+    server.lazy_expire_disabled = 0;
+    server.skip_checksum_validation = 0;
+    server.loading = 0;
+    server.async_loading = 0;
+    server.loading_rdb_used_mem = 0;
+    server.aof_state = AOF_OFF;
+    server.aof_rewrite_base_size = 0;
+    server.aof_rewrite_scheduled = 0;
+    server.aof_flush_sleep = 0;
+    server.aof_last_fsync = time(NULL) * 1000;
+    server.aof_cur_timestamp = 0;
+    atomic_store_explicit(&server.aof_bio_fsync_status, C_OK, memory_order_relaxed);
+    server.aof_rewrite_time_last = -1;
+    server.aof_rewrite_time_start = -1;
+    server.aof_lastbgrewrite_status = C_OK;
+    server.aof_delayed_fsync = 0;
+    server.aof_fd = -1;
+    server.aof_selected_db = -1; /* Make sure the first time will not match */
+    server.aof_flush_postponed_start = 0;
+    server.aof_last_incr_size = 0;
+    server.aof_last_incr_fsync_offset = 0;
+    server.active_defrag_cpu_percent = 0;
+    server.active_defrag_configuration_changed = 0;
+    server.notify_keyspace_events = 0;
+    server.blocked_clients = 0;
+    memset(server.blocked_clients_by_type, 0, sizeof(server.blocked_clients_by_type));
+    server.shutdown_asap = 0;
+    server.shutdown_flags = 0;
+    server.shutdown_mstime = 0;
+    server.cluster_module_flags = CLUSTER_MODULE_FLAG_NONE;
+    server.migrate_cached_sockets = dictCreate(&migrateCacheDictType);
+    server.next_client_id = 1; /* Client IDs, start from 1 .*/
+    server.page_size = sysconf(_SC_PAGESIZE);
+    server.extended_redis_compat = 0;
+    server.pause_cron = 0;
+    server.dict_resizing = 1;
+    server.import_mode = 0;
+
+    server.latency_tracking_info_percentiles_len = 3;
+    server.latency_tracking_info_percentiles = zmalloc(sizeof(double) * (server.latency_tracking_info_percentiles_len));
+    server.latency_tracking_info_percentiles[0] = 50.0; /* p50 */
+    server.latency_tracking_info_percentiles[1] = 99.0; /* p99 */
+    server.latency_tracking_info_percentiles[2] = 99.9; /* p999 */
+
+    server.lruclock = getLRUClock();
+    resetServerSaveParams();
+
+    appendServerSaveParams(60 * 60, 1); /* save after 1 hour and 1 change */
+    appendServerSaveParams(300, 100);   /* save after 5 minutes and 100 changes */
+    appendServerSaveParams(60, 10000);  /* save after 1 minute and 10000 changes */
+
+    /* Replication related */
+    server.primary_host = NULL;
+    server.primary_port = 6379;
+    server.primary = NULL;
+    server.cached_primary = NULL;
+    server.primary_initial_offset = -1;
+    server.repl_state = REPL_STATE_NONE;
+    server.repl_rdb_channel_state = REPL_DUAL_CHANNEL_STATE_NONE;
+    server.repl_transfer_tmpfile = NULL;
+    server.repl_transfer_fd = -1;
+    server.repl_transfer_s = NULL;
+    server.repl_syncio_timeout = CONFIG_REPL_SYNCIO_TIMEOUT;
+    server.repl_down_since = 0; /* Never connected, repl is down since EVER. */
+    server.primary_repl_offset = 0;
+    server.fsynced_reploff_pending = 0;
+    server.rdb_client_id = -1;
+    server.loading_process_events_interval_ms = LOADING_PROCESS_EVENTS_INTERVAL_DEFAULT;
+    server.loading_rio = NULL;
+
+    /* Replication partial resync backlog */
+    server.repl_backlog = NULL;
+    server.repl_no_replicas_since = time(NULL);
+
+    /* Failover related */
+    server.failover_end_time = 0;
+    server.force_failover = 0;
+    server.target_replica_host = NULL;
+    server.target_replica_port = 0;
+    server.failover_state = NO_FAILOVER;
+
+    /* Client output buffer limits */
+    for (j = 0; j < CLIENT_TYPE_OBUF_COUNT; j++) server.client_obuf_limits[j] = clientBufferLimitsDefaults[j];
+
+    /* Linux OOM Score config */
+    for (j = 0; j < CONFIG_OOM_COUNT; j++) server.oom_score_adj_values[j] = configOOMScoreAdjValuesDefaults[j];
+
+    /* Double constants initialization */
+    R_Zero = 0.0;
+    R_PosInf = 1.0 / R_Zero;
+    R_NegInf = -1.0 / R_Zero;
+    R_Nan = R_Zero / R_Zero;
+
+    /* Command table -- we initialize it here as it is part of the
+     * initial configuration, since command names may be changed via
+     * futriix.conf using the rename-command directive. */
+    server.commands = hashtableCreate(&commandSetType);
+    server.orig_commands = hashtableCreate(&commandSetType);
+    populateCommandTable();
+
+    /* Debugging */
+    server.watchdog_period = 0;
+}
+
+extern char **environ;
+
+/* Restart the server, executing the same executable that started this
+ * instance, with the same arguments and configuration file.
+ *
+ * The function is designed to directly call execve() so that the new
+ * server instance will retain the PID of the previous one.
+ *
+ * The list of flags, that may be bitwise ORed together, alter the
+ * behavior of this function:
+ *
+ * RESTART_SERVER_NONE              No flags.
+ * RESTART_SERVER_GRACEFULLY        Do a proper shutdown before restarting.
+ * RESTART_SERVER_CONFIG_REWRITE    Rewrite the config file before restarting.
+ *
+ * On success the function does not return, because the process turns into
+ * a different process. On error C_ERR is returned. */
+int restartServer(client *c, int flags, mstime_t delay) {
+    int j;
+
+    /* Check if we still have accesses to the executable that started this
+     * server instance. */
+    if (access(server.executable, X_OK) == -1) {
+        serverLog(LL_WARNING,
+                  "Can't restart: this process has no "
+                  "permissions to execute %s",
+                  server.executable);
+        return C_ERR;
+    }
+
+    /* Config rewriting. */
+    if (flags & RESTART_SERVER_CONFIG_REWRITE && server.configfile && rewriteConfig(server.configfile, 0) == -1) {
+        serverLog(LL_WARNING,
+                  "Can't restart: configuration rewrite process "
+                  "failed: %s",
+                  strerror(errno));
+        return C_ERR;
+    }
+
+    /* Perform a proper shutdown. We don't wait for lagging replicas though. */
+    if (flags & RESTART_SERVER_GRACEFULLY && prepareForShutdown(c, SHUTDOWN_NOW) != C_OK) {
+        serverLog(LL_WARNING, "Can't restart: error preparing for shutdown");
+        return C_ERR;
+    }
+
+    /* Close all file descriptors, with the exception of stdin, stdout, stderr
+     * which are useful if we restart a server which is not daemonized. */
+    for (j = 3; j < (int)server.maxclients + 1024; j++) {
+        /* Test the descriptor validity before closing it, otherwise
+         * Valgrind issues a warning on close(). */
+        if (fcntl(j, F_GETFD) != -1) close(j);
+    }
+
+    /* Execute the server with the original command line. */
+    if (delay) usleep(delay * 1000);
+    zfree(server.exec_argv[0]);
+    server.exec_argv[0] = zstrdup(server.executable);
+    execve(server.executable, server.exec_argv, environ);
+
+    /* If an error occurred here, there is nothing we can do, but exit. */
+    _exit(1);
+
+    return C_ERR; /* Never reached. */
+}
+
+/* This function will configure the current process's oom_score_adj according
+ * to user specified configuration. This is currently implemented on Linux
+ * only.
+ *
+ * A process_class value of -1 implies OOM_CONFIG_PRIMARY or OOM_CONFIG_REPLICA,
+ * depending on current role.
+ */
+int setOOMScoreAdj(int process_class) {
+    if (process_class == -1) process_class = (server.primary_host ? CONFIG_OOM_REPLICA : CONFIG_OOM_PRIMARY);
+
+    serverAssert(process_class >= 0 && process_class < CONFIG_OOM_COUNT);
+
+#ifdef HAVE_PROC_OOM_SCORE_ADJ
+    /* The following statics are used to indicate the server has changed the process's oom score.
+     * And to save the original score so we can restore it later if needed.
+     * We need this so when we disabled oom-score-adj (also during configuration rollback
+     * when another configuration parameter was invalid and causes a rollback after
+     * applying a new oom-score) we can return to the oom-score value from before our
+     * adjustments. */
+    static int oom_score_adjusted_by_valkey = 0;
+    static int oom_score_adj_base = 0;
+
+    int fd;
+    int val;
+    char buf[64];
+
+    if (server.oom_score_adj != OOM_SCORE_ADJ_NO) {
+        if (!oom_score_adjusted_by_valkey) {
+            oom_score_adjusted_by_valkey = 1;
+            /* Backup base value before enabling the server control over oom score */
+            fd = open("/proc/self/oom_score_adj", O_RDONLY);
+            if (fd < 0 || read(fd, buf, sizeof(buf)) < 0) {
+                serverLog(LL_WARNING, "Unable to read oom_score_adj: %s", strerror(errno));
+                if (fd != -1) close(fd);
+                return C_ERR;
+            }
+            oom_score_adj_base = atoi(buf);
+            close(fd);
+        }
+
+        val = server.oom_score_adj_values[process_class];
+        if (server.oom_score_adj == OOM_SCORE_RELATIVE) val += oom_score_adj_base;
+        if (val > 1000) val = 1000;
+        if (val < -1000) val = -1000;
+    } else if (oom_score_adjusted_by_valkey) {
+        oom_score_adjusted_by_valkey = 0;
+        val = oom_score_adj_base;
+    } else {
+        return C_OK;
+    }
+
+    snprintf(buf, sizeof(buf) - 1, "%d\n", val);
+
+    fd = open("/proc/self/oom_score_adj", O_WRONLY);
+    if (fd < 0 || write(fd, buf, strlen(buf)) < 0) {
+        serverLog(LL_WARNING, "Unable to write oom_score_adj: %s", strerror(errno));
+        if (fd != -1) close(fd);
+        return C_ERR;
+    }
+
+    close(fd);
+    return C_OK;
+#else
+    /* Unsupported */
+    return C_ERR;
+#endif
+}
+
+/* This function will try to raise the max number of open files accordingly to
+ * the configured max number of clients. It also reserves a number of file
+ * descriptors (CONFIG_MIN_RESERVED_FDS) for extra operations of
+ * persistence, listening sockets, log files and so forth.
+ *
+ * If it will not be possible to set the limit accordingly to the configured
+ * max number of clients, the function will do the reverse setting
+ * server.maxclients to the value that we can actually handle. */
+void adjustOpenFilesLimit(void) {
+    rlim_t maxfiles = server.maxclients + CONFIG_MIN_RESERVED_FDS;
+    struct rlimit limit;
+
+    if (getrlimit(RLIMIT_NOFILE, &limit) == -1) {
+        serverLog(LL_WARNING,
+                  "Unable to obtain the current NOFILE limit (%s), assuming 1024 and setting the max clients "
+                  "configuration accordingly.",
+                  strerror(errno));
+        server.maxclients = 1024 - CONFIG_MIN_RESERVED_FDS;
+    } else {
+        rlim_t oldlimit = limit.rlim_cur;
+
+        /* Set the max number of files if the current limit is not enough
+         * for our needs. */
+        if (oldlimit < maxfiles) {
+            rlim_t bestlimit;
+            int setrlimit_error = 0;
+
+            /* Try to set the file limit to match 'maxfiles' or at least
+             * to the higher value supported less than maxfiles. */
+            bestlimit = maxfiles;
+            while (bestlimit > oldlimit) {
+                rlim_t decr_step = 16;
+
+                limit.rlim_cur = bestlimit;
+                limit.rlim_max = bestlimit;
+                if (setrlimit(RLIMIT_NOFILE, &limit) != -1) break;
+                setrlimit_error = errno;
+
+                /* We failed to set file limit to 'bestlimit'. Try with a
+                 * smaller limit decrementing by a few FDs per iteration. */
+                if (bestlimit < decr_step) {
+                    bestlimit = oldlimit;
+                    break;
+                }
+                bestlimit -= decr_step;
+            }
+
+            /* Assume that the limit we get initially is still valid if
+             * our last try was even lower. */
+            if (bestlimit < oldlimit) bestlimit = oldlimit;
+
+            if (bestlimit < maxfiles) {
+                unsigned int old_maxclients = server.maxclients;
+                server.maxclients = bestlimit - CONFIG_MIN_RESERVED_FDS;
+                /* maxclients is unsigned so may overflow: in order
+                 * to check if maxclients is now logically less than 1
+                 * we test indirectly via bestlimit. */
+                if (bestlimit <= CONFIG_MIN_RESERVED_FDS) {
+                    serverLog(LL_WARNING,
+                              "Your current 'ulimit -n' "
+                              "of %llu is not enough for the server to start. "
+                              "Please increase your open file limit to at least "
+                              "%llu. Exiting.",
+                              (unsigned long long)oldlimit, (unsigned long long)maxfiles);
+                    exit(1);
+                }
+                serverLog(LL_WARNING,
+                          "You requested maxclients of %d "
+                          "requiring at least %llu max file descriptors.",
+                          old_maxclients, (unsigned long long)maxfiles);
+                serverLog(LL_WARNING,
+                          "Server can't set maximum open files "
+                          "to %llu because of OS error: %s.",
+                          (unsigned long long)maxfiles, strerror(setrlimit_error));
+                serverLog(LL_WARNING,
+                          "Current maximum open files is %llu. "
+                          "maxclients has been reduced to %d to compensate for "
+                          "low ulimit. "
+                          "If you need higher maxclients increase 'ulimit -n'.",
+                          (unsigned long long)bestlimit, server.maxclients);
+            } else {
+                serverLog(LL_NOTICE,
+                          "Increased maximum number of open files "
+                          "to %llu (it was originally set to %llu).",
+                          (unsigned long long)maxfiles, (unsigned long long)oldlimit);
+            }
+        }
+    }
+}
+
+/* Check that server.tcp_backlog can be actually enforced in Linux according
+ * to the value of /proc/sys/net/core/somaxconn, or warn about it. */
+void checkTcpBacklogSettings(void) {
+#if defined(HAVE_PROC_SOMAXCONN)
+    FILE *fp = fopen("/proc/sys/net/core/somaxconn", "r");
+    char buf[1024];
+    if (!fp) return;
+    if (fgets(buf, sizeof(buf), fp) != NULL) {
+        int somaxconn = atoi(buf);
+        if (somaxconn > 0 && somaxconn < server.tcp_backlog) {
+            serverLog(LL_WARNING,
+                      "WARNING: The TCP backlog setting of %d cannot be enforced because /proc/sys/net/core/somaxconn "
+                      "is set to the lower value of %d.",
+                      server.tcp_backlog, somaxconn);
+        }
+    }
+    fclose(fp);
+#elif defined(HAVE_SYSCTL_KIPC_SOMAXCONN)
+    int somaxconn, mib[3];
+    size_t len = sizeof(int);
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_IPC;
+    mib[2] = KIPC_SOMAXCONN;
+
+    if (sysctl(mib, 3, &somaxconn, &len, NULL, 0) == 0) {
+        if (somaxconn > 0 && somaxconn < server.tcp_backlog) {
+            serverLog(LL_WARNING,
+                      "WARNING: The TCP backlog setting of %d cannot be enforced because kern.ipc.somaxconn is set to "
+                      "the lower value of %d.",
+                      server.tcp_backlog, somaxconn);
+        }
+    }
+#elif defined(HAVE_SYSCTL_KERN_SOMAXCONN)
+    int somaxconn, mib[2];
+    size_t len = sizeof(int);
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_SOMAXCONN;
+
+    if (sysctl(mib, 2, &somaxconn, &len, NULL, 0) == 0) {
+        if (somaxconn > 0 && somaxconn < server.tcp_backlog) {
+            serverLog(LL_WARNING,
+                      "WARNING: The TCP backlog setting of %d cannot be enforced because kern.somaxconn is set to the "
+                      "lower value of %d.",
+                      server.tcp_backlog, somaxconn);
+        }
+    }
+#elif defined(SOMAXCONN)
+    if (SOMAXCONN < server.tcp_backlog) {
+        serverLog(LL_WARNING,
+                  "WARNING: The TCP backlog setting of %d cannot be enforced because SOMAXCONN is set to the lower "
+                  "value of %d.",
+                  server.tcp_backlog, SOMAXCONN);
+    }
+#endif
+}
+
+/* Create an event handler for accepting new connections in TCP or TLS domain sockets.
+ * This works atomically for all socket fds */
+int createSocketAcceptHandler(connListener *sfd, aeFileProc *accept_handler) {
+    int j;
+
+    for (j = 0; j < sfd->count; j++) {
+        if (aeCreateFileEvent(server.el, sfd->fd[j], AE_READABLE, accept_handler, sfd) == AE_ERR) {
+            /* Rollback */
+            for (j = j - 1; j >= 0; j--) aeDeleteFileEvent(server.el, sfd->fd[j], AE_READABLE);
+            return C_ERR;
+        }
+    }
+    return C_OK;
+}
+
+/* Initialize a set of file descriptors to listen to the specified 'port'
+ * binding the addresses specified in the server configuration.
+ *
+ * The listening file descriptors are stored in the integer array 'fds'
+ * and their number is set in '*count'. Actually @sfd should be 'listener',
+ * for the historical reasons, let's keep 'sfd' here.
+ *
+ * The addresses to bind are specified in the global server.bindaddr array
+ * and their number is server.bindaddr_count. If the server configuration
+ * contains no specific addresses to bind, this function will try to
+ * bind * (all addresses) for both the IPv4 and IPv6 protocols.
+ *
+ * On success the function returns C_OK.
+ *
+ * On error the function returns C_ERR. For the function to be on
+ * error, at least one of the server.bindaddr addresses was
+ * impossible to bind, or no bind addresses were specified in the server
+ * configuration but the function is not able to bind * for at least
+ * one of the IPv4 or IPv6 protocols. */
+int listenToPort(connListener *sfd) {
+    int j;
+    int port = sfd->port;
+    char **bindaddr = sfd->bindaddr;
+
+    /* If we have no bind address, we don't listen on a TCP socket */
+    if (sfd->bindaddr_count == 0) return C_OK;
+
+    for (j = 0; j < sfd->bindaddr_count; j++) {
+        char *addr = bindaddr[j];
+        int optional = *addr == '-';
+        if (optional) addr++;
+        if (strchr(addr, ':')) {
+            /* Bind IPv6 address. */
+            sfd->fd[sfd->count] = anetTcp6Server(server.neterr, port, addr, server.tcp_backlog);
+        } else {
+            /* Bind IPv4 address. */
+            sfd->fd[sfd->count] = anetTcpServer(server.neterr, port, addr, server.tcp_backlog);
+        }
+        if (sfd->fd[sfd->count] == ANET_ERR) {
+            int net_errno = errno;
+            serverLog(LL_WARNING, "Warning: Could not create server TCP listening socket %s:%d: %s", addr, port,
+                      server.neterr);
+            if (net_errno == EADDRNOTAVAIL && optional) continue;
+            if (net_errno == ENOPROTOOPT || net_errno == EPROTONOSUPPORT || net_errno == ESOCKTNOSUPPORT ||
+                net_errno == EPFNOSUPPORT || net_errno == EAFNOSUPPORT)
+                continue;
+
+            /* Rollback successful listens before exiting */
+            connCloseListener(sfd);
+            return C_ERR;
+        }
+        if (server.socket_mark_id > 0) anetSetSockMarkId(NULL, sfd->fd[sfd->count], server.socket_mark_id);
+        anetNonBlock(NULL, sfd->fd[sfd->count]);
+        anetCloexec(sfd->fd[sfd->count]);
+        sfd->count++;
+    }
+    return C_OK;
+}
+
+/* Resets the stats that we expose via INFO or other means that we want
+ * to reset via CONFIG RESETSTAT. The function is also used in order to
+ * initialize these fields in initServer() at server startup. */
+void resetServerStats(void) {
+    int j;
+
+    server.stat_numcommands = 0;
+    server.stat_numconnections = 0;
+    server.stat_expiredkeys = 0;
+    server.stat_expired_stale_perc = 0;
+    server.stat_expired_time_cap_reached_count = 0;
+    server.stat_expire_cycle_time_used = 0;
+    server.stat_evictedkeys = 0;
+    server.stat_evictedclients = 0;
+    server.stat_evictedscripts = 0;
+    server.stat_total_eviction_exceeded_time = 0;
+    server.stat_last_eviction_exceeded_time = 0;
+    server.stat_keyspace_misses = 0;
+    server.stat_keyspace_hits = 0;
+    server.stat_active_defrag_hits = 0;
+    server.stat_active_defrag_misses = 0;
+    server.stat_active_defrag_key_hits = 0;
+    server.stat_active_defrag_key_misses = 0;
+    server.stat_active_defrag_scanned = 0;
+    server.stat_total_active_defrag_time = 0;
+    server.stat_last_active_defrag_time = 0;
+    server.stat_fork_time = 0;
+    server.stat_fork_rate = 0;
+    server.stat_total_forks = 0;
+    server.stat_rejected_conn = 0;
+    server.stat_sync_full = 0;
+    server.stat_sync_partial_ok = 0;
+    server.stat_sync_partial_err = 0;
+    server.stat_io_reads_processed = 0;
+    server.stat_total_reads_processed = 0;
+    server.stat_io_writes_processed = 0;
+    server.stat_io_freed_objects = 0;
+    server.stat_io_accept_offloaded = 0;
+    server.stat_poll_processed_by_io_threads = 0;
+    server.stat_total_writes_processed = 0;
+    server.stat_client_qbuf_limit_disconnections = 0;
+    server.stat_client_outbuf_limit_disconnections = 0;
+    for (j = 0; j < STATS_METRIC_COUNT; j++) {
+        server.inst_metric[j].idx = 0;
+        server.inst_metric[j].last_sample_base = 0;
+        server.inst_metric[j].last_sample_value = 0;
+        memset(server.inst_metric[j].samples, 0, sizeof(server.inst_metric[j].samples));
+    }
+    server.stat_aof_rewrites = 0;
+    server.stat_rdb_saves = 0;
+    server.stat_aofrw_consecutive_failures = 0;
+    server.stat_net_input_bytes = 0;
+    server.stat_net_output_bytes = 0;
+    server.stat_net_repl_input_bytes = 0;
+    server.stat_net_repl_output_bytes = 0;
+    server.stat_unexpected_error_replies = 0;
+    server.stat_total_error_replies = 0;
+    server.stat_dump_payload_sanitizations = 0;
+    server.aof_delayed_fsync = 0;
+    server.stat_reply_buffer_shrinks = 0;
+    server.stat_reply_buffer_expands = 0;
+    memset(server.duration_stats, 0, sizeof(durationStats) * EL_DURATION_TYPE_NUM);
+    server.el_cmd_cnt_max = 0;
+    lazyfreeResetStats();
+}
+
+/* Make the thread killable at any time, so that kill threads functions
+ * can work reliably (default cancellability type is PTHREAD_CANCEL_DEFERRED).
+ * Needed for pthread_cancel used by the fast memory test used by the crash report. */
+void makeThreadKillable(void) {
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+}
+
+void initServer(void) {
+    int j;
+
+    signal(SIGHUP, SIG_IGN);
+    signal(SIGPIPE, SIG_IGN);
+    setupSignalHandlers();
+    ThreadsManager_init();
+    makeThreadKillable();
+
+    if (server.syslog_enabled) {
+        openlog(server.syslog_ident, LOG_PID | LOG_NDELAY | LOG_NOWAIT, server.syslog_facility);
+    }
+
+    /* Initialization after setting defaults from the config system. */
+    server.aof_state = server.aof_enabled ? AOF_ON : AOF_OFF;
+    server.fsynced_reploff = server.aof_enabled ? 0 : -1;
+    server.hz = server.config_hz;
+    server.in_fork_child = CHILD_TYPE_NONE;
+    server.rdb_pipe_read = -1;
+    server.rdb_child_exit_pipe = -1;
+    server.main_thread_id = pthread_self();
+    server.current_client = NULL;
+    server.errors = raxNew();
+    server.execution_nesting = 0;
+    server.clients = listCreate();
+    server.clients_index = raxNew();
+    server.clients_to_close = listCreate();
+    server.replicas = listCreate();
+    server.monitors = listCreate();
+    server.replicas_waiting_psync = raxNew();
+    server.wait_before_rdb_client_free = DEFAULT_WAIT_BEFORE_RDB_CLIENT_FREE;
+    server.clients_pending_write = listCreate();
+    server.clients_pending_io_write = listCreate();
+    server.clients_pending_io_read = listCreate();
+    server.clients_timeout_table = raxNew();
+    server.replication_allowed = 1;
+    server.replicas_eldb = -1; /* Force to emit the first SELECT command. */
+    server.unblocked_clients = listCreate();
+    server.ready_keys = listCreate();
+    server.tracking_pending_keys = listCreate();
+    server.pending_push_messages = listCreate();
+    server.clients_waiting_acks = listCreate();
+    server.get_ack_from_replicas = 0;
+    server.paused_actions = 0;
+    memset(server.client_pause_per_purpose, 0, sizeof(server.client_pause_per_purpose));
+    server.postponed_clients = listCreate();
+    server.events_processed_while_blocked = 0;
+    server.system_memory_size = zmalloc_get_memory_size();
+    server.blocked_last_cron = 0;
+    server.blocking_op_nesting = 0;
+    server.thp_enabled = 0;
+    server.cluster_drop_packet_filter = -1;
+    server.debug_cluster_disable_random_ping = 0;
+    server.reply_buffer_peak_reset_time = REPLY_BUFFER_DEFAULT_PEAK_RESET_TIME;
+    server.reply_buffer_resizing_enabled = 1;
+    server.client_mem_usage_buckets = NULL;
+    resetReplicationBuffer();
+
+    /* Make sure the locale is set on startup based on the config file. */
+    if (setlocale(LC_COLLATE, server.locale_collate) == NULL) {
+        serverLog(LL_WARNING, "Failed to configure LOCALE for invalid locale name.");
+        exit(1);
+    }
+
+    createSharedObjects();
+    adjustOpenFilesLimit();
+    const char *clk_msg = monotonicInit();
+    serverLog(LL_NOTICE, "monotonic clock: %s", clk_msg);
+    server.el = aeCreateEventLoop(server.maxclients + CONFIG_FDSET_INCR);
+    if (server.el == NULL) {
+        serverLog(LL_WARNING, "Failed creating the event loop. Error message: '%s'", strerror(errno));
+        exit(1);
+    }
+    server.db = zmalloc(sizeof(serverDb) * server.dbnum);
+
+    /* Create the databases, and initialize other internal state. */
+    int slot_count_bits = 0;
+    int flags = KVSTORE_ALLOCATE_HASHTABLES_ON_DEMAND;
+    if (server.cluster_enabled) {
+        slot_count_bits = CLUSTER_SLOT_MASK_BITS;
+        flags |= KVSTORE_FREE_EMPTY_HASHTABLES;
+    }
+    for (j = 0; j < server.dbnum; j++) {
+        server.db[j].keys = kvstoreCreate(&kvstoreKeysHashtableType, slot_count_bits, flags);
+        server.db[j].expires = kvstoreCreate(&kvstoreExpiresHashtableType, slot_count_bits, flags);
+        server.db[j].expires_cursor = 0;
+        server.db[j].blocking_keys = dictCreate(&keylistDictType);
+        server.db[j].blocking_keys_unblock_on_nokey = dictCreate(&objectKeyPointerValueDictType);
+        server.db[j].ready_keys = dictCreate(&objectKeyPointerValueDictType);
+        server.db[j].watched_keys = dictCreate(&keylistDictType);
+        server.db[j].id = j;
+        server.db[j].avg_ttl = 0;
+    }
+    evictionPoolAlloc(); /* Initialize the LRU keys pool. */
+    /* Note that server.pubsub_channels was chosen to be a kvstore (with only one dict, which
+     * seems odd) just to make the code cleaner by making it be the same type as server.pubsubshard_channels
+     * (which has to be kvstore), see pubsubtype.serverPubSubChannels */
+    server.pubsub_channels = kvstoreCreate(&kvstoreChannelHashtableType, 0, KVSTORE_ALLOCATE_HASHTABLES_ON_DEMAND);
+    server.pubsub_patterns = dictCreate(&objToDictDictType);
+    server.pubsubshard_channels = kvstoreCreate(&kvstoreChannelHashtableType, slot_count_bits,
+                                                KVSTORE_ALLOCATE_HASHTABLES_ON_DEMAND | KVSTORE_FREE_EMPTY_HASHTABLES);
+    server.pubsub_clients = 0;
+    server.watching_clients = 0;
+    server.cronloops = 0;
+    server.in_exec = 0;
+    server.busy_module_yield_flags = BUSY_MODULE_YIELD_NONE;
+    server.busy_module_yield_reply = NULL;
+    server.client_pause_in_transaction = 0;
+    server.child_pid = -1;
+    server.child_type = CHILD_TYPE_NONE;
+    server.rdb_child_type = RDB_CHILD_TYPE_NONE;
+    server.rdb_pipe_conns = NULL;
+    server.rdb_pipe_numconns = 0;
+    server.rdb_pipe_numconns_writing = 0;
+    server.rdb_pipe_buff = NULL;
+    server.rdb_pipe_bufflen = 0;
+    server.rdb_bgsave_scheduled = 0;
+    server.child_info_pipe[0] = -1;
+    server.child_info_pipe[1] = -1;
+    server.child_info_nread = 0;
+    server.aof_buf = sdsempty();
+    server.lastsave = time(NULL); /* At startup we consider the DB saved. */
+    server.lastbgsave_try = 0;    /* At startup we never tried to BGSAVE. */
+    server.rdb_save_time_last = -1;
+    server.rdb_save_time_start = -1;
+    server.rdb_last_load_keys_expired = 0;
+    server.rdb_last_load_keys_loaded = 0;
+    server.dirty = 0;
+    server.crashed = 0;
+    resetServerStats();
+    /* A few stats we don't want to reset: server startup time, and peak mem. */
+    server.stat_starttime = time(NULL);
+    server.stat_peak_memory = 0;
+    server.stat_current_cow_peak = 0;
+    server.stat_current_cow_bytes = 0;
+    server.stat_current_cow_updated = 0;
+    server.stat_current_save_keys_processed = 0;
+    server.stat_current_save_keys_total = 0;
+    server.stat_rdb_cow_bytes = 0;
+    server.stat_aof_cow_bytes = 0;
+    server.stat_module_cow_bytes = 0;
+    server.stat_module_progress = 0;
+    for (int j = 0; j < CLIENT_TYPE_COUNT; j++) server.stat_clients_type_memory[j] = 0;
+    server.stat_cluster_links_memory = 0;
+    server.cron_malloc_stats.zmalloc_used = 0;
+    server.cron_malloc_stats.process_rss = 0;
+    server.cron_malloc_stats.allocator_allocated = 0;
+    server.cron_malloc_stats.allocator_active = 0;
+    server.cron_malloc_stats.allocator_resident = 0;
+    server.lastbgsave_status = C_OK;
+    server.aof_last_write_status = C_OK;
+    server.aof_last_write_errno = 0;
+    server.repl_good_replicas_count = 0;
+    server.last_sig_received = 0;
+
+    /* Initiate acl info struct */
+    server.acl_info.invalid_cmd_accesses = 0;
+    server.acl_info.invalid_key_accesses = 0;
+    server.acl_info.user_auth_failures = 0;
+    server.acl_info.invalid_channel_accesses = 0;
+
+    /* Create the timer callback, this is our way to process many background
+     * operations incrementally, like clients timeout, eviction of unaccessed
+     * expired keys and so forth. */
+    if (aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL) == AE_ERR) {
+        serverPanic("Can't create event loop timers.");
+        exit(1);
+    }
+
+    /* Register a readable event for the pipe used to awake the event loop
+     * from module threads. */
+    if (aeCreateFileEvent(server.el, server.module_pipe[0], AE_READABLE, modulePipeReadable, NULL) == AE_ERR) {
+        serverPanic("Error registering the readable event for the module pipe.");
+    }
+
+    /* Register before and after sleep handlers (note this needs to be done
+     * before loading persistence since it is used by processEventsWhileBlocked. */
+    aeSetBeforeSleepProc(server.el, beforeSleep);
+    aeSetAfterSleepProc(server.el, afterSleep);
+
+    /* 32 bit instances are limited to 4GB of address space, so if there is
+     * no explicit limit in the user provided configuration we set a limit
+     * at 3 GB using maxmemory with 'noeviction' policy'. This avoids
+     * useless crashes of the instance for out of memory. */
+    if (server.arch_bits == 32 && server.maxmemory == 0) {
+        serverLog(LL_WARNING, "Warning: 32 bit instance detected but no memory limit set. Setting 3 GB maxmemory limit "
+                              "with 'noeviction' policy now.");
+        server.maxmemory = 3072LL * (1024 * 1024); /* 3 GB */
+        server.maxmemory_policy = MAXMEMORY_NO_EVICTION;
+    }
+
+    if (scriptingEngineManagerInit() == C_ERR) {
+        serverPanic("Scripting engine manager initialization failed, check the server logs.");
+    }
+
+    /* Initialize the LUA scripting engine. */
+    scriptingInit(1);
+    /* Initialize the functions engine based off of LUA initialization. */
+    if (functionsInit() == C_ERR) {
+        serverPanic("Functions initialization failed, check the server logs.");
+    }
+    commandlogInit();
+    latencyMonitorInit();
+    initSharedQueryBuf();
+
+    /* Initialize ACL default password if it exists */
+    ACLUpdateDefaultUserPassword(server.requirepass);
+
+    applyWatchdogPeriod();
+
+    if (server.maxmemory_clients != 0) initServerClientMemUsageBuckets();
+}
+
+void initListeners(void) {
+    /* Setup listeners from server config for TCP/TLS/Unix */
+    int conn_index;
+    connListener *listener;
+    if (server.port != 0) {
+        conn_index = connectionIndexByType(CONN_TYPE_SOCKET);
+        if (conn_index < 0) serverPanic("Failed finding connection listener of %s", CONN_TYPE_SOCKET);
+        listener = &server.listeners[conn_index];
+        listener->bindaddr = server.bindaddr;
+        listener->bindaddr_count = server.bindaddr_count;
+        listener->port = server.port;
+        listener->ct = connectionByType(CONN_TYPE_SOCKET);
+    }
+
+    if (server.tls_port || server.tls_replication || server.tls_cluster) {
+        ConnectionType *ct_tls = connectionTypeTls();
+        if (!ct_tls) {
+            serverLog(LL_WARNING, "Failed finding TLS support.");
+            exit(1);
+        }
+        if (connTypeConfigure(ct_tls, &server.tls_ctx_config, 1) == C_ERR) {
+            serverLog(LL_WARNING, "Failed to configure TLS. Check logs for more info.");
+            exit(1);
+        }
+    }
+
+    if (server.tls_port != 0) {
+        conn_index = connectionIndexByType(CONN_TYPE_TLS);
+        if (conn_index < 0) serverPanic("Failed finding connection listener of %s", CONN_TYPE_TLS);
+        listener = &server.listeners[conn_index];
+        listener->bindaddr = server.bindaddr;
+        listener->bindaddr_count = server.bindaddr_count;
+        listener->port = server.tls_port;
+        listener->ct = connectionByType(CONN_TYPE_TLS);
+    }
+    if (server.unixsocket != NULL) {
+        conn_index = connectionIndexByType(CONN_TYPE_UNIX);
+        if (conn_index < 0) serverPanic("Failed finding connection listener of %s", CONN_TYPE_UNIX);
+        listener = &server.listeners[conn_index];
+        listener->bindaddr = &server.unixsocket;
+        listener->bindaddr_count = 1;
+        listener->ct = connectionByType(CONN_TYPE_UNIX);
+        listener->priv = &server.unix_ctx_config; /* Unix socket specified */
+    }
+
+    if (server.rdma_ctx_config.port != 0) {
+        conn_index = connectionIndexByType(CONN_TYPE_RDMA);
+        if (conn_index < 0) serverPanic("Failed finding connection listener of %s", CONN_TYPE_RDMA);
+        listener = &server.listeners[conn_index];
+        listener->bindaddr = server.rdma_ctx_config.bindaddr;
+        listener->bindaddr_count = server.rdma_ctx_config.bindaddr_count;
+        listener->port = server.rdma_ctx_config.port;
+        listener->ct = connectionByType(CONN_TYPE_RDMA);
+        listener->priv = &server.rdma_ctx_config;
+    }
+
+    /* create all the configured listener, and add handler to start to accept */
+    int listen_fds = 0;
+    for (int j = 0; j < CONN_TYPE_MAX; j++) {
+        listener = &server.listeners[j];
+        if (listener->ct == NULL) continue;
+
+        if (connListen(listener) == C_ERR) {
+            serverLog(LL_WARNING, "Failed listening on port %u (%s), aborting.", listener->port,
+                      listener->ct->get_type(NULL));
+            exit(1);
+        }
+
+        if (createSocketAcceptHandler(listener, connAcceptHandler(listener->ct)) != C_OK)
+            serverPanic("Unrecoverable error creating %s listener accept handler.", listener->ct->get_type(NULL));
+
+        listen_fds += listener->count;
+    }
+
+    if (listen_fds == 0) {
+        serverLog(LL_WARNING, "Configured to not listen anywhere, exiting.");
+        exit(1);
+    }
+}
+
+/* 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(void) {
+    bioInit();
+    initIOThreads();
+    set_jemalloc_bg_thread(server.jemalloc_bg_thread);
+    server.initial_memory_usage = zmalloc_used_memory();
+}
+
+/* The purpose of this function is to try to "glue" consecutive range
+ * key specs in order to build the legacy (first,last,step) spec
+ * used by the COMMAND command.
+ * By far the most common case is just one range spec (e.g. SET)
+ * but some commands' ranges were split into two or more ranges
+ * in order to have different flags for different keys (e.g. SMOVE,
+ * first key is "RW ACCESS DELETE", second key is "RW INSERT").
+ *
+ * Additionally set the CMD_MOVABLE_KEYS flag for commands that may have key
+ * names in their arguments, but the legacy range spec doesn't cover all of them.
+ *
+ * This function uses very basic heuristics and is "best effort":
+ * 1. Only commands which have only "range" specs are considered.
+ * 2. Only range specs with keystep of 1 are considered.
+ * 3. The order of the range specs must be ascending (i.e.
+ *    lastkey of spec[i] == firstkey-1 of spec[i+1]).
+ *
+ * This function will succeed on all native commands and may
+ * fail on module commands, even if it only has "range" specs that
+ * could actually be "glued", in the following cases:
+ * 1. The order of "range" specs is not ascending (e.g. the spec for
+ *    the key at index 2 was added before the spec of the key at
+ *    index 1).
+ * 2. The "range" specs have keystep >1.
+ *
+ * If this functions fails it means that the legacy (first,last,step)
+ * spec used by COMMAND will show 0,0,0. This is not a dire situation
+ * because anyway the legacy (first,last,step) spec is to be deprecated
+ * and one should use the new key specs scheme.
+ */
+void populateCommandLegacyRangeSpec(struct serverCommand *c) {
+    memset(&c->legacy_range_key_spec, 0, sizeof(c->legacy_range_key_spec));
+
+    /* Set the movablekeys flag if we have a GETKEYS flag for modules.
+     * Note that for native commands, we always have keyspecs,
+     * with enough information to rely on for movablekeys. */
+    if (c->flags & CMD_MODULE_GETKEYS) c->flags |= CMD_MOVABLE_KEYS;
+
+    /* no key-specs, no keys, exit. */
+    if (c->key_specs_num == 0) {
+        return;
+    }
+
+    if (c->key_specs_num == 1 && c->key_specs[0].begin_search_type == KSPEC_BS_INDEX &&
+        c->key_specs[0].find_keys_type == KSPEC_FK_RANGE) {
+        /* Quick win, exactly one range spec. */
+        c->legacy_range_key_spec = c->key_specs[0];
+        /* If it has the incomplete flag, set the movablekeys flag on the command. */
+        if (c->key_specs[0].flags & CMD_KEY_INCOMPLETE) c->flags |= CMD_MOVABLE_KEYS;
+        return;
+    }
+
+    int firstkey = INT_MAX, lastkey = 0;
+    int prev_lastkey = 0;
+    for (int i = 0; i < c->key_specs_num; i++) {
+        if (c->key_specs[i].begin_search_type != KSPEC_BS_INDEX || c->key_specs[i].find_keys_type != KSPEC_FK_RANGE) {
+            /* Found an incompatible (non range) spec, skip it, and set the movablekeys flag. */
+            c->flags |= CMD_MOVABLE_KEYS;
+            continue;
+        }
+        if (c->key_specs[i].fk.range.keystep != 1 ||
+            (prev_lastkey && prev_lastkey != c->key_specs[i].bs.index.pos - 1)) {
+            /* Found a range spec that's not plain (step of 1) or not consecutive to the previous one.
+             * Skip it, and we set the movablekeys flag. */
+            c->flags |= CMD_MOVABLE_KEYS;
+            continue;
+        }
+        if (c->key_specs[i].flags & CMD_KEY_INCOMPLETE) {
+            /* The spec we're using is incomplete, we can use it, but we also have to set the movablekeys flag. */
+            c->flags |= CMD_MOVABLE_KEYS;
+        }
+        firstkey = min(firstkey, c->key_specs[i].bs.index.pos);
+        /* Get the absolute index for lastkey (in the "range" spec, lastkey is relative to firstkey) */
+        int lastkey_abs_index = c->key_specs[i].fk.range.lastkey;
+        if (lastkey_abs_index >= 0) lastkey_abs_index += c->key_specs[i].bs.index.pos;
+        /* For lastkey we use unsigned comparison to handle negative values correctly */
+        lastkey = max((unsigned)lastkey, (unsigned)lastkey_abs_index);
+        prev_lastkey = lastkey;
+    }
+
+    if (firstkey == INT_MAX) {
+        /* Couldn't find range specs, the legacy range spec will remain empty, and we set the movablekeys flag. */
+        c->flags |= CMD_MOVABLE_KEYS;
+        return;
+    }
+
+    serverAssert(firstkey != 0);
+    serverAssert(lastkey != 0);
+
+    c->legacy_range_key_spec.begin_search_type = KSPEC_BS_INDEX;
+    c->legacy_range_key_spec.bs.index.pos = firstkey;
+    c->legacy_range_key_spec.find_keys_type = KSPEC_FK_RANGE;
+    c->legacy_range_key_spec.fk.range.lastkey =
+        lastkey < 0 ? lastkey : (lastkey - firstkey); /* in the "range" spec, lastkey is relative to firstkey */
+    c->legacy_range_key_spec.fk.range.keystep = 1;
+    c->legacy_range_key_spec.fk.range.limit = 0;
+}
+
+sds catSubCommandFullname(const char *parent_name, const char *sub_name) {
+    return sdscatfmt(sdsempty(), "%s|%s", parent_name, sub_name);
+}
+
+void commandAddSubcommand(struct serverCommand *parent, struct serverCommand *subcommand) {
+    if (!parent->subcommands_ht) parent->subcommands_ht = hashtableCreate(&subcommandSetType);
+
+    subcommand->parent = parent;                            /* Assign the parent command */
+    subcommand->id = ACLGetCommandID(subcommand->fullname); /* Assign the ID used for ACL. */
+
+    serverAssert(hashtableAdd(parent->subcommands_ht, subcommand));
+}
+
+/* Set implicit ACl categories (see comment above the definition of
+ * struct serverCommand). */
+void setImplicitACLCategories(struct serverCommand *c) {
+    if (c->flags & CMD_WRITE) c->acl_categories |= ACL_CATEGORY_WRITE;
+    /* Exclude scripting commands from the RO category. */
+    if (c->flags & CMD_READONLY && !(c->acl_categories & ACL_CATEGORY_SCRIPTING))
+        c->acl_categories |= ACL_CATEGORY_READ;
+    if (c->flags & CMD_ADMIN) c->acl_categories |= ACL_CATEGORY_ADMIN | ACL_CATEGORY_DANGEROUS;
+    if (c->flags & CMD_PUBSUB) c->acl_categories |= ACL_CATEGORY_PUBSUB;
+    if (c->flags & CMD_FAST) c->acl_categories |= ACL_CATEGORY_FAST;
+    if (c->flags & CMD_BLOCKING) c->acl_categories |= ACL_CATEGORY_BLOCKING;
+
+    /* If it's not @fast is @slow in this binary world. */
+    if (!(c->acl_categories & ACL_CATEGORY_FAST)) c->acl_categories |= ACL_CATEGORY_SLOW;
+}
+
+/* Recursively populate the command structure.
+ *
+ * On success, the function return C_OK. Otherwise C_ERR is returned and we won't
+ * add this command in the commands dict. */
+int populateCommandStructure(struct serverCommand *c) {
+    /* If the command marks with CMD_SENTINEL, it exists in sentinel. */
+    if (!(c->flags & CMD_SENTINEL) && server.sentinel_mode) return C_ERR;
+
+    /* If the command marks with CMD_ONLY_SENTINEL, it only exists in sentinel. */
+    if (c->flags & CMD_ONLY_SENTINEL && !server.sentinel_mode) return C_ERR;
+
+    /* Translate the command string flags description into an actual
+     * set of flags. */
+    setImplicitACLCategories(c);
+
+    /* We start with an unallocated histogram and only allocate memory when a command
+     * has been issued for the first time */
+    c->latency_histogram = NULL;
+
+    /* Handle the legacy range spec and the "movablekeys" flag (must be done after populating all key specs). */
+    populateCommandLegacyRangeSpec(c);
+
+    /* Assign the ID used for ACL. */
+    c->id = ACLGetCommandID(c->fullname);
+
+    /* Handle subcommands */
+    if (c->subcommands) {
+        for (int j = 0; c->subcommands[j].declared_name; j++) {
+            struct serverCommand *sub = c->subcommands + j;
+
+            sub->fullname = catSubCommandFullname(c->declared_name, sub->declared_name);
+            if (populateCommandStructure(sub) == C_ERR) continue;
+
+            commandAddSubcommand(c, sub);
+        }
+    }
+
+    return C_OK;
+}
+
+extern struct serverCommand serverCommandTable[];
+
+/* Populates the Command Table dict from the static table in commands.c
+ * which is auto generated from the json files in the commands folder. */
+void populateCommandTable(void) {
+    int j;
+    struct serverCommand *c;
+
+    for (j = 0;; j++) {
+        c = serverCommandTable + j;
+        if (c->declared_name == NULL) break;
+
+        int retval1, retval2;
+
+        c->fullname = sdsnew(c->declared_name);
+        if (populateCommandStructure(c) == C_ERR) continue;
+
+        retval1 = hashtableAdd(server.commands, c);
+        /* Populate an additional dictionary that will be unaffected
+         * by rename-command statements in futriixconf. */
+        retval2 = hashtableAdd(server.orig_commands, c);
+        serverAssert(retval1 && retval2);
+    }
+}
+
+void resetCommandTableStats(hashtable *commands) {
+    hashtableIterator iter;
+    void *next;
+    hashtableInitIterator(&iter, commands, HASHTABLE_ITER_SAFE);
+    while (hashtableNext(&iter, &next)) {
+        struct serverCommand *c = next;
+        c->microseconds = 0;
+        c->calls = 0;
+        c->rejected_calls = 0;
+        c->failed_calls = 0;
+        if (c->latency_histogram) {
+            hdr_close(c->latency_histogram);
+            c->latency_histogram = NULL;
+        }
+        if (c->subcommands_ht) resetCommandTableStats(c->subcommands_ht);
+    }
+    hashtableResetIterator(&iter);
+}
+
+void resetErrorTableStats(void) {
+    freeErrorsRadixTreeAsync(server.errors);
+    server.errors = raxNew();
+}
+
+/* ========================== OP Array API ============================ */
+
+int serverOpArrayAppend(serverOpArray *oa, int dbid, robj **argv, int argc, int target) {
+    serverOp *op;
+    int prev_capacity = oa->capacity;
+
+    if (oa->numops == 0) {
+        oa->capacity = 16;
+    } else if (oa->numops >= oa->capacity) {
+        oa->capacity *= 2;
+    }
+
+    if (prev_capacity != oa->capacity) oa->ops = zrealloc(oa->ops, sizeof(serverOp) * oa->capacity);
+    op = oa->ops + oa->numops;
+    op->dbid = dbid;
+    op->argv = argv;
+    op->argc = argc;
+    op->target = target;
+    oa->numops++;
+    return oa->numops;
+}
+
+void serverOpArrayFree(serverOpArray *oa) {
+    while (oa->numops) {
+        int j;
+        serverOp *op;
+
+        oa->numops--;
+        op = oa->ops + oa->numops;
+        for (j = 0; j < op->argc; j++) decrRefCount(op->argv[j]);
+        zfree(op->argv);
+    }
+    /* no need to free the actual op array, we reuse the memory for future commands */
+    serverAssert(!oa->numops);
+}
+
+/* ====================== Commands lookup and execution ===================== */
+
+int isContainerCommandBySds(sds s) {
+    void *entry;
+    int found_command = hashtableFind(server.commands, s, &entry);
+    struct serverCommand *base_cmd = entry;
+    int has_subcommands = found_command && base_cmd->subcommands_ht;
+    return has_subcommands;
+}
+
+struct serverCommand *lookupSubcommand(struct serverCommand *container, sds sub_name) {
+    void *entry = NULL;
+    hashtableFind(container->subcommands_ht, sub_name, &entry);
+    struct serverCommand *subcommand = entry;
+    return subcommand;
+}
+
+/* Look up a command by argv and argc
+ *
+ * If `strict` is not 0 we expect argc to be exact (i.e. argc==2
+ * for a subcommand and argc==1 for a top-level command)
+ * `strict` should be used every time we want to look up a command
+ * name (e.g. in COMMAND INFO) rather than to find the command
+ * a user requested to execute (in processCommand).
+ */
+struct serverCommand *lookupCommandLogic(hashtable *commands, robj **argv, int argc, int strict) {
+    void *entry = NULL;
+    int found_command = hashtableFind(commands, argv[0]->ptr, &entry);
+    struct serverCommand *base_cmd = entry;
+    int has_subcommands = found_command && base_cmd->subcommands_ht;
+    if (argc == 1 || !has_subcommands) {
+        if (strict && argc != 1) return NULL;
+        /* Note: It is possible that base_cmd->proc==NULL (e.g. CONFIG) */
+        return base_cmd;
+    } else { /* argc > 1 && has_subcommands */
+        if (strict && argc != 2) return NULL;
+        /* Note: Currently we support just one level of subcommands */
+        return lookupSubcommand(base_cmd, argv[1]->ptr);
+    }
+}
+
+struct serverCommand *lookupCommand(robj **argv, int argc) {
+    return lookupCommandLogic(server.commands, argv, argc, 0);
+}
+
+struct serverCommand *lookupCommandBySdsLogic(hashtable *commands, sds s) {
+    int argc, j;
+    sds *strings = sdssplitlen(s, sdslen(s), "|", 1, &argc);
+    if (strings == NULL) return NULL;
+    if (argc < 1 || argc > 2) {
+        /* Currently we support just one level of subcommands */
+        sdsfreesplitres(strings, argc);
+        return NULL;
+    }
+
+    serverAssert(argc > 0); /* Avoid warning `-Wmaybe-uninitialized` in lookupCommandLogic() */
+    robj objects[argc];
+    robj *argv[argc];
+    for (j = 0; j < argc; j++) {
+        initStaticStringObject(objects[j], strings[j]);
+        argv[j] = &objects[j];
+    }
+
+    struct serverCommand *cmd = lookupCommandLogic(commands, argv, argc, 1);
+    sdsfreesplitres(strings, argc);
+    return cmd;
+}
+
+struct serverCommand *lookupCommandBySds(sds s) {
+    return lookupCommandBySdsLogic(server.commands, s);
+}
+
+struct serverCommand *lookupCommandByCStringLogic(hashtable *commands, const char *s) {
+    struct serverCommand *cmd;
+    sds name = sdsnew(s);
+
+    cmd = lookupCommandBySdsLogic(commands, name);
+    sdsfree(name);
+    return cmd;
+}
+
+struct serverCommand *lookupCommandByCString(const char *s) {
+    return lookupCommandByCStringLogic(server.commands, s);
+}
+
+/* Lookup the command in the current table, if not found also check in
+ * the original table containing the original command names unaffected by
+ * futriix.conf rename-command statement.
+ *
+ * This is used by functions rewriting the argument vector such as
+ * rewriteClientCommandVector() in order to set client->cmd pointer
+ * correctly even if the command was renamed. */
+struct serverCommand *lookupCommandOrOriginal(robj **argv, int argc) {
+    struct serverCommand *cmd = lookupCommandLogic(server.commands, argv, argc, 0);
+
+    if (!cmd) cmd = lookupCommandLogic(server.orig_commands, argv, argc, 0);
+    return cmd;
+}
+
+/* Commands arriving from the primary client or AOF client, should never be rejected. */
+int mustObeyClient(client *c) {
+    return c->id == CLIENT_ID_AOF || c->flag.primary;
+}
+
+static int shouldPropagate(int target) {
+    if (!server.replication_allowed || target == PROPAGATE_NONE || server.loading) return 0;
+
+    if (target & PROPAGATE_AOF) {
+        if (server.aof_state != AOF_OFF) return 1;
+    }
+    if (target & PROPAGATE_REPL) {
+        if (server.primary_host == NULL && (server.repl_backlog || listLength(server.replicas) != 0)) return 1;
+    }
+
+    return 0;
+}
+
+/* Propagate the specified command (in the context of the specified database id)
+ * to AOF and replicas.
+ *
+ * flags are an xor between:
+ * + PROPAGATE_NONE (no propagation of command at all)
+ * + PROPAGATE_AOF (propagate into the AOF file if is enabled)
+ * + PROPAGATE_REPL (propagate into the replication link)
+ *
+ * This is an internal low-level function and should not be called!
+ *
+ * The API for propagating commands is alsoPropagate().
+ *
+ * dbid value of -1 is saved to indicate that the called do not want
+ * to replicate SELECT for this command (used for database neutral commands).
+ */
+static void propagateNow(int dbid, robj **argv, int argc, int target) {
+    if (!shouldPropagate(target)) return;
+
+    /* This needs to be unreachable since the dataset should be fixed during
+     * replica pause (otherwise data may be lost during a failover).
+     *
+     * Though, there are exceptions:
+     *
+     * 1. We allow write commands that were queued up before and after to
+     *    execute, if a CLIENT PAUSE executed during a transaction, we will
+     *    track the state, the CLIENT PAUSE takes effect only after a transaction
+     *    has finished.
+     * 2. Primary loses a slot during the pause, deletes all keys and replicates
+     *    DEL to its replicas. In this case, we will track the state, the dirty
+     *    slots will be deleted in the end without affecting the data consistency.
+     *
+     * Note that case 2 can happen in one of the following scenarios:
+     * 1) The primary waits for the replica to replicate before exiting, see
+     *    shutdown-timeout in conf for more details. In this case, primary lost
+     *    a slot during the SIGTERM waiting.
+     * 2) The primary waits for the replica to replicate during a manual failover.
+     *    In this case, primary lost a slot during the pausing.
+     * 3) The primary was paused by CLIENT PAUSE, and lost a slot during the
+     *    pausing. */
+    serverAssert(!isPausedActions(PAUSE_ACTION_REPLICA) || server.client_pause_in_transaction ||
+                 server.server_del_keys_in_slot);
+
+    if (server.aof_state != AOF_OFF && target & PROPAGATE_AOF) feedAppendOnlyFile(dbid, argv, argc);
+    if (target & PROPAGATE_REPL) replicationFeedReplicas(dbid, argv, argc);
+}
+
+/* Used inside commands to schedule the propagation of additional commands
+ * after the current command is propagated to AOF / Replication.
+ *
+ * dbid is the database ID the command should be propagated into.
+ * Arguments of the command to propagate are passed as an array of
+ * Objects pointers of len 'argc', using the 'argv' vector.
+ *
+ * The function does not take a reference to the passed 'argv' vector,
+ * so it is up to the caller to release the passed argv (but it is usually
+ * stack allocated).  The function automatically increments ref count of
+ * passed objects, so the caller does not need to. */
+void alsoPropagate(int dbid, robj **argv, int argc, int target) {
+    robj **argvcopy;
+    int j;
+
+    if (!shouldPropagate(target)) return;
+
+    argvcopy = zmalloc(sizeof(robj *) * argc);
+    for (j = 0; j < argc; j++) {
+        argvcopy[j] = argv[j];
+        incrRefCount(argv[j]);
+    }
+    serverOpArrayAppend(&server.also_propagate, dbid, argvcopy, argc, target);
+}
+
+/* It is possible to call the function forceCommandPropagation() inside a
+ * command implementation in order to to force the propagation of a
+ * specific command execution into AOF / Replication. */
+void forceCommandPropagation(client *c, int flags) {
+    serverAssert(c->cmd->flags & (CMD_WRITE | CMD_MAY_REPLICATE));
+    if (flags & PROPAGATE_REPL) c->flag.force_repl = 1;
+    if (flags & PROPAGATE_AOF) c->flag.force_aof = 1;
+}
+
+/* Avoid that the executed command is propagated at all. This way we
+ * are free to just propagate what we want using the alsoPropagate()
+ * API. */
+void preventCommandPropagation(client *c) {
+    c->flag.prevent_prop = 1;
+}
+
+/* AOF specific version of preventCommandPropagation(). */
+void preventCommandAOF(client *c) {
+    c->flag.prevent_aof_prop = 1;
+}
+
+/* Replication specific version of preventCommandPropagation(). */
+void preventCommandReplication(client *c) {
+    c->flag.prevent_repl_prop = 1;
+}
+
+/* This function is called in order to update the total command histogram duration.
+ * The latency unit is nano-seconds.
+ * If needed it will allocate the histogram memory and trim the duration to the upper/lower tracking limits*/
+void updateCommandLatencyHistogram(struct hdr_histogram **latency_histogram, int64_t duration_hist) {
+    if (duration_hist < LATENCY_HISTOGRAM_MIN_VALUE) duration_hist = LATENCY_HISTOGRAM_MIN_VALUE;
+    if (duration_hist > LATENCY_HISTOGRAM_MAX_VALUE) duration_hist = LATENCY_HISTOGRAM_MAX_VALUE;
+    if (*latency_histogram == NULL)
+        hdr_init(LATENCY_HISTOGRAM_MIN_VALUE, LATENCY_HISTOGRAM_MAX_VALUE, LATENCY_HISTOGRAM_PRECISION,
+                 latency_histogram);
+    hdr_record_value(*latency_histogram, duration_hist);
+}
+
+/* Handle the alsoPropagate() API to handle commands that want to propagate
+ * multiple separated commands. Note that alsoPropagate() is not affected
+ * by CLIENT_PREVENT_PROP flag. */
+static void propagatePendingCommands(void) {
+    if (server.also_propagate.numops == 0) return;
+
+    int j;
+    serverOp *rop;
+
+    /* If we got here it means we have finished an execution-unit.
+     * If that unit has caused propagation of multiple commands, they
+     * should be propagated as a transaction */
+    int transaction = server.also_propagate.numops > 1;
+
+    /* In case a command that may modify random keys was run *directly*
+     * (i.e. not from within a script, MULTI/EXEC, RM_Call, etc.) we want
+     * to avoid using a transaction (much like active-expire) */
+    if (server.current_client && server.current_client->cmd &&
+        server.current_client->cmd->flags & CMD_TOUCHES_ARBITRARY_KEYS) {
+        transaction = 0;
+    }
+
+    if (transaction) {
+        /* We use dbid=-1 to indicate we do not want to replicate SELECT.
+         * It'll be inserted together with the next command (inside the MULTI) */
+        propagateNow(-1, &shared.multi, 1, PROPAGATE_AOF | PROPAGATE_REPL);
+    }
+
+    for (j = 0; j < server.also_propagate.numops; j++) {
+        rop = &server.also_propagate.ops[j];
+        serverAssert(rop->target);
+        propagateNow(rop->dbid, rop->argv, rop->argc, rop->target);
+    }
+
+    if (transaction) {
+        /* We use dbid=-1 to indicate we do not want to replicate select */
+        propagateNow(-1, &shared.exec, 1, PROPAGATE_AOF | PROPAGATE_REPL);
+    }
+
+    serverOpArrayFree(&server.also_propagate);
+}
+
+/* Performs operations that should be performed after an execution unit ends.
+ * Execution unit is a code that should be done atomically.
+ * Execution units can be nested and do not necessarily start with a server command.
+ *
+ * For example the following is a logical unit:
+ *   active expire ->
+ *      trigger del notification of some module ->
+ *          accessing a key ->
+ *              trigger key miss notification of some other module
+ *
+ * What we want to achieve is that the entire execution unit will be done atomically,
+ * currently with respect to replication and post jobs, but in the future there might
+ * be other considerations. So we basically want the `postUnitOperations` to trigger
+ * after the entire chain finished. */
+void postExecutionUnitOperations(void) {
+    if (server.execution_nesting) return;
+
+    firePostExecutionUnitJobs();
+
+    /* If we are at the top-most call() and not inside a an active module
+     * context (e.g. within a module timer) we can propagate what we accumulated. */
+    propagatePendingCommands();
+
+    /* Module subsystem post-execution-unit logic */
+    modulePostExecutionUnitOperations();
+}
+
+/* Increment the command failure counters (either rejected_calls or failed_calls).
+ * The decision which counter to increment is done using the flags argument, options are:
+ * * ERROR_COMMAND_REJECTED - update rejected_calls
+ * * ERROR_COMMAND_FAILED - update failed_calls
+ *
+ * The function also reset the prev_err_count to make sure we will not count the same error
+ * twice, its possible to pass a NULL cmd value to indicate that the error was counted elsewhere.
+ *
+ * The function returns true if stats was updated and false if not. */
+int incrCommandStatsOnError(struct serverCommand *cmd, int flags) {
+    /* hold the prev error count captured on the last command execution */
+    static long long prev_err_count = 0;
+    int res = 0;
+    if (cmd) {
+        if ((server.stat_total_error_replies - prev_err_count) > 0) {
+            if (flags & ERROR_COMMAND_REJECTED) {
+                cmd->rejected_calls++;
+                res = 1;
+            } else if (flags & ERROR_COMMAND_FAILED) {
+                cmd->failed_calls++;
+                res = 1;
+            }
+        }
+    }
+    prev_err_count = server.stat_total_error_replies;
+    return res;
+}
+
+/* Call() is the core of the server's execution of a command.
+ *
+ * The following flags can be passed:
+ * CMD_CALL_NONE        No flags.
+ * CMD_CALL_PROPAGATE_AOF   Append command to AOF if it modified the dataset
+ *                          or if the client flags are forcing propagation.
+ * CMD_CALL_PROPAGATE_REPL  Send command to replicas if it modified the dataset
+ *                          or if the client flags are forcing propagation.
+ * CMD_CALL_PROPAGATE   Alias for PROPAGATE_AOF|PROPAGATE_REPL.
+ * CMD_CALL_FULL        Alias for SLOWLOG|STATS|PROPAGATE.
+ *
+ * The exact propagation behavior depends on the client flags.
+ * Specifically:
+ *
+ * 1. If the client flags CLIENT_FORCE_AOF or CLIENT_FORCE_REPL are set
+ *    and assuming the corresponding CMD_CALL_PROPAGATE_AOF/REPL is set
+ *    in the call flags, then the command is propagated even if the
+ *    dataset was not affected by the command.
+ * 2. If the client flags CLIENT_PREVENT_REPL_PROP or CLIENT_PREVENT_AOF_PROP
+ *    are set, the propagation into AOF or to replicas is not performed even
+ *    if the command modified the dataset.
+ *
+ * Note that regardless of the client flags, if CMD_CALL_PROPAGATE_AOF
+ * or CMD_CALL_PROPAGATE_REPL are not set, then respectively AOF or
+ * replicas propagation will never occur.
+ *
+ * Client flags are modified by the implementation of a given command
+ * using the following API:
+ *
+ * forceCommandPropagation(client *c, int flags);
+ * preventCommandPropagation(client *c);
+ * preventCommandAOF(client *c);
+ * preventCommandReplication(client *c);
+ *
+ */
+void call(client *c, int flags) {
+    long long dirty;
+    struct ClientFlags client_old_flags = c->flag;
+
+    struct serverCommand *real_cmd = c->realcmd;
+    client *prev_client = server.executing_client;
+    server.executing_client = c;
+
+    /* When call() is issued during loading the AOF we don't want commands called
+     * from module, exec or LUA to go into the commandlog or to populate statistics. */
+    int update_command_stats = !isAOFLoadingContext();
+
+    /* We want to be aware of a client which is making a first time attempt to execute this command
+     * and a client which is reprocessing command again (after being unblocked).
+     * Blocked clients can be blocked in different places and not always it means the call() function has been
+     * called. For example this is required for avoiding double logging to monitors.*/
+    int reprocessing_command = flags & CMD_CALL_REPROCESSING;
+
+    /* Initialization: clear the flags that must be set by the command on
+     * demand, and initialize the array for additional commands propagation. */
+    c->flag.force_aof = 0;
+    c->flag.force_repl = 0;
+    c->flag.prevent_prop = 0;
+
+    /* The server core is in charge of propagation when the first entry point
+     * of call() is processCommand().
+     * The only other option to get to call() without having processCommand
+     * as an entry point is if a module triggers RM_Call outside of call()
+     * context (for example, in a timer).
+     * In that case, the module is in charge of propagation. */
+
+    /* Call the command. */
+    dirty = server.dirty;
+    long long old_primary_repl_offset = server.primary_repl_offset;
+    incrCommandStatsOnError(NULL, 0);
+
+    const long long call_timer = ustime();
+    enterExecutionUnit(1, call_timer);
+
+    /* setting the CLIENT_EXECUTING_COMMAND flag so we will avoid
+     * sending client side caching message in the middle of a command reply.
+     * In case of blocking commands, the flag will be un-set only after successfully
+     * re-processing and unblock the client.*/
+    c->flag.executing_command = 1;
+
+    /* Setting the CLIENT_REPROCESSING_COMMAND flag so that during the actual
+     * processing of the command proc, the client is aware that it is being
+     * re-processed. */
+    if (reprocessing_command) c->flag.reprocessing_command = 1;
+
+    monotime monotonic_start = 0;
+    if (monotonicGetType() == MONOTONIC_CLOCK_HW) monotonic_start = getMonotonicUs();
+
+    c->cmd->proc(c);
+
+    /* Clear the CLIENT_REPROCESSING_COMMAND flag after the proc is executed. */
+    if (reprocessing_command) c->flag.reprocessing_command = 0;
+
+    exitExecutionUnit();
+
+    /* In case client is blocked after trying to execute the command,
+     * it means the execution is not yet completed and we MIGHT reprocess the command in the future. */
+    if (!c->flag.blocked) c->flag.executing_command = 0;
+
+    /* In order to avoid performance implication due to querying the clock using a system call 3 times,
+     * we use a monotonic clock, when we are sure its cost is very low, and fall back to non-monotonic call otherwise. */
+    ustime_t duration;
+    if (monotonicGetType() == MONOTONIC_CLOCK_HW)
+        duration = getMonotonicUs() - monotonic_start;
+    else
+        duration = ustime() - call_timer;
+
+    c->duration += duration;
+    dirty = server.dirty - dirty;
+    if (dirty < 0) dirty = 0;
+
+    /* Update failed command calls if required. */
+
+    if (!incrCommandStatsOnError(real_cmd, ERROR_COMMAND_FAILED) && c->deferred_reply_errors) {
+        /* When call is used from a module client, error stats, and total_error_replies
+         * isn't updated since these errors, if handled by the module, are internal,
+         * and not reflected to users. however, the commandstats does show these calls
+         * (made by RM_Call), so it should log if they failed or succeeded. */
+        real_cmd->failed_calls++;
+    }
+
+    /* After executing command, we will close the client after writing entire
+     * reply if it is set 'CLIENT_CLOSE_AFTER_COMMAND' flag. */
+    if (c->flag.close_after_command) {
+        c->flag.close_after_command = 0;
+        c->flag.close_after_reply = 1;
+    }
+
+    /* Note: the code below uses the real command that was executed
+     * c->cmd and c->lastcmd may be different, in case of MULTI-EXEC or
+     * re-written commands such as EXPIRE, GEOADD, etc. */
+
+    /* Record the latency this command induced on the main thread.
+     * unless instructed by the caller not to log. (happens when processing
+     * a MULTI-EXEC from inside an AOF). */
+    if (update_command_stats) {
+        char *latency_event = (real_cmd->flags & CMD_FAST) ? "fast-command" : "command";
+        latencyAddSampleIfNeeded(latency_event, duration / 1000);
+        if (server.execution_nesting == 0) durationAddSample(EL_DURATION_TYPE_CMD, duration);
+    }
+
+    /* Log the command into the commandlog if needed.
+     * If the client is blocked we will handle commandlog when it is unblocked. */
+    if (update_command_stats && !c->flag.blocked) commandlogPushCurrentCommand(c, real_cmd);
+
+    /* Send the command to clients in MONITOR mode if applicable,
+     * since some administrative commands are considered too dangerous to be shown.
+     * Other exceptions is a client which is unblocked and retrying to process the command
+     * or we are currently in the process of loading AOF. */
+    if (update_command_stats && !reprocessing_command && !(c->cmd->flags & (CMD_SKIP_MONITOR | CMD_ADMIN))) {
+        robj **argv = c->original_argv ? c->original_argv : c->argv;
+        int argc = c->original_argv ? c->original_argc : c->argc;
+        replicationFeedMonitors(c, server.monitors, c->db->id, argv, argc);
+    }
+
+    /* Populate the per-command and per-slot statistics that we show in INFO commandstats and CLUSTER SLOT-STATS,
+     * respectively. If the client is blocked we will handle latency stats and duration when it is unblocked. */
+    if (update_command_stats && !c->flag.blocked) {
+        real_cmd->calls++;
+        real_cmd->microseconds += c->duration;
+        if (server.latency_tracking_enabled && !c->flag.blocked)
+            updateCommandLatencyHistogram(&(real_cmd->latency_histogram), c->duration * 1000);
+        clusterSlotStatsAddCpuDuration(c, c->duration);
+    }
+
+    /* The duration needs to be reset after each call except for a blocked command,
+     * which is expected to record and reset the duration after unblocking. */
+    if (!c->flag.blocked) {
+        c->duration = 0;
+    }
+
+    /* Propagate the command into the AOF and replication link.
+     * We never propagate EXEC explicitly, it will be implicitly
+     * propagated if needed (see propagatePendingCommands).
+     * Also, module commands take care of themselves */
+    if (flags & CMD_CALL_PROPAGATE && !c->flag.prevent_prop && c->cmd->proc != execCommand &&
+        !(c->cmd->flags & CMD_MODULE)) {
+        int propagate_flags = PROPAGATE_NONE;
+
+        /* Check if the command operated changes in the data set. If so
+         * set for replication / AOF propagation. */
+        if (dirty) propagate_flags |= (PROPAGATE_AOF | PROPAGATE_REPL);
+
+        /* If the client forced AOF / replication of the command, set
+         * the flags regardless of the command effects on the data set. */
+        if (c->flag.force_repl) propagate_flags |= PROPAGATE_REPL;
+        if (c->flag.force_aof) propagate_flags |= PROPAGATE_AOF;
+
+        /* However prevent AOF / replication propagation if the command
+         * implementation called preventCommandPropagation() or similar,
+         * or if we don't have the call() flags to do so. */
+        if (c->flag.prevent_repl_prop || c->flag.module_prevent_repl_prop || !(flags & CMD_CALL_PROPAGATE_REPL))
+            propagate_flags &= ~PROPAGATE_REPL;
+        if (c->flag.prevent_aof_prop || c->flag.module_prevent_aof_prop || !(flags & CMD_CALL_PROPAGATE_AOF))
+            propagate_flags &= ~PROPAGATE_AOF;
+
+        /* Call alsoPropagate() only if at least one of AOF / replication
+         * propagation is needed. */
+        if (propagate_flags != PROPAGATE_NONE) alsoPropagate(c->db->id, c->argv, c->argc, propagate_flags);
+    }
+
+    /* Restore the old replication flags, since call() can be executed
+     * recursively. */
+    c->flag.force_aof = client_old_flags.force_aof;
+    c->flag.force_repl = client_old_flags.force_repl;
+    c->flag.prevent_prop = client_old_flags.prevent_prop;
+
+    /* If the client has keys tracking enabled for client side caching,
+     * make sure to remember the keys it fetched via this command. For read-only
+     * scripts, don't process the script, only the commands it executes. */
+    if ((c->cmd->flags & CMD_READONLY) && (c->cmd->proc != evalRoCommand) && (c->cmd->proc != evalShaRoCommand) &&
+        (c->cmd->proc != fcallroCommand)) {
+        /* We use the tracking flag of the original external client that
+         * triggered the command, but we take the keys from the actual command
+         * being executed. */
+        if (server.current_client && (server.current_client->flag.tracking) &&
+            !(server.current_client->flag.tracking_bcast)) {
+            trackingRememberKeys(server.current_client, c);
+        }
+    }
+
+    if (!c->flag.blocked) {
+        /* Modules may call commands in cron, in which case server.current_client
+         * is not set. */
+        if (server.current_client) {
+            server.current_client->commands_processed++;
+        }
+        server.stat_numcommands++;
+    }
+
+    /* Record peak memory after each command and before the eviction that runs
+     * before the next command. */
+    size_t zmalloc_used = zmalloc_used_memory();
+    if (zmalloc_used > server.stat_peak_memory) server.stat_peak_memory = zmalloc_used;
+
+    /* Do some maintenance job and cleanup */
+    afterCommand(c);
+
+    /* Remember the replication offset of the client, right after its last
+     * command that resulted in propagation. */
+    if (old_primary_repl_offset != server.primary_repl_offset) c->woff = server.primary_repl_offset;
+
+    /* Client pause takes effect after a transaction has finished. This needs
+     * to be located after everything is propagated. */
+    if (!server.in_exec && server.client_pause_in_transaction) {
+        server.client_pause_in_transaction = 0;
+    }
+
+    server.executing_client = prev_client;
+}
+
+/* Used when a command that is ready for execution needs to be rejected, due to
+ * various pre-execution checks. it returns the appropriate error to the client.
+ * If there's a transaction is flags it as dirty, and if the command is EXEC,
+ * it aborts the transaction.
+ * The duration is reset, since we reject the command, and it did not record.
+ * Note: 'reply' is expected to end with \r\n */
+void rejectCommand(client *c, robj *reply) {
+    flagTransaction(c);
+    c->duration = 0;
+    if (c->cmd) c->cmd->rejected_calls++;
+    if (c->cmd && c->cmd->proc == execCommand) {
+        execCommandAbort(c, reply->ptr);
+    } else {
+        /* using addReplyError* rather than addReply so that the error can be logged. */
+        addReplyErrorObject(c, reply);
+    }
+}
+
+void rejectCommandSds(client *c, sds s) {
+    flagTransaction(c);
+    c->duration = 0;
+    if (c->cmd) c->cmd->rejected_calls++;
+    if (c->cmd && c->cmd->proc == execCommand) {
+        execCommandAbort(c, s);
+        sdsfree(s);
+    } else {
+        /* The following frees 's'. */
+        addReplyErrorSds(c, s);
+    }
+}
+
+void rejectCommandFormat(client *c, const char *fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+    sds s = sdscatvprintf(sdsempty(), fmt, ap);
+    va_end(ap);
+    /* Make sure there are no newlines in the string, otherwise invalid protocol
+     * is emitted (The args come from the user, they may contain any character). */
+    sdsmapchars(s, "\r\n", "  ", 2);
+    rejectCommandSds(c, s);
+}
+
+/* This is called after a command in call, we can do some maintenance job in it. */
+void afterCommand(client *c) {
+    UNUSED(c);
+    /* Should be done before trackingHandlePendingKeyInvalidations so that we
+     * reply to client before invalidating cache (makes more sense) */
+    postExecutionUnitOperations();
+
+    /* Flush pending tracking invalidations. */
+    trackingHandlePendingKeyInvalidations();
+
+    clusterSlotStatsAddNetworkBytesOutForUserClient(c);
+
+    /* Flush other pending push messages. only when we are not in nested call.
+     * So the messages are not interleaved with transaction response. */
+    if (!server.execution_nesting) listJoin(c->reply, server.pending_push_messages);
+}
+
+/* Check if c->cmd exists, fills `err` with details in case it doesn't.
+ * Return 1 if exists. */
+int commandCheckExistence(client *c, sds *err) {
+    if (c->cmd) return 1;
+    if (!err) return 0;
+    if (isContainerCommandBySds(c->argv[0]->ptr) && c->argc >= 2) {
+        /* If we can't find the command but argv[0] by itself is a command
+         * it means we're dealing with an invalid subcommand. Print Help. */
+        sds cmd = sdsnew((char *)c->argv[0]->ptr);
+        sdstoupper(cmd);
+        *err = sdsnew(NULL);
+        *err = sdscatprintf(*err, "unknown subcommand '%.128s'. Try %s HELP.", (char *)c->argv[1]->ptr, cmd);
+        sdsfree(cmd);
+    } else {
+        sds args = sdsempty();
+        int i;
+        for (i = 1; i < c->argc && sdslen(args) < 128; i++)
+            args = sdscatprintf(args, "'%.*s' ", 128 - (int)sdslen(args), (char *)c->argv[i]->ptr);
+        *err = sdsnew(NULL);
+        *err =
+            sdscatprintf(*err, "unknown command '%.128s', with args beginning with: %s", (char *)c->argv[0]->ptr, args);
+        sdsfree(args);
+    }
+    /* Make sure there are no newlines in the string, otherwise invalid protocol
+     * is emitted (The args come from the user, they may contain any character). */
+    sdsmapchars(*err, "\r\n", "  ", 2);
+    return 0;
+}
+
+/* Check if c->argc is valid for c->cmd, fills `err` with details in case it isn't.
+ * Return 1 if valid. */
+int commandCheckArity(struct serverCommand *cmd, int argc, sds *err) {
+    if ((cmd->arity > 0 && cmd->arity != argc) || (argc < -cmd->arity)) {
+        if (err) {
+            *err = sdsnew(NULL);
+            *err = sdscatprintf(*err, "wrong number of arguments for '%s' command", cmd->fullname);
+        }
+        return 0;
+    }
+
+    return 1;
+}
+
+/* If we're executing a script, try to extract a set of command flags from
+ * it, in case it declared them. Note this is just an attempt, we don't yet
+ * know the script command is well formed.*/
+uint64_t getCommandFlags(client *c) {
+    uint64_t cmd_flags = c->cmd->flags;
+
+    if (c->cmd->proc == fcallCommand || c->cmd->proc == fcallroCommand) {
+        cmd_flags = fcallGetCommandFlags(c, cmd_flags);
+    } else if (c->cmd->proc == evalCommand || c->cmd->proc == evalRoCommand || c->cmd->proc == evalShaCommand ||
+               c->cmd->proc == evalShaRoCommand) {
+        cmd_flags = evalGetCommandFlags(c, cmd_flags);
+    }
+
+    return cmd_flags;
+}
+
+/* If this function gets called we already read a whole
+ * command, arguments are in the client argv/argc fields.
+ * processCommand() execute the command or prepare the
+ * server for a bulk read from the client.
+ *
+ * If C_OK is returned the client is still alive and valid and
+ * 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) {
+    if (!scriptIsTimedout()) {
+        /* Both EXEC and scripts call call() directly so there should be
+         * no way in_exec or scriptIsRunning() is 1.
+         * That is unless lua_timedout, in which case client may run
+         * some commands. */
+        serverAssert(!server.in_exec);
+        serverAssert(!scriptIsRunning());
+    }
+
+    /* in case we are starting to ProcessCommand and we already have a command we assume
+     * this is a reprocessing of this command, so we do not want to perform some of the actions again. */
+    int client_reprocessing_command = c->cmd ? 1 : 0;
+
+    /* only run command filter if not reprocessing command */
+    if (!client_reprocessing_command) {
+        moduleCallCommandFilters(c);
+        reqresAppendRequest(c);
+    }
+
+    /* If we're inside a module blocked context yielding that wants to avoid
+     * processing clients, postpone the command. */
+    if (server.busy_module_yield_flags != BUSY_MODULE_YIELD_NONE &&
+        !(server.busy_module_yield_flags & BUSY_MODULE_YIELD_CLIENTS)) {
+        blockPostponeClient(c);
+        return C_OK;
+    }
+
+    /* Now lookup the command and check ASAP about trivial error conditions
+     * such as wrong arity, bad command name and so forth.
+     * In case we are reprocessing a command after it was blocked,
+     * we do not have to repeat the same checks */
+    if (!client_reprocessing_command) {
+        struct serverCommand *cmd = c->io_parsed_cmd ? c->io_parsed_cmd : lookupCommand(c->argv, c->argc);
+        if (!cmd) {
+            /* Handle possible security attacks. */
+            if (!strcasecmp(c->argv[0]->ptr, "host:") || !strcasecmp(c->argv[0]->ptr, "post")) {
+                securityWarningCommand(c);
+                return C_ERR;
+            }
+        }
+        c->cmd = c->lastcmd = c->realcmd = cmd;
+        sds err;
+        if (!commandCheckExistence(c, &err)) {
+            rejectCommandSds(c, err);
+            return C_OK;
+        }
+        if (!commandCheckArity(c->cmd, c->argc, &err)) {
+            rejectCommandSds(c, err);
+            return C_OK;
+        }
+
+        /* Check if the command is marked as protected and the relevant configuration allows it */
+        if (c->cmd->flags & CMD_PROTECTED) {
+            if ((c->cmd->proc == debugCommand && !allowProtectedAction(server.enable_debug_cmd, c)) ||
+                (c->cmd->proc == moduleCommand && !allowProtectedAction(server.enable_module_cmd, c))) {
+                rejectCommandFormat(c,
+                                    "%s command not allowed. If the %s option is set to \"local\", "
+                                    "you can run it from a local connection, otherwise you need to set this option "
+                                    "in the configuration file, and then restart the server.",
+                                    c->cmd->proc == debugCommand ? "DEBUG" : "MODULE",
+                                    c->cmd->proc == debugCommand ? "enable-debug-command" : "enable-module-command");
+                return C_OK;
+            }
+        }
+    }
+
+    uint64_t cmd_flags = getCommandFlags(c);
+
+    int is_exec = (c->mstate && c->cmd->proc == execCommand);
+    int ms_flags = is_exec ? c->mstate->cmd_flags : 0;
+    int ms_inv_flags = is_exec ? c->mstate->cmd_inv_flags : 0;
+    int combined_flags = cmd_flags | ms_flags;
+    int combined_inv_flags = (~cmd_flags | ms_inv_flags);
+
+    int is_read_command = (combined_flags & CMD_READONLY);
+    int is_write_command = (combined_flags & CMD_WRITE);
+    int is_denyoom_command = (combined_flags & CMD_DENYOOM);
+    int is_denystale_command = (combined_inv_flags & CMD_STALE);
+    int is_denyloading_command = (combined_inv_flags & CMD_LOADING);
+    int is_may_replicate_command = (combined_flags & (CMD_WRITE | CMD_MAY_REPLICATE));
+    int is_deny_async_loading_command = (combined_flags & CMD_NO_ASYNC_LOADING);
+
+    const int obey_client = mustObeyClient(c);
+
+    if (authRequired(c)) {
+        /* AUTH and HELLO and no auth commands are valid even in
+         * non-authenticated state. */
+        if (!(c->cmd->flags & CMD_NO_AUTH)) {
+            rejectCommand(c, shared.noautherr);
+            return C_OK;
+        }
+    }
+
+    if (c->flag.multi && c->cmd->flags & CMD_NO_MULTI) {
+        rejectCommandFormat(c, "Command not allowed inside a transaction");
+        return C_OK;
+    }
+
+    /* Check if the user can run this command according to the current
+     * ACLs. */
+    int acl_errpos;
+    int acl_retval = ACLCheckAllPerm(c, &acl_errpos);
+    if (acl_retval != ACL_OK) {
+        addACLLogEntry(c, acl_retval, (c->flag.multi) ? ACL_LOG_CTX_MULTI : ACL_LOG_CTX_TOPLEVEL, acl_errpos, NULL,
+                       NULL);
+        sds msg = getAclErrorMessage(acl_retval, c->user, c->cmd, c->argv[acl_errpos]->ptr, 0);
+        rejectCommandFormat(c, "-NOPERM %s", msg);
+        sdsfree(msg);
+        return C_OK;
+    }
+
+    /* If cluster is enabled perform the cluster redirection here.
+     * However we don't perform the redirection if:
+     * 1) The sender of this command is our primary.
+     * 2) The command has no key arguments. */
+    if (server.cluster_enabled && !obey_client &&
+        !(!(c->cmd->flags & CMD_MOVABLE_KEYS) && c->cmd->key_specs_num == 0 && c->cmd->proc != execCommand)) {
+        int error_code;
+        clusterNode *n = getNodeByQuery(c, c->cmd, c->argv, c->argc, &c->slot, &error_code);
+        if (n == NULL || !clusterNodeIsMyself(n)) {
+            if (c->cmd->proc == execCommand) {
+                discardTransaction(c);
+            } else {
+                flagTransaction(c);
+            }
+            clusterRedirectClient(c, n, c->slot, error_code);
+            c->duration = 0;
+            c->cmd->rejected_calls++;
+            return C_OK;
+        }
+    }
+
+    if (!server.cluster_enabled && c->capa & CLIENT_CAPA_REDIRECT && server.primary_host && !obey_client &&
+        (is_write_command || (is_read_command && !c->flag.readonly))) {
+        if (server.failover_state == FAILOVER_IN_PROGRESS) {
+            /* During the FAILOVER process, when conditions are met (such as
+             * when the force time is reached or the primary and replica offsets
+             * are consistent), the primary actively becomes the replica and
+             * transitions to the FAILOVER_IN_PROGRESS state.
+             *
+             * After the primary becomes the replica, and after handshaking
+             * and other operations, it will eventually send the PSYNC FAILOVER
+             * command to the replica, then the replica will become the primary.
+             * This means that the upgrade of the replica to the primary is an
+             * asynchronous operation, which implies that during the
+             * FAILOVER_IN_PROGRESS state, there may be a period of time where
+             * both nodes are replicas.
+             *
+             * In this scenario, if a -REDIRECT is returned, the request will be
+             * redirected to the replica and then redirected back, causing back
+             * and forth redirection. To avoid this situation, during the
+             * FAILOVER_IN_PROGRESS state, we temporarily suspend the clients
+             * that need to be redirected until the replica truly becomes the primary,
+             * and then resume the execution. */
+            blockPostponeClient(c);
+        } else {
+            if (c->cmd->proc == execCommand) {
+                discardTransaction(c);
+            } else {
+                flagTransaction(c);
+            }
+            c->duration = 0;
+            c->cmd->rejected_calls++;
+            addReplyErrorSds(c, sdscatprintf(sdsempty(), "-REDIRECT %s:%d", server.primary_host, server.primary_port));
+        }
+        return C_OK;
+    }
+
+    /* Disconnect some clients if total clients memory is too high. We do this
+     * before key eviction, after the last command was executed and consumed
+     * some client output buffer memory. */
+    evictClients();
+    if (server.current_client == NULL) {
+        /* If we evicted ourself then abort processing the command */
+        return C_ERR;
+    }
+
+    /* Handle the maxmemory directive.
+     *
+     * 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. */
+    if (server.maxmemory && !isInsideYieldingLongCommand()) {
+        int out_of_memory = (performEvictions() == EVICT_FAIL);
+
+        /* performEvictions may evict keys, so we need flush pending tracking
+         * invalidation keys. If we don't do this, we may get an invalidation
+         * message after we perform operation on the key, where in fact this
+         * message belongs to the old value of the key before it gets evicted.*/
+        trackingHandlePendingKeyInvalidations();
+
+        /* performEvictions may flush replica output buffers. This may result
+         * in a replica, that may be the active client, to be freed. */
+        if (server.current_client == NULL) return C_ERR;
+
+        if (out_of_memory && is_denyoom_command) {
+            rejectCommand(c, shared.oomerr);
+            return C_OK;
+        }
+
+        /* Save out_of_memory result at command start, otherwise if we check OOM
+         * in the first write within script, memory used by lua stack and
+         * arguments might interfere. We need to save it for EXEC and module
+         * calls too, since these can call EVAL, but avoid saving it during an
+         * interrupted / yielding busy script / module. */
+        server.pre_command_oom_state = out_of_memory;
+    }
+
+    /* Make sure to use a reasonable amount of memory for client side
+     * caching metadata. */
+    if (server.tracking_clients) trackingLimitUsedSlots();
+
+    /* Don't accept write commands if there are problems persisting on disk
+     * unless coming from our primary, in which case check the replica ignore
+     * disk write error config to either log or crash. */
+    int deny_write_type = writeCommandsDeniedByDiskError();
+    if (deny_write_type != DISK_ERROR_TYPE_NONE && (is_write_command || c->cmd->proc == pingCommand)) {
+        if (obey_client) {
+            if (!server.repl_ignore_disk_write_error && c->cmd->proc != pingCommand) {
+                serverPanic("Replica was unable to write command to disk.");
+            } else {
+                static mstime_t last_log_time_ms = 0;
+                const mstime_t log_interval_ms = 10000;
+                if (server.mstime > last_log_time_ms + log_interval_ms) {
+                    last_log_time_ms = server.mstime;
+                    serverLog(LL_WARNING, "Replica is applying a command even though "
+                                          "it is unable to write to disk.");
+                }
+            }
+        } else {
+            sds err = writeCommandsGetDiskErrorMessage(deny_write_type);
+            /* remove the newline since rejectCommandSds adds it. */
+            sdssubstr(err, 0, sdslen(err) - 2);
+            rejectCommandSds(c, err);
+            return C_OK;
+        }
+    }
+
+    /* Don't accept write commands if there are not enough good replicas and
+     * user configured the min-replicas-to-write option. */
+    if (is_write_command && !checkGoodReplicasStatus()) {
+        rejectCommand(c, shared.noreplicaserr);
+        return C_OK;
+    }
+
+    /* Don't accept write commands if this is a read only replica. But
+     * accept write commands if this is our primary. */
+    if (server.primary_host && server.repl_replica_ro && !obey_client && is_write_command) {
+        rejectCommand(c, shared.roreplicaerr);
+        return C_OK;
+    }
+
+    /* Only allow a subset of commands in the context of Pub/Sub if the
+     * connection is in RESP2 mode. With RESP3 there are no limits. */
+    if ((c->flag.pubsub && c->resp == 2) && c->cmd->proc != pingCommand && c->cmd->proc != subscribeCommand &&
+        c->cmd->proc != ssubscribeCommand && c->cmd->proc != unsubscribeCommand &&
+        c->cmd->proc != sunsubscribeCommand && c->cmd->proc != psubscribeCommand &&
+        c->cmd->proc != punsubscribeCommand && c->cmd->proc != quitCommand && c->cmd->proc != resetCommand) {
+        rejectCommandFormat(c,
+                            "Can't execute '%s': only (P|S)SUBSCRIBE / "
+                            "(P|S)UNSUBSCRIBE / PING / QUIT / RESET are allowed in this context",
+                            c->cmd->fullname);
+        return C_OK;
+    }
+
+    /* Only allow commands with flag "t", such as INFO, REPLICAOF and so on,
+     * when replica-serve-stale-data is no and we are a replica with a broken
+     * link with primary. */
+    if (server.primary_host && server.repl_state != REPL_STATE_CONNECTED && server.repl_serve_stale_data == 0 &&
+        is_denystale_command) {
+        rejectCommand(c, shared.primarydownerr);
+        return C_OK;
+    }
+
+    /* Loading DB? Return an error if the command has not the
+     * CMD_LOADING flag. */
+    if (server.loading && !server.async_loading && is_denyloading_command) {
+        rejectCommand(c, shared.loadingerr);
+        return C_OK;
+    }
+
+    /* During async-loading, block certain commands. */
+    if (server.async_loading && is_deny_async_loading_command) {
+        rejectCommand(c, shared.loadingerr);
+        return C_OK;
+    }
+
+    /* when a busy job is being done (script / module)
+     * Only allow a limited number of commands.
+     * Note that we need to allow the transactions commands, otherwise clients
+     * sending a transaction with pipelining without error checking, may have
+     * the MULTI plus a few initial commands refused, then the timeout
+     * condition resolves, and the bottom-half of the transaction gets
+     * executed, see Github PR #7022. */
+    if (isInsideYieldingLongCommand() && !(c->cmd->flags & CMD_ALLOW_BUSY)) {
+        if (server.busy_module_yield_flags && server.busy_module_yield_reply) {
+            rejectCommandFormat(c, "-BUSY %s", server.busy_module_yield_reply);
+        } else if (server.busy_module_yield_flags) {
+            rejectCommand(c, shared.slowmoduleerr);
+        } else if (scriptIsEval()) {
+            rejectCommand(c, shared.slowevalerr);
+        } else {
+            rejectCommand(c, shared.slowscripterr);
+        }
+        return C_OK;
+    }
+
+    /* Prevent a replica from sending commands that access the keyspace.
+     * The main objective here is to prevent abuse of client pause check
+     * from which replicas are exempt. */
+    if (c->flag.replica && (is_may_replicate_command || is_write_command || is_read_command)) {
+        rejectCommandFormat(c, "Replica can't interact with the keyspace");
+        return C_OK;
+    }
+
+    /* If the server is paused, block the client until
+     * the pause has ended. Replicas are never paused. */
+    if (!c->flag.replica && ((isPausedActions(PAUSE_ACTION_CLIENT_ALL)) ||
+                             ((isPausedActions(PAUSE_ACTION_CLIENT_WRITE)) && is_may_replicate_command))) {
+        blockPostponeClient(c);
+        return C_OK;
+    }
+
+    /* Exec the command */
+    if (c->flag.multi && c->cmd->proc != execCommand && c->cmd->proc != discardCommand &&
+        c->cmd->proc != multiCommand && c->cmd->proc != watchCommand && c->cmd->proc != quitCommand &&
+        c->cmd->proc != resetCommand) {
+        queueMultiCommand(c, cmd_flags);
+        addReply(c, shared.queued);
+    } else {
+        int flags = CMD_CALL_FULL;
+        if (client_reprocessing_command) flags |= CMD_CALL_REPROCESSING;
+        call(c, flags);
+        if (listLength(server.ready_keys) && !isInsideYieldingLongCommand()) handleClientsBlockedOnKeys();
+    }
+    return C_OK;
+}
+
+/* ====================== Error lookup and execution ===================== */
+
+void incrementErrorCount(const char *fullerr, size_t namelen) {
+    void *result;
+    if (!raxFind(server.errors, (unsigned char *)fullerr, namelen, &result)) {
+        struct serverError *error = zmalloc(sizeof(*error));
+        error->count = 1;
+        raxInsert(server.errors, (unsigned char *)fullerr, namelen, error, NULL);
+    } else {
+        struct serverError *error = result;
+        error->count++;
+    }
+}
+
+/*================================== Shutdown =============================== */
+
+/* Close listening sockets. Also unlink the unix domain socket if
+ * unlink_unix_socket is non-zero. */
+void closeListeningSockets(int unlink_unix_socket) {
+    int j;
+
+    for (int i = 0; i < CONN_TYPE_MAX; i++) {
+        connListener *listener = &server.listeners[i];
+        if (listener->ct == NULL) continue;
+
+        for (j = 0; j < listener->count; j++) close(listener->fd[j]);
+    }
+
+    if (server.cluster_enabled)
+        for (j = 0; j < server.clistener.count; j++) close(server.clistener.fd[j]);
+    if (unlink_unix_socket && server.unixsocket) {
+        serverLog(LL_NOTICE, "Removing the unix socket file.");
+        if (unlink(server.unixsocket) != 0)
+            serverLog(LL_WARNING, "Error removing the unix socket file: %s", strerror(errno));
+    }
+}
+
+/* Prepare for shutting down the server.
+ *
+ * The client *c can be NULL, it may come from a signal. If client is passed in,
+ * it is used to print the client info.
+ *
+ * Flags:
+ *
+ * - SHUTDOWN_SAVE: Save a database dump even if the server is configured not to
+ *   save any dump.
+ *
+ * - SHUTDOWN_NOSAVE: Don't save any database dump even if the server is
+ *   configured to save one.
+ *
+ * - SHUTDOWN_NOW: Don't wait for replicas to catch up before shutting down.
+ *
+ * - SHUTDOWN_FORCE: Ignore errors writing AOF and RDB files on disk, which
+ *   would normally prevent a shutdown.
+ *
+ * Unless SHUTDOWN_NOW is set and if any replicas are lagging behind, C_ERR is
+ * returned and server.shutdown_mstime is set to a timestamp to allow a grace
+ * period for the replicas to catch up. This is checked and handled by
+ * serverCron() which completes the shutdown as soon as possible.
+ *
+ * If shutting down fails due to errors writing RDB or AOF files, C_ERR is
+ * returned and an error is logged. If the flag SHUTDOWN_FORCE is set, these
+ * errors are logged but ignored and C_OK is returned.
+ *
+ * On success, this function returns C_OK and then it's OK to call exit(0). */
+int prepareForShutdown(client *c, int flags) {
+    if (isShutdownInitiated()) return C_ERR;
+
+    /* When SHUTDOWN is called while the server is loading a dataset in
+     * memory we need to make sure no attempt is performed to save
+     * the dataset on shutdown (otherwise it could overwrite the current DB
+     * with half-read data).
+     *
+     * Also when in Sentinel mode clear the SAVE flag and force NOSAVE. */
+    if (server.loading || server.sentinel_mode) flags = (flags & ~SHUTDOWN_SAVE) | SHUTDOWN_NOSAVE;
+
+    server.shutdown_flags = flags;
+
+    if (c != NULL) {
+        sds client = catClientInfoShortString(sdsempty(), c, server.hide_user_data_from_log);
+        serverLog(LL_NOTICE, "User requested shutdown... (user request from '%s')", client);
+        sdsfree(client);
+    } else {
+        serverLog(LL_NOTICE, "User requested shutdown...");
+    }
+    if (server.supervised_mode == SUPERVISED_SYSTEMD) serverCommunicateSystemd("STOPPING=1\n");
+
+    /* If we have any replicas, let them catch up the replication offset before
+     * we shut down, to avoid data loss. */
+    if (!(flags & SHUTDOWN_NOW) && server.shutdown_timeout != 0 && !isReadyToShutdown()) {
+        server.shutdown_mstime = server.mstime + server.shutdown_timeout * 1000;
+        if (!isPausedActions(PAUSE_ACTION_REPLICA)) sendGetackToReplicas();
+        pauseActions(PAUSE_DURING_SHUTDOWN, LLONG_MAX, PAUSE_ACTIONS_CLIENT_WRITE_SET);
+        serverLog(LL_NOTICE, "Waiting for replicas before shutting down.");
+        return C_ERR;
+    }
+
+    return finishShutdown();
+}
+
+static inline int isShutdownInitiated(void) {
+    return server.shutdown_mstime != 0;
+}
+
+/* Returns 0 if there are any replicas which are lagging in replication which we
+ * need to wait for before shutting down. Returns 1 if we're ready to shut
+ * down now. */
+int isReadyToShutdown(void) {
+    if (listLength(server.replicas) == 0) return 1; /* No replicas. */
+
+    listIter li;
+    listNode *ln;
+    listRewind(server.replicas, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        client *replica = listNodeValue(ln);
+        if (replica->repl_data->repl_ack_off != server.primary_repl_offset) return 0;
+    }
+    return 1;
+}
+
+static void cancelShutdown(void) {
+    server.shutdown_asap = 0;
+    server.shutdown_flags = 0;
+    server.shutdown_mstime = 0;
+    server.last_sig_received = 0;
+    replyToClientsBlockedOnShutdown();
+    unpauseActions(PAUSE_DURING_SHUTDOWN);
+}
+
+/* Returns C_OK if shutdown was aborted and C_ERR if shutdown wasn't ongoing. */
+int abortShutdown(void) {
+    if (isShutdownInitiated()) {
+        cancelShutdown();
+    } else if (server.shutdown_asap) {
+        /* Signal handler has requested shutdown, but it hasn't been initiated
+         * yet. Just clear the flag. */
+        server.shutdown_asap = 0;
+    } else {
+        /* Shutdown neither initiated nor requested. */
+        return C_ERR;
+    }
+    serverLog(LL_NOTICE, "Shutdown manually aborted.");
+    return C_OK;
+}
+
+/* The final step of the shutdown sequence. Returns C_OK if the shutdown
+ * sequence was successful and it's OK to call exit(). If C_ERR is returned,
+ * it's not safe to call exit(). */
+int finishShutdown(void) {
+    int save = server.shutdown_flags & SHUTDOWN_SAVE;
+    int nosave = server.shutdown_flags & SHUTDOWN_NOSAVE;
+    int force = server.shutdown_flags & SHUTDOWN_FORCE;
+
+    /* Log a warning for each replica that is lagging. */
+    listIter replicas_iter;
+    listNode *replicas_list_node;
+    int num_replicas = 0, num_lagging_replicas = 0;
+    listRewind(server.replicas, &replicas_iter);
+    while ((replicas_list_node = listNext(&replicas_iter)) != NULL) {
+        client *replica = listNodeValue(replicas_list_node);
+        num_replicas++;
+        if (replica->repl_data->repl_ack_off != server.primary_repl_offset) {
+            num_lagging_replicas++;
+            long lag = replica->repl_data->repl_state == REPLICA_STATE_ONLINE ? time(NULL) - replica->repl_data->repl_ack_time : 0;
+            serverLog(LL_NOTICE, "Lagging replica %s reported offset %lld behind master, lag=%ld, state=%s.",
+                      replicationGetReplicaName(replica), server.primary_repl_offset - replica->repl_data->repl_ack_off, lag,
+                      replstateToString(replica->repl_data->repl_state));
+        }
+    }
+    if (num_replicas > 0) {
+        serverLog(LL_NOTICE, "%d of %d replicas are in sync when shutting down.", num_replicas - num_lagging_replicas,
+                  num_replicas);
+    }
+
+    /* Kill all the Lua debugger forked sessions. */
+    ldbKillForkedSessions();
+
+    /* Kill the saving child if there is a background saving in progress.
+       We want to avoid race conditions, for instance our saving child may
+       overwrite the synchronous saving did by SHUTDOWN. */
+    if (server.child_type == CHILD_TYPE_RDB) {
+        serverLog(LL_WARNING, "There is a child saving an .rdb. Killing it!");
+        killRDBChild();
+        /* Note that, in killRDBChild normally has backgroundSaveDoneHandler
+         * doing it's cleanup, but in this case this code will not be reached,
+         * so we need to call rdbRemoveTempFile which will close fd(in order
+         * to unlink file actually) in background thread.
+         * The temp rdb file fd may won't be closed when the server exits quickly,
+         * but OS will close this fd when process exits. */
+        rdbRemoveTempFile(server.child_pid, 0);
+    }
+
+    /* Kill module child if there is one. */
+    if (server.child_type == CHILD_TYPE_MODULE) {
+        serverLog(LL_WARNING, "There is a module fork child. Killing it!");
+        TerminateModuleForkChild(server.child_pid, 0);
+    }
+
+    /* Kill the AOF saving child as the AOF we already have may be longer
+     * but contains the full dataset anyway. */
+    if (server.child_type == CHILD_TYPE_AOF) {
+        /* If we have AOF enabled but haven't written the AOF yet, don't
+         * shutdown or else the dataset will be lost. */
+        if (server.aof_state == AOF_WAIT_REWRITE) {
+            if (force) {
+                serverLog(LL_WARNING, "Writing initial AOF. Exit anyway.");
+            } else {
+                serverLog(LL_WARNING, "Writing initial AOF, can't exit.");
+                if (server.supervised_mode == SUPERVISED_SYSTEMD)
+                    serverCommunicateSystemd("STATUS=Writing initial AOF, can't exit.\n");
+                goto error;
+            }
+        }
+        serverLog(LL_WARNING, "There is a child rewriting the AOF. Killing it!");
+        killAppendOnlyChild();
+    }
+    if (server.aof_state != AOF_OFF) {
+        /* Append only file: flush buffers and fsync() the AOF at exit */
+        serverLog(LL_NOTICE, "Calling fsync() on the AOF file.");
+        flushAppendOnlyFile(1);
+        if (valkey_fsync(server.aof_fd) == -1) {
+            serverLog(LL_WARNING, "Fail to fsync the AOF file: %s.", strerror(errno));
+        }
+    }
+
+    /* Create a new RDB file before exiting. */
+    if ((server.saveparamslen > 0 && !nosave) || save) {
+        serverLog(LL_NOTICE, "Saving the final RDB snapshot before exiting.");
+        if (server.supervised_mode == SUPERVISED_SYSTEMD)
+            serverCommunicateSystemd("STATUS=Saving the final RDB snapshot\n");
+        /* Snapshotting. Perform a SYNC SAVE and exit */
+        rdbSaveInfo rsi, *rsiptr;
+        rsiptr = rdbPopulateSaveInfo(&rsi);
+        /* Keep the page cache since it's likely to restart soon */
+        if (rdbSave(REPLICA_REQ_NONE, server.rdb_filename, rsiptr, RDBFLAGS_KEEP_CACHE) != C_OK) {
+            /* Ooops.. error saving! The best we can do is to continue
+             * operating. Note that if there was a background saving process,
+             * in the next cron() the server will be notified that the background
+             * saving aborted, handling special stuff like replicas pending for
+             * synchronization... */
+            if (force) {
+                serverLog(LL_WARNING, "Error trying to save the DB. Exit anyway.");
+            } else {
+                serverLog(LL_WARNING, "Error trying to save the DB, can't exit.");
+                if (server.supervised_mode == SUPERVISED_SYSTEMD)
+                    serverCommunicateSystemd("STATUS=Error trying to save the DB, can't exit.\n");
+                goto error;
+            }
+        }
+    }
+
+    /* Free the AOF manifest. */
+    if (server.aof_manifest) aofManifestFree(server.aof_manifest);
+
+    /* Fire the shutdown modules event. */
+    moduleFireServerEvent(VALKEYMODULE_EVENT_SHUTDOWN, 0, NULL);
+
+    /* Remove the pid file if possible and needed. */
+    if (server.daemonize || server.pidfile) {
+        serverLog(LL_NOTICE, "Removing the pid file.");
+        unlink(server.pidfile);
+    }
+
+    /* Best effort flush of replica output buffers, so that we hopefully
+     * send them pending writes. */
+    flushReplicasOutputBuffers();
+
+    /* Close the listening sockets. Apparently this allows faster restarts. */
+    closeListeningSockets(1);
+
+    /* Handle cluster-related matters when shutdown. */
+    if (server.cluster_enabled) clusterHandleServerShutdown();
+
+    serverLog(LL_WARNING, "%s is now ready to exit, bye bye...", server.sentinel_mode ? "Sentinel" : "Futriix");
+    return C_OK;
+
+error:
+    serverLog(LL_WARNING, "Errors trying to shut down the server. Check the logs for more information.");
+    cancelShutdown();
+    return C_ERR;
+}
+
+/*================================== Commands =============================== */
+
+/* Sometimes the server cannot accept write commands because there is a persistence
+ * error with the RDB or AOF file, and the server is configured in order to stop
+ * accepting writes in such situation. This function returns if such a
+ * condition is active, and the type of the condition.
+ *
+ * Function return values:
+ *
+ * DISK_ERROR_TYPE_NONE:    No problems, we can accept writes.
+ * DISK_ERROR_TYPE_AOF:     Don't accept writes: AOF errors.
+ * DISK_ERROR_TYPE_RDB:     Don't accept writes: RDB errors.
+ */
+int writeCommandsDeniedByDiskError(void) {
+    if (server.stop_writes_on_bgsave_err && server.saveparamslen > 0 && server.lastbgsave_status == C_ERR) {
+        return DISK_ERROR_TYPE_RDB;
+    } else if (server.aof_state != AOF_OFF) {
+        if (server.aof_last_write_status == C_ERR) {
+            return DISK_ERROR_TYPE_AOF;
+        }
+        /* AOF fsync error. */
+        int aof_bio_fsync_status = atomic_load_explicit(&server.aof_bio_fsync_status, memory_order_acquire);
+        if (aof_bio_fsync_status == C_ERR) {
+            server.aof_last_write_errno = atomic_load_explicit(&server.aof_bio_fsync_errno, memory_order_relaxed);
+            return DISK_ERROR_TYPE_AOF;
+        }
+    }
+
+    return DISK_ERROR_TYPE_NONE;
+}
+
+sds writeCommandsGetDiskErrorMessage(int error_code) {
+    sds ret = NULL;
+    if (error_code == DISK_ERROR_TYPE_RDB) {
+        ret = sdsdup(shared.bgsaveerr->ptr);
+    } else {
+        ret = sdscatfmt(sdsempty(), "-MISCONF Errors writing to the AOF file: %s\r\n",
+                        strerror(server.aof_last_write_errno));
+    }
+    return ret;
+}
+
+/* The PING command. It works in a different way if the client is in
+ * in Pub/Sub mode. */
+void pingCommand(client *c) {
+    /* The command takes zero or one arguments. */
+    if (c->argc > 2) {
+        addReplyErrorArity(c);
+        return;
+    }
+
+    if (c->flag.pubsub && c->resp == 2) {
+        addReply(c, shared.mbulkhdr[2]);
+        addReplyBulkCBuffer(c, "pong", 4);
+        if (c->argc == 1)
+            addReplyBulkCBuffer(c, "", 0);
+        else
+            addReplyBulk(c, c->argv[1]);
+    } else {
+        if (c->argc == 1)
+            addReply(c, shared.pong);
+        else
+            addReplyBulk(c, c->argv[1]);
+    }
+}
+
+void echoCommand(client *c) {
+    addReplyBulk(c, c->argv[1]);
+}
+
+void timeCommand(client *c) {
+    addReplyArrayLen(c, 2);
+    addReplyBulkLongLong(c, server.unixtime);
+    addReplyBulkLongLong(c, server.ustime - ((long long)server.unixtime) * 1000000);
+}
+
+typedef struct replyFlagNames {
+    uint64_t flag;
+    const char *name;
+} replyFlagNames;
+
+/* Helper function to output flags. */
+void addReplyCommandFlags(client *c, uint64_t flags, replyFlagNames *replyFlags) {
+    int count = 0, j = 0;
+    /* Count them so we don't have to use deferred reply. */
+    while (replyFlags[j].name) {
+        if (flags & replyFlags[j].flag) count++;
+        j++;
+    }
+
+    addReplySetLen(c, count);
+    j = 0;
+    while (replyFlags[j].name) {
+        if (flags & replyFlags[j].flag) addReplyStatus(c, replyFlags[j].name);
+        j++;
+    }
+}
+
+void addReplyFlagsForCommand(client *c, struct serverCommand *cmd) {
+    replyFlagNames flagNames[] = {{CMD_WRITE, "write"},
+                                  {CMD_READONLY, "readonly"},
+                                  {CMD_DENYOOM, "denyoom"},
+                                  {CMD_MODULE, "module"},
+                                  {CMD_ADMIN, "admin"},
+                                  {CMD_PUBSUB, "pubsub"},
+                                  {CMD_NOSCRIPT, "noscript"},
+                                  {CMD_BLOCKING, "blocking"},
+                                  {CMD_LOADING, "loading"},
+                                  {CMD_STALE, "stale"},
+                                  {CMD_SKIP_MONITOR, "skip_monitor"},
+                                  {CMD_SKIP_COMMANDLOG, "skip_commandlog"},
+                                  {CMD_ASKING, "asking"},
+                                  {CMD_FAST, "fast"},
+                                  {CMD_NO_AUTH, "no_auth"},
+                                  /* {CMD_MAY_REPLICATE,     "may_replicate"},, Hidden on purpose */
+                                  /* {CMD_SENTINEL,          "sentinel"}, Hidden on purpose */
+                                  /* {CMD_ONLY_SENTINEL,     "only_sentinel"}, Hidden on purpose */
+                                  {CMD_NO_MANDATORY_KEYS, "no_mandatory_keys"},
+                                  /* {CMD_PROTECTED,         "protected"}, Hidden on purpose */
+                                  {CMD_NO_ASYNC_LOADING, "no_async_loading"},
+                                  {CMD_NO_MULTI, "no_multi"},
+                                  {CMD_MOVABLE_KEYS, "movablekeys"},
+                                  {CMD_ALLOW_BUSY, "allow_busy"},
+                                  /* {CMD_TOUCHES_ARBITRARY_KEYS,  "TOUCHES_ARBITRARY_KEYS"}, Hidden on purpose */
+                                  {0, NULL}};
+    addReplyCommandFlags(c, cmd->flags, flagNames);
+}
+
+void addReplyDocFlagsForCommand(client *c, struct serverCommand *cmd) {
+    replyFlagNames docFlagNames[] = {{CMD_DOC_DEPRECATED, "deprecated"}, {CMD_DOC_SYSCMD, "syscmd"}, {0, NULL}};
+    addReplyCommandFlags(c, cmd->doc_flags, docFlagNames);
+}
+
+void addReplyFlagsForKeyArgs(client *c, uint64_t flags) {
+    replyFlagNames docFlagNames[] = {{CMD_KEY_RO, "RO"},
+                                     {CMD_KEY_RW, "RW"},
+                                     {CMD_KEY_OW, "OW"},
+                                     {CMD_KEY_RM, "RM"},
+                                     {CMD_KEY_ACCESS, "access"},
+                                     {CMD_KEY_UPDATE, "update"},
+                                     {CMD_KEY_INSERT, "insert"},
+                                     {CMD_KEY_DELETE, "delete"},
+                                     {CMD_KEY_NOT_KEY, "not_key"},
+                                     {CMD_KEY_INCOMPLETE, "incomplete"},
+                                     {CMD_KEY_VARIABLE_FLAGS, "variable_flags"},
+                                     {0, NULL}};
+    addReplyCommandFlags(c, flags, docFlagNames);
+}
+
+/* Must match serverCommandArgType */
+const char *ARG_TYPE_STR[] = {
+    "string",
+    "integer",
+    "double",
+    "key",
+    "pattern",
+    "unix-time",
+    "pure-token",
+    "oneof",
+    "block",
+};
+
+void addReplyFlagsForArg(client *c, uint64_t flags) {
+    replyFlagNames argFlagNames[] = {{CMD_ARG_OPTIONAL, "optional"},
+                                     {CMD_ARG_MULTIPLE, "multiple"},
+                                     {CMD_ARG_MULTIPLE_TOKEN, "multiple_token"},
+                                     {0, NULL}};
+    addReplyCommandFlags(c, flags, argFlagNames);
+}
+
+void addReplyCommandArgList(client *c, struct serverCommandArg *args, int num_args) {
+    addReplyArrayLen(c, num_args);
+    for (int j = 0; j < num_args; j++) {
+        /* Count our reply len so we don't have to use deferred reply. */
+        int has_display_text = 1;
+        long maplen = 2;
+        if (args[j].key_spec_index != -1) maplen++;
+        if (args[j].token) maplen++;
+        if (args[j].summary) maplen++;
+        if (args[j].since) maplen++;
+        if (args[j].deprecated_since) maplen++;
+        if (args[j].flags) maplen++;
+        if (args[j].type == ARG_TYPE_ONEOF || args[j].type == ARG_TYPE_BLOCK) {
+            has_display_text = 0;
+            maplen++;
+        }
+        if (has_display_text) maplen++;
+        addReplyMapLen(c, maplen);
+
+        addReplyBulkCString(c, "name");
+        addReplyBulkCString(c, args[j].name);
+
+        addReplyBulkCString(c, "type");
+        addReplyBulkCString(c, ARG_TYPE_STR[args[j].type]);
+
+        if (has_display_text) {
+            addReplyBulkCString(c, "display_text");
+            addReplyBulkCString(c, args[j].display_text ? args[j].display_text : args[j].name);
+        }
+        if (args[j].key_spec_index != -1) {
+            addReplyBulkCString(c, "key_spec_index");
+            addReplyLongLong(c, args[j].key_spec_index);
+        }
+        if (args[j].token) {
+            addReplyBulkCString(c, "token");
+            addReplyBulkCString(c, args[j].token);
+        }
+        if (args[j].summary) {
+            addReplyBulkCString(c, "summary");
+            addReplyBulkCString(c, args[j].summary);
+        }
+        if (args[j].since) {
+            addReplyBulkCString(c, "since");
+            addReplyBulkCString(c, args[j].since);
+        }
+        if (args[j].deprecated_since) {
+            addReplyBulkCString(c, "deprecated_since");
+            addReplyBulkCString(c, args[j].deprecated_since);
+        }
+        if (args[j].flags) {
+            addReplyBulkCString(c, "flags");
+            addReplyFlagsForArg(c, args[j].flags);
+        }
+        if (args[j].type == ARG_TYPE_ONEOF || args[j].type == ARG_TYPE_BLOCK) {
+            addReplyBulkCString(c, "arguments");
+            addReplyCommandArgList(c, args[j].subargs, args[j].num_args);
+        }
+    }
+}
+
+#ifdef LOG_REQ_RES
+
+void addReplyJson(client *c, struct jsonObject *rs) {
+    addReplyMapLen(c, rs->length);
+
+    for (int i = 0; i < rs->length; i++) {
+        struct jsonObjectElement *curr = &rs->elements[i];
+        addReplyBulkCString(c, curr->key);
+        switch (curr->type) {
+        case (JSON_TYPE_BOOLEAN): addReplyBool(c, curr->value.boolean); break;
+        case (JSON_TYPE_INTEGER): addReplyLongLong(c, curr->value.integer); break;
+        case (JSON_TYPE_STRING): addReplyBulkCString(c, curr->value.string); break;
+        case (JSON_TYPE_OBJECT): addReplyJson(c, curr->value.object); break;
+        case (JSON_TYPE_ARRAY):
+            addReplyArrayLen(c, curr->value.array.length);
+            for (int k = 0; k < curr->value.array.length; k++) {
+                struct jsonObject *object = curr->value.array.objects[k];
+                addReplyJson(c, object);
+            }
+            break;
+        default: serverPanic("Invalid JSON type %d", curr->type);
+        }
+    }
+}
+
+#endif
+
+void addReplyCommandHistory(client *c, struct serverCommand *cmd) {
+    addReplySetLen(c, cmd->num_history);
+    for (int j = 0; j < cmd->num_history; j++) {
+        addReplyArrayLen(c, 2);
+        addReplyBulkCString(c, cmd->history[j].since);
+        addReplyBulkCString(c, cmd->history[j].changes);
+    }
+}
+
+void addReplyCommandTips(client *c, struct serverCommand *cmd) {
+    addReplySetLen(c, cmd->num_tips);
+    for (int j = 0; j < cmd->num_tips; j++) {
+        addReplyBulkCString(c, cmd->tips[j]);
+    }
+}
+
+void addReplyCommandKeySpecs(client *c, struct serverCommand *cmd) {
+    addReplySetLen(c, cmd->key_specs_num);
+    for (int i = 0; i < cmd->key_specs_num; i++) {
+        int maplen = 3;
+        if (cmd->key_specs[i].notes) maplen++;
+
+        addReplyMapLen(c, maplen);
+
+        if (cmd->key_specs[i].notes) {
+            addReplyBulkCString(c, "notes");
+            addReplyBulkCString(c, cmd->key_specs[i].notes);
+        }
+
+        addReplyBulkCString(c, "flags");
+        addReplyFlagsForKeyArgs(c, cmd->key_specs[i].flags);
+
+        addReplyBulkCString(c, "begin_search");
+        switch (cmd->key_specs[i].begin_search_type) {
+        case KSPEC_BS_UNKNOWN:
+            addReplyMapLen(c, 2);
+            addReplyBulkCString(c, "type");
+            addReplyBulkCString(c, "unknown");
+
+            addReplyBulkCString(c, "spec");
+            addReplyMapLen(c, 0);
+            break;
+        case KSPEC_BS_INDEX:
+            addReplyMapLen(c, 2);
+            addReplyBulkCString(c, "type");
+            addReplyBulkCString(c, "index");
+
+            addReplyBulkCString(c, "spec");
+            addReplyMapLen(c, 1);
+            addReplyBulkCString(c, "index");
+            addReplyLongLong(c, cmd->key_specs[i].bs.index.pos);
+            break;
+        case KSPEC_BS_KEYWORD:
+            addReplyMapLen(c, 2);
+            addReplyBulkCString(c, "type");
+            addReplyBulkCString(c, "keyword");
+
+            addReplyBulkCString(c, "spec");
+            addReplyMapLen(c, 2);
+            addReplyBulkCString(c, "keyword");
+            addReplyBulkCString(c, cmd->key_specs[i].bs.keyword.keyword);
+            addReplyBulkCString(c, "startfrom");
+            addReplyLongLong(c, cmd->key_specs[i].bs.keyword.startfrom);
+            break;
+        default: serverPanic("Invalid begin_search key spec type %d", cmd->key_specs[i].begin_search_type);
+        }
+
+        addReplyBulkCString(c, "find_keys");
+        switch (cmd->key_specs[i].find_keys_type) {
+        case KSPEC_FK_UNKNOWN:
+            addReplyMapLen(c, 2);
+            addReplyBulkCString(c, "type");
+            addReplyBulkCString(c, "unknown");
+
+            addReplyBulkCString(c, "spec");
+            addReplyMapLen(c, 0);
+            break;
+        case KSPEC_FK_RANGE:
+            addReplyMapLen(c, 2);
+            addReplyBulkCString(c, "type");
+            addReplyBulkCString(c, "range");
+
+            addReplyBulkCString(c, "spec");
+            addReplyMapLen(c, 3);
+            addReplyBulkCString(c, "lastkey");
+            addReplyLongLong(c, cmd->key_specs[i].fk.range.lastkey);
+            addReplyBulkCString(c, "keystep");
+            addReplyLongLong(c, cmd->key_specs[i].fk.range.keystep);
+            addReplyBulkCString(c, "limit");
+            addReplyLongLong(c, cmd->key_specs[i].fk.range.limit);
+            break;
+        case KSPEC_FK_KEYNUM:
+            addReplyMapLen(c, 2);
+            addReplyBulkCString(c, "type");
+            addReplyBulkCString(c, "keynum");
+
+            addReplyBulkCString(c, "spec");
+            addReplyMapLen(c, 3);
+            addReplyBulkCString(c, "keynumidx");
+            addReplyLongLong(c, cmd->key_specs[i].fk.keynum.keynumidx);
+            addReplyBulkCString(c, "firstkey");
+            addReplyLongLong(c, cmd->key_specs[i].fk.keynum.firstkey);
+            addReplyBulkCString(c, "keystep");
+            addReplyLongLong(c, cmd->key_specs[i].fk.keynum.keystep);
+            break;
+        default: serverPanic("Invalid find_keys key spec type %d", cmd->key_specs[i].begin_search_type);
+        }
+    }
+}
+
+/* Reply with an array of sub-command using the provided reply callback. */
+void addReplyCommandSubCommands(client *c,
+                                struct serverCommand *cmd,
+                                void (*reply_function)(client *, struct serverCommand *),
+                                int use_map) {
+    if (!cmd->subcommands_ht) {
+        addReplySetLen(c, 0);
+        return;
+    }
+
+    if (use_map)
+        addReplyMapLen(c, hashtableSize(cmd->subcommands_ht));
+    else
+        addReplyArrayLen(c, hashtableSize(cmd->subcommands_ht));
+
+    void *next;
+    hashtableIterator iter;
+    hashtableInitIterator(&iter, cmd->subcommands_ht, HASHTABLE_ITER_SAFE);
+    while (hashtableNext(&iter, &next)) {
+        struct serverCommand *sub = next;
+        if (use_map) addReplyBulkCBuffer(c, sub->fullname, sdslen(sub->fullname));
+        reply_function(c, sub);
+    }
+    hashtableResetIterator(&iter);
+}
+
+/* Output the representation of a server command. Used by the COMMAND command and COMMAND INFO. */
+void addReplyCommandInfo(client *c, struct serverCommand *cmd) {
+    if (!cmd) {
+        addReplyNull(c);
+    } else {
+        int firstkey = 0, lastkey = 0, keystep = 0;
+        if (cmd->legacy_range_key_spec.begin_search_type != KSPEC_BS_INVALID) {
+            firstkey = cmd->legacy_range_key_spec.bs.index.pos;
+            lastkey = cmd->legacy_range_key_spec.fk.range.lastkey;
+            if (lastkey >= 0) lastkey += firstkey;
+            keystep = cmd->legacy_range_key_spec.fk.range.keystep;
+        }
+
+        addReplyArrayLen(c, 10);
+        addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
+        addReplyLongLong(c, cmd->arity);
+        addReplyFlagsForCommand(c, cmd);
+        addReplyLongLong(c, firstkey);
+        addReplyLongLong(c, lastkey);
+        addReplyLongLong(c, keystep);
+        addReplyCommandCategories(c, cmd);
+        addReplyCommandTips(c, cmd);
+        addReplyCommandKeySpecs(c, cmd);
+        addReplyCommandSubCommands(c, cmd, addReplyCommandInfo, 0);
+    }
+}
+
+/* Output the representation of a server command. Used by the COMMAND DOCS. */
+void addReplyCommandDocs(client *c, struct serverCommand *cmd) {
+    /* Count our reply len so we don't have to use deferred reply. */
+    long maplen = 1;
+    if (cmd->summary) maplen++;
+    if (cmd->since) maplen++;
+    if (cmd->flags & CMD_MODULE) maplen++;
+    if (cmd->complexity) maplen++;
+    if (cmd->doc_flags) maplen++;
+    if (cmd->deprecated_since) maplen++;
+    if (cmd->replaced_by) maplen++;
+    if (cmd->history) maplen++;
+#ifdef LOG_REQ_RES
+    if (cmd->reply_schema) maplen++;
+#endif
+    if (cmd->args) maplen++;
+    if (cmd->subcommands_ht) maplen++;
+    addReplyMapLen(c, maplen);
+
+    if (cmd->summary) {
+        addReplyBulkCString(c, "summary");
+        addReplyBulkCString(c, cmd->summary);
+    }
+    if (cmd->since) {
+        addReplyBulkCString(c, "since");
+        addReplyBulkCString(c, cmd->since);
+    }
+
+    /* Always have the group, for module commands the group is always "module". */
+    addReplyBulkCString(c, "group");
+    addReplyBulkCString(c, commandGroupStr(cmd->group));
+
+    if (cmd->complexity) {
+        addReplyBulkCString(c, "complexity");
+        addReplyBulkCString(c, cmd->complexity);
+    }
+    if (cmd->flags & CMD_MODULE) {
+        addReplyBulkCString(c, "module");
+        addReplyBulkCString(c, moduleNameFromCommand(cmd));
+    }
+    if (cmd->doc_flags) {
+        addReplyBulkCString(c, "doc_flags");
+        addReplyDocFlagsForCommand(c, cmd);
+    }
+    if (cmd->deprecated_since) {
+        addReplyBulkCString(c, "deprecated_since");
+        addReplyBulkCString(c, cmd->deprecated_since);
+    }
+    if (cmd->replaced_by) {
+        addReplyBulkCString(c, "replaced_by");
+        addReplyBulkCString(c, cmd->replaced_by);
+    }
+    if (cmd->history) {
+        addReplyBulkCString(c, "history");
+        addReplyCommandHistory(c, cmd);
+    }
+#ifdef LOG_REQ_RES
+    if (cmd->reply_schema) {
+        addReplyBulkCString(c, "reply_schema");
+        addReplyJson(c, cmd->reply_schema);
+    }
+#endif
+    if (cmd->args) {
+        addReplyBulkCString(c, "arguments");
+        addReplyCommandArgList(c, cmd->args, cmd->num_args);
+    }
+    if (cmd->subcommands_ht) {
+        addReplyBulkCString(c, "subcommands");
+        addReplyCommandSubCommands(c, cmd, addReplyCommandDocs, 1);
+    }
+}
+
+/* Helper for COMMAND GETKEYS and GETKEYSANDFLAGS */
+void getKeysSubcommandImpl(client *c, int with_flags) {
+    struct serverCommand *cmd = lookupCommand(c->argv + 2, c->argc - 2);
+    getKeysResult result;
+    initGetKeysResult(&result);
+    int j;
+
+    if (!cmd) {
+        addReplyError(c, "Invalid command specified");
+        return;
+    } else if (!doesCommandHaveKeys(cmd)) {
+        addReplyError(c, "The command has no key arguments");
+        return;
+    } else if ((cmd->arity > 0 && cmd->arity != c->argc - 2) || ((c->argc - 2) < -cmd->arity)) {
+        addReplyError(c, "Invalid number of arguments specified for command");
+        return;
+    }
+
+    if (!getKeysFromCommandWithSpecs(cmd, c->argv + 2, c->argc - 2, GET_KEYSPEC_DEFAULT, &result)) {
+        if (cmd->flags & CMD_NO_MANDATORY_KEYS) {
+            addReplyArrayLen(c, 0);
+        } else {
+            addReplyError(c, "Invalid arguments specified for command");
+        }
+    } else {
+        addReplyArrayLen(c, result.numkeys);
+        for (j = 0; j < result.numkeys; j++) {
+            if (!with_flags) {
+                addReplyBulk(c, c->argv[result.keys[j].pos + 2]);
+            } else {
+                addReplyArrayLen(c, 2);
+                addReplyBulk(c, c->argv[result.keys[j].pos + 2]);
+                addReplyFlagsForKeyArgs(c, result.keys[j].flags);
+            }
+        }
+    }
+    getKeysFreeResult(&result);
+}
+
+/* COMMAND GETKEYSANDFLAGS cmd arg1 arg2 ... */
+void commandGetKeysAndFlagsCommand(client *c) {
+    getKeysSubcommandImpl(c, 1);
+}
+
+/* COMMAND GETKEYS cmd arg1 arg2 ... */
+void getKeysSubcommand(client *c) {
+    getKeysSubcommandImpl(c, 0);
+}
+
+/* COMMAND (no args) */
+void commandCommand(client *c) {
+    hashtableIterator iter;
+    void *next;
+    addReplyArrayLen(c, hashtableSize(server.commands));
+    hashtableInitIterator(&iter, server.commands, 0);
+    while (hashtableNext(&iter, &next)) {
+        struct serverCommand *cmd = next;
+        addReplyCommandInfo(c, cmd);
+    }
+    hashtableResetIterator(&iter);
+}
+
+/* COMMAND COUNT */
+void commandCountCommand(client *c) {
+    addReplyLongLong(c, hashtableSize(server.commands));
+}
+
+typedef enum {
+    COMMAND_LIST_FILTER_MODULE,
+    COMMAND_LIST_FILTER_ACLCAT,
+    COMMAND_LIST_FILTER_PATTERN,
+} commandListFilterType;
+
+typedef struct {
+    commandListFilterType type;
+    sds arg;
+    struct {
+        int valid;
+        union {
+            uint64_t aclcat;
+            void *module_handle;
+        } u;
+    } cache;
+} commandListFilter;
+
+int shouldFilterFromCommandList(struct serverCommand *cmd, commandListFilter *filter) {
+    switch (filter->type) {
+    case (COMMAND_LIST_FILTER_MODULE):
+        if (!filter->cache.valid) {
+            filter->cache.u.module_handle = moduleGetHandleByName(filter->arg);
+            filter->cache.valid = 1;
+        }
+        return !moduleIsModuleCommand(filter->cache.u.module_handle, cmd);
+    case (COMMAND_LIST_FILTER_ACLCAT): {
+        if (!filter->cache.valid) {
+            filter->cache.u.aclcat = ACLGetCommandCategoryFlagByName(filter->arg);
+            filter->cache.valid = 1;
+        }
+        uint64_t cat = filter->cache.u.aclcat;
+        if (cat == 0) return 1; /* Invalid ACL category */
+        return (!(cmd->acl_categories & cat));
+        break;
+    }
+    case (COMMAND_LIST_FILTER_PATTERN):
+        return !stringmatchlen(filter->arg, sdslen(filter->arg), cmd->fullname, sdslen(cmd->fullname), 1);
+    default: serverPanic("Invalid filter type %d", filter->type);
+    }
+}
+
+/* COMMAND LIST FILTERBY (MODULE <module-name>|ACLCAT <cat>|PATTERN <pattern>) */
+void commandListWithFilter(client *c, hashtable *commands, commandListFilter filter, int *numcmds) {
+    hashtableIterator iter;
+    void *next;
+    hashtableInitIterator(&iter, commands, 0);
+    while (hashtableNext(&iter, &next)) {
+        struct serverCommand *cmd = next;
+        if (!shouldFilterFromCommandList(cmd, &filter)) {
+            addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
+            (*numcmds)++;
+        }
+
+        if (cmd->subcommands_ht) {
+            commandListWithFilter(c, cmd->subcommands_ht, filter, numcmds);
+        }
+    }
+    hashtableResetIterator(&iter);
+}
+
+/* COMMAND LIST */
+void commandListWithoutFilter(client *c, hashtable *commands, int *numcmds) {
+    hashtableIterator iter;
+    void *next;
+    hashtableInitIterator(&iter, commands, 0);
+    while (hashtableNext(&iter, &next)) {
+        struct serverCommand *cmd = next;
+        addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
+        (*numcmds)++;
+
+        if (cmd->subcommands_ht) {
+            commandListWithoutFilter(c, cmd->subcommands_ht, numcmds);
+        }
+    }
+    hashtableResetIterator(&iter);
+}
+
+/* COMMAND LIST [FILTERBY (MODULE <module-name>|ACLCAT <cat>|PATTERN <pattern>)] */
+void commandListCommand(client *c) {
+    /* Parse options. */
+    int i = 2, got_filter = 0;
+    commandListFilter filter = {0};
+    for (; i < c->argc; i++) {
+        int moreargs = (c->argc - 1) - i; /* Number of additional arguments. */
+        char *opt = c->argv[i]->ptr;
+        if (!strcasecmp(opt, "filterby") && moreargs == 2) {
+            char *filtertype = c->argv[i + 1]->ptr;
+            if (!strcasecmp(filtertype, "module")) {
+                filter.type = COMMAND_LIST_FILTER_MODULE;
+            } else if (!strcasecmp(filtertype, "aclcat")) {
+                filter.type = COMMAND_LIST_FILTER_ACLCAT;
+            } else if (!strcasecmp(filtertype, "pattern")) {
+                filter.type = COMMAND_LIST_FILTER_PATTERN;
+            } else {
+                addReplyErrorObject(c, shared.syntaxerr);
+                return;
+            }
+            got_filter = 1;
+            filter.arg = c->argv[i + 2]->ptr;
+            i += 2;
+        } else {
+            addReplyErrorObject(c, shared.syntaxerr);
+            return;
+        }
+    }
+
+    int numcmds = 0;
+    void *replylen = addReplyDeferredLen(c);
+
+    if (got_filter) {
+        commandListWithFilter(c, server.commands, filter, &numcmds);
+    } else {
+        commandListWithoutFilter(c, server.commands, &numcmds);
+    }
+
+    setDeferredArrayLen(c, replylen, numcmds);
+}
+
+/* COMMAND INFO [<command-name> ...] */
+void commandInfoCommand(client *c) {
+    int i;
+
+    if (c->argc == 2) {
+        hashtableIterator iter;
+        void *next;
+        addReplyArrayLen(c, hashtableSize(server.commands));
+        hashtableInitIterator(&iter, server.commands, 0);
+        while (hashtableNext(&iter, &next)) {
+            struct serverCommand *cmd = next;
+            addReplyCommandInfo(c, cmd);
+        }
+        hashtableResetIterator(&iter);
+    } else {
+        addReplyArrayLen(c, c->argc - 2);
+        for (i = 2; i < c->argc; i++) {
+            addReplyCommandInfo(c, lookupCommandBySds(c->argv[i]->ptr));
+        }
+    }
+}
+
+/* COMMAND DOCS [command-name [command-name ...]] */
+void commandDocsCommand(client *c) {
+    int i;
+    if (c->argc == 2) {
+        /* Reply with an array of all commands */
+        hashtableIterator iter;
+        void *next;
+        addReplyMapLen(c, hashtableSize(server.commands));
+        hashtableInitIterator(&iter, server.commands, 0);
+        while (hashtableNext(&iter, &next)) {
+            struct serverCommand *cmd = next;
+            addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
+            addReplyCommandDocs(c, cmd);
+        }
+        hashtableResetIterator(&iter);
+    } else {
+        /* Reply with an array of the requested commands (if we find them) */
+        int numcmds = 0;
+        void *replylen = addReplyDeferredLen(c);
+        for (i = 2; i < c->argc; i++) {
+            struct serverCommand *cmd = lookupCommandBySds(c->argv[i]->ptr);
+            if (!cmd) continue;
+            addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));
+            addReplyCommandDocs(c, cmd);
+            numcmds++;
+        }
+        setDeferredMapLen(c, replylen, numcmds);
+    }
+}
+
+/* COMMAND GETKEYS arg0 arg1 arg2 ... */
+void commandGetKeysCommand(client *c) {
+    getKeysSubcommand(c);
+}
+
+/* COMMAND HELP */
+void commandHelpCommand(client *c) {
+    const char *help[] = {
+        "(no subcommand)",
+        "    Return details about all commands.",
+        "COUNT",
+        "    Return the total number of commands in this server.",
+        "LIST",
+        "    Return a list of all commands in this server.",
+        "INFO [<command-name> ...]",
+        "    Return details about multiple commands.",
+        "    If no command names are given, documentation details for all",
+        "    commands are returned.",
+        "DOCS [<command-name> ...]",
+        "    Return documentation details about multiple commands.",
+        "    If no command names are given, documentation details for all",
+        "    commands are returned.",
+        "GETKEYS <full-command>",
+        "    Return the keys from a full command.",
+        "GETKEYSANDFLAGS <full-command>",
+        "    Return the keys and the access flags from a full command.",
+        NULL,
+    };
+    addReplyHelp(c, help);
+}
+
+/* Convert an amount of bytes into a human readable string in the form
+ * of 100B, 2G, 100M, 4K, and so forth. */
+void bytesToHuman(char *s, size_t size, unsigned long long n) {
+    double d;
+
+    if (n < 1024) {
+        /* Bytes */
+        snprintf(s, size, "%lluB", n);
+    } else if (n < (1024 * 1024)) {
+        d = (double)n / (1024);
+        snprintf(s, size, "%.2fK", d);
+    } else if (n < (1024LL * 1024 * 1024)) {
+        d = (double)n / (1024 * 1024);
+        snprintf(s, size, "%.2fM", d);
+    } else if (n < (1024LL * 1024 * 1024 * 1024)) {
+        d = (double)n / (1024LL * 1024 * 1024);
+        snprintf(s, size, "%.2fG", d);
+    } else if (n < (1024LL * 1024 * 1024 * 1024 * 1024)) {
+        d = (double)n / (1024LL * 1024 * 1024 * 1024);
+        snprintf(s, size, "%.2fT", d);
+    } else if (n < (1024LL * 1024 * 1024 * 1024 * 1024 * 1024)) {
+        d = (double)n / (1024LL * 1024 * 1024 * 1024 * 1024);
+        snprintf(s, size, "%.2fP", d);
+    } else {
+        /* Let's hope we never need this */
+        snprintf(s, size, "%lluB", n);
+    }
+}
+
+/* Fill percentile distribution of latencies. */
+sds fillPercentileDistributionLatencies(sds info, const char *histogram_name, struct hdr_histogram *histogram) {
+    info = sdscatfmt(info, "latency_percentiles_usec_%s:", histogram_name);
+    for (int j = 0; j < server.latency_tracking_info_percentiles_len; j++) {
+        char fbuf[128];
+        size_t len = snprintf(fbuf, sizeof(fbuf), "%f", server.latency_tracking_info_percentiles[j]);
+        trimDoubleString(fbuf, len);
+        info = sdscatprintf(info, "p%s=%.3f", fbuf,
+                            ((double)hdr_value_at_percentile(histogram, server.latency_tracking_info_percentiles[j])) /
+                                1000.0f);
+        if (j != server.latency_tracking_info_percentiles_len - 1) info = sdscatlen(info, ",", 1);
+    }
+    info = sdscatprintf(info, "\r\n");
+    return info;
+}
+
+const char *replstateToString(int replstate) {
+    switch (replstate) {
+    case REPLICA_STATE_WAIT_BGSAVE_START:
+    case REPLICA_STATE_WAIT_BGSAVE_END: return "wait_bgsave";
+    case REPLICA_STATE_BG_RDB_LOAD: return "bg_transfer";
+    case REPLICA_STATE_SEND_BULK: return "send_bulk";
+    case REPLICA_STATE_ONLINE: return "online";
+    default: return "";
+    }
+}
+
+/* Characters we sanitize on INFO output to maintain expected format. */
+static char unsafe_info_chars[] = "#:\n\r";
+static char unsafe_info_chars_substs[] = "____"; /* Must be same length as above */
+
+/* Returns a sanitized version of s that contains no unsafe info string chars.
+ * If no unsafe characters are found, simply returns s. Caller needs to
+ * free tmp if it is non-null on return.
+ */
+const char *getSafeInfoString(const char *s, size_t len, char **tmp) {
+    *tmp = NULL;
+    if (mempbrk(s, len, unsafe_info_chars, sizeof(unsafe_info_chars) - 1) == NULL) return s;
+    char *new = *tmp = zmalloc(len + 1);
+    memcpy(new, s, len);
+    new[len] = '\0';
+    return memmapchars(new, len, unsafe_info_chars, unsafe_info_chars_substs, sizeof(unsafe_info_chars) - 1);
+}
+
+sds genValkeyInfoStringCommandStats(sds info, hashtable *commands) {
+    hashtableIterator iter;
+    void *next;
+    hashtableInitIterator(&iter, commands, HASHTABLE_ITER_SAFE);
+    while (hashtableNext(&iter, &next)) {
+        struct serverCommand *c = next;
+        char *tmpsafe;
+        if (c->calls || c->failed_calls || c->rejected_calls) {
+            info = sdscatprintf(info,
+                                "cmdstat_%s:calls=%lld,usec=%lld,usec_per_call=%.2f"
+                                ",rejected_calls=%lld,failed_calls=%lld\r\n",
+                                getSafeInfoString(c->fullname, sdslen(c->fullname), &tmpsafe), c->calls,
+                                c->microseconds, (c->calls == 0) ? 0 : ((float)c->microseconds / c->calls),
+                                c->rejected_calls, c->failed_calls);
+            if (tmpsafe != NULL) zfree(tmpsafe);
+        }
+        if (c->subcommands_ht) {
+            info = genValkeyInfoStringCommandStats(info, c->subcommands_ht);
+        }
+    }
+    hashtableResetIterator(&iter);
+
+    return info;
+}
+
+/* Writes the ACL metrics to the info */
+sds genValkeyInfoStringACLStats(sds info) {
+    info = sdscatprintf(info,
+                        "acl_access_denied_auth:%lld\r\n"
+                        "acl_access_denied_cmd:%lld\r\n"
+                        "acl_access_denied_key:%lld\r\n"
+                        "acl_access_denied_channel:%lld\r\n",
+                        server.acl_info.user_auth_failures, server.acl_info.invalid_cmd_accesses,
+                        server.acl_info.invalid_key_accesses, server.acl_info.invalid_channel_accesses);
+    return info;
+}
+
+sds genValkeyInfoStringLatencyStats(sds info, hashtable *commands) {
+    hashtableIterator iter;
+    void *next;
+    hashtableInitIterator(&iter, commands, HASHTABLE_ITER_SAFE);
+    while (hashtableNext(&iter, &next)) {
+        struct serverCommand *c = next;
+        char *tmpsafe;
+        if (c->latency_histogram) {
+            info = fillPercentileDistributionLatencies(
+                info, getSafeInfoString(c->fullname, sdslen(c->fullname), &tmpsafe), c->latency_histogram);
+            if (tmpsafe != NULL) zfree(tmpsafe);
+        }
+        if (c->subcommands_ht) {
+            info = genValkeyInfoStringLatencyStats(info, c->subcommands_ht);
+        }
+    }
+    hashtableResetIterator(&iter);
+
+    return info;
+}
+
+/* Takes a null terminated sections list, and adds them to the dict. */
+void addInfoSectionsToDict(dict *section_dict, char **sections) {
+    while (*sections) {
+        sds section = sdsnew(*sections);
+        if (dictAdd(section_dict, section, NULL) == DICT_ERR) sdsfree(section);
+        sections++;
+    }
+}
+
+/* Cached copy of the default sections, as an optimization. */
+static dict *cached_default_info_sections = NULL;
+
+void releaseInfoSectionDict(dict *sec) {
+    if (sec != cached_default_info_sections) dictRelease(sec);
+}
+
+/* Create a dictionary with unique section names to be used by genValkeyInfoString.
+ * 'argv' and 'argc' are list of arguments for INFO.
+ * 'defaults' is an optional null terminated list of default sections.
+ * 'out_all' and 'out_everything' are optional.
+ * The resulting dictionary should be released with releaseInfoSectionDict. */
+dict *genInfoSectionDict(robj **argv, int argc, char **defaults, int *out_all, int *out_everything) {
+    char *default_sections[] = {
+        "server",
+        "clients",
+        "memory",
+        "persistence",
+        "stats",
+        "replication",
+        "cpu",
+        "module_list",
+        "errorstats",
+        "cluster",
+        "keyspace",
+        NULL,
+    };
+    if (!defaults) defaults = default_sections;
+
+    if (argc == 0) {
+        /* In this case we know the dict is not gonna be modified, so we cache
+         * it as an optimization for a common case. */
+        if (cached_default_info_sections) return cached_default_info_sections;
+        cached_default_info_sections = dictCreate(&stringSetDictType);
+        dictExpand(cached_default_info_sections, 16);
+        addInfoSectionsToDict(cached_default_info_sections, defaults);
+        return cached_default_info_sections;
+    }
+
+    dict *section_dict = dictCreate(&stringSetDictType);
+    dictExpand(section_dict, min(argc, 16));
+    for (int i = 0; i < argc; i++) {
+        if (!strcasecmp(argv[i]->ptr, "default")) {
+            addInfoSectionsToDict(section_dict, defaults);
+        } else if (!strcasecmp(argv[i]->ptr, "all")) {
+            if (out_all) *out_all = 1;
+        } else if (!strcasecmp(argv[i]->ptr, "everything")) {
+            if (out_everything) *out_everything = 1;
+            if (out_all) *out_all = 1;
+        } else {
+            sds section = sdsnew(argv[i]->ptr);
+            if (dictAdd(section_dict, section, NULL) != DICT_OK) sdsfree(section);
+        }
+    }
+    return section_dict;
+}
+
+/* sets blocking_keys to the total number of keys which has at least one client blocked on them.
+ * sets blocking_keys_on_nokey to the total number of keys which has at least one client
+ * blocked on them to be written or deleted.
+ * sets watched_keys to the total number of keys which has at least on client watching on them. */
+void totalNumberOfStatefulKeys(unsigned long *blocking_keys,
+                               unsigned long *blocking_keys_on_nokey,
+                               unsigned long *watched_keys) {
+    unsigned long bkeys = 0, bkeys_on_nokey = 0, wkeys = 0;
+    for (int j = 0; j < server.dbnum; j++) {
+        bkeys += dictSize(server.db[j].blocking_keys);
+        bkeys_on_nokey += dictSize(server.db[j].blocking_keys_unblock_on_nokey);
+        wkeys += dictSize(server.db[j].watched_keys);
+    }
+    if (blocking_keys) *blocking_keys = bkeys;
+    if (blocking_keys_on_nokey) *blocking_keys_on_nokey = bkeys_on_nokey;
+    if (watched_keys) *watched_keys = wkeys;
+}
+
+/* Create the string returned by the INFO command. This is decoupled
+ * by the INFO command itself as we need to report the same information
+ * on memory corruption problems. */
+sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
+    sds info = sdsempty();
+    time_t uptime = server.unixtime - server.stat_starttime;
+    int j;
+    int sections = 0;
+    if (everything) all_sections = 1;
+
+    /* Server */
+    if (all_sections || (dictFind(section_dict, "server") != NULL)) {
+        static int call_uname = 1;
+        static struct utsname name;
+        char *mode;
+        char *supervised;
+
+        if (server.cluster_enabled)
+            mode = "cluster";
+        else if (server.sentinel_mode)
+            mode = "sentinel";
+        else
+            mode = "standalone";
+
+        if (server.supervised) {
+            if (server.supervised_mode == SUPERVISED_UPSTART)
+                supervised = "upstart";
+            else if (server.supervised_mode == SUPERVISED_SYSTEMD)
+                supervised = "systemd";
+            else
+                supervised = "unknown";
+        } else {
+            supervised = "no";
+        }
+
+        if (sections++) info = sdscat(info, "\r\n");
+
+        if (call_uname) {
+            /* Uname can be slow and is always the same output. Cache it. */
+            uname(&name);
+            call_uname = 0;
+        }
+
+        info = sdscatfmt(
+            info,
+            "# Server\r\n" FMTARGS(
+                "redis_version:%s\r\n", REDIS_VERSION,
+                "server_name:%s\r\n", SERVER_NAME,
+                "futriix_version:%s\r\n", VALKEY_VERSION,
+                "redis_git_sha1:%s\r\n", serverGitSHA1(),
+                "redis_git_dirty:%i\r\n", strtol(serverGitDirty(), NULL, 10) > 0,
+                "redis_build_id:%s\r\n", serverBuildIdString(),
+                "%s_mode:", (server.extended_redis_compat ? "redis" : "server"),
+                "%s\r\n", mode,
+                "os:%s", name.sysname,
+                " %s", name.release,
+                " %s\r\n", name.machine,
+                "arch_bits:%i\r\n", server.arch_bits,
+                "monotonic_clock:%s\r\n", monotonicInfoString(),
+                "multiplexing_api:%s\r\n", aeGetApiName(),
+                "gcc_version:%s\r\n", GNUC_VERSION_STR,
+                "process_id:%I\r\n", (int64_t)getpid(),
+                "process_supervised:%s\r\n", supervised,
+                "run_id:%s\r\n", server.runid,
+                "tcp_port:%i\r\n", server.port ? server.port : server.tls_port,
+                "server_time_usec:%I\r\n", (int64_t)server.ustime,
+                "uptime_in_seconds:%I\r\n", (int64_t)uptime,
+                "uptime_in_days:%I\r\n", (int64_t)(uptime / (3600 * 24)),
+                "hz:%i\r\n", server.hz,
+                "configured_hz:%i\r\n", server.config_hz,
+                "lru_clock:%u\r\n", server.lruclock,
+                "executable:%s\r\n", server.executable ? server.executable : "",
+                "config_file:%s\r\n", server.configfile ? server.configfile : "",
+                "io_threads_active:%i\r\n", server.active_io_threads_num > 1,
+                "availability_zone:%s\r\n", server.availability_zone));
+
+        /* Conditional properties */
+        if (isShutdownInitiated()) {
+            info = sdscatfmt(info, "shutdown_in_milliseconds:%I\r\n",
+                             (int64_t)(server.shutdown_mstime - commandTimeSnapshot()));
+        }
+
+        /* get all the listeners information */
+        info = getListensInfoString(info);
+    }
+
+    /* Clients */
+    if (all_sections || (dictFind(section_dict, "clients") != NULL)) {
+        size_t maxin, maxout;
+        unsigned long blocking_keys, blocking_keys_on_nokey, watched_keys;
+        getExpansiveClientsInfo(&maxin, &maxout);
+        totalNumberOfStatefulKeys(&blocking_keys, &blocking_keys_on_nokey, &watched_keys);
+
+        char *paused_actions = "none";
+        long long paused_timeout = 0;
+        if (server.paused_actions & PAUSE_ACTION_CLIENT_ALL) {
+            paused_actions = "all";
+            paused_timeout = getPausedActionTimeout(PAUSE_ACTION_CLIENT_ALL);
+        } else if (server.paused_actions & PAUSE_ACTION_CLIENT_WRITE) {
+            paused_actions = "write";
+            paused_timeout = getPausedActionTimeout(PAUSE_ACTION_CLIENT_WRITE);
+        }
+
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(
+            info,
+            "# Clients\r\n" FMTARGS(
+                "connected_clients:%lu\r\n", listLength(server.clients) - listLength(server.replicas),
+                "cluster_connections:%lu\r\n", getClusterConnectionsCount(),
+                "maxclients:%u\r\n", server.maxclients,
+                "client_recent_max_input_buffer:%zu\r\n", maxin,
+                "client_recent_max_output_buffer:%zu\r\n", maxout,
+                "blocked_clients:%d\r\n", server.blocked_clients,
+                "tracking_clients:%d\r\n", server.tracking_clients,
+                "pubsub_clients:%d\r\n", server.pubsub_clients,
+                "watching_clients:%d\r\n", server.watching_clients,
+                "clients_in_timeout_table:%llu\r\n", (unsigned long long)raxSize(server.clients_timeout_table),
+                "total_watched_keys:%lu\r\n", watched_keys,
+                "total_blocking_keys:%lu\r\n", blocking_keys,
+                "total_blocking_keys_on_nokey:%lu\r\n", blocking_keys_on_nokey,
+                "paused_actions:%s\r\n", paused_actions,
+                "paused_timeout_milliseconds:%lld\r\n", paused_timeout));
+    }
+
+    /* Memory */
+    if (all_sections || (dictFind(section_dict, "memory") != NULL)) {
+        char hmem[64];
+        char peak_hmem[64];
+        char total_system_hmem[64];
+        char used_memory_lua_hmem[64];
+        char used_memory_vm_total_hmem[64];
+        char used_memory_scripts_hmem[64];
+        char used_memory_rss_hmem[64];
+        char maxmemory_hmem[64];
+        size_t zmalloc_used = zmalloc_used_memory();
+        size_t total_system_mem = server.system_memory_size;
+        const char *evict_policy = evictPolicyToString();
+        long long memory_lua = evalMemory();
+        long long memory_functions = functionsMemory();
+        struct serverMemOverhead *mh = getMemoryOverheadData();
+
+        /* Peak memory is updated from time to time by serverCron() so it
+         * may happen that the instantaneous value is slightly bigger than
+         * the peak value. This may confuse users, so we update the peak
+         * if found smaller than the current memory usage. */
+        if (zmalloc_used > server.stat_peak_memory) server.stat_peak_memory = zmalloc_used;
+
+        bytesToHuman(hmem, sizeof(hmem), zmalloc_used);
+        bytesToHuman(peak_hmem, sizeof(peak_hmem), server.stat_peak_memory);
+        bytesToHuman(total_system_hmem, sizeof(total_system_hmem), total_system_mem);
+        bytesToHuman(used_memory_lua_hmem, sizeof(used_memory_lua_hmem), memory_lua);
+        bytesToHuman(used_memory_vm_total_hmem, sizeof(used_memory_vm_total_hmem), memory_functions + memory_lua);
+        bytesToHuman(used_memory_scripts_hmem, sizeof(used_memory_scripts_hmem), mh->lua_caches + mh->functions_caches);
+        bytesToHuman(used_memory_rss_hmem, sizeof(used_memory_rss_hmem), server.cron_malloc_stats.process_rss);
+        bytesToHuman(maxmemory_hmem, sizeof(maxmemory_hmem), server.maxmemory);
+
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(
+            info,
+            "# Memory\r\n" FMTARGS(
+                "used_memory:%zu\r\n", zmalloc_used,
+                "used_memory_human:%s\r\n", hmem,
+                "used_memory_rss:%zu\r\n", server.cron_malloc_stats.process_rss,
+                "used_memory_rss_human:%s\r\n", used_memory_rss_hmem,
+                "used_memory_peak:%zu\r\n", server.stat_peak_memory,
+                "used_memory_peak_human:%s\r\n", peak_hmem,
+                "used_memory_peak_perc:%.2f%%\r\n", mh->peak_perc,
+                "used_memory_overhead:%zu\r\n", mh->overhead_total,
+                "used_memory_startup:%zu\r\n", mh->startup_allocated,
+                "used_memory_dataset:%zu\r\n", mh->dataset,
+                "used_memory_dataset_perc:%.2f%%\r\n", mh->dataset_perc,
+                "allocator_allocated:%zu\r\n", server.cron_malloc_stats.allocator_allocated,
+                "allocator_active:%zu\r\n", server.cron_malloc_stats.allocator_active,
+                "allocator_resident:%zu\r\n", server.cron_malloc_stats.allocator_resident,
+                "allocator_muzzy:%zu\r\n", server.cron_malloc_stats.allocator_muzzy,
+                "total_system_memory:%lu\r\n", (unsigned long)total_system_mem,
+                "total_system_memory_human:%s\r\n", total_system_hmem,
+                "used_memory_lua:%lld\r\n", memory_lua, /* deprecated, renamed to used_memory_vm_eval */
+                "used_memory_vm_eval:%lld\r\n", memory_lua,
+                "used_memory_lua_human:%s\r\n", used_memory_lua_hmem, /* deprecated */
+                "used_memory_scripts_eval:%lld\r\n", (long long)mh->lua_caches,
+                "number_of_cached_scripts:%lu\r\n", dictSize(evalScriptsDict()),
+                "number_of_functions:%lu\r\n", functionsNum(),
+                "number_of_libraries:%lu\r\n", functionsLibNum(),
+                "used_memory_vm_functions:%lld\r\n", memory_functions,
+                "used_memory_vm_total:%lld\r\n", memory_functions + memory_lua,
+                "used_memory_vm_total_human:%s\r\n", used_memory_vm_total_hmem,
+                "used_memory_functions:%lld\r\n", (long long)mh->functions_caches,
+                "used_memory_scripts:%lld\r\n", (long long)mh->lua_caches + (long long)mh->functions_caches,
+                "used_memory_scripts_human:%s\r\n", used_memory_scripts_hmem,
+                "maxmemory:%lld\r\n", server.maxmemory,
+                "maxmemory_human:%s\r\n", maxmemory_hmem,
+                "maxmemory_policy:%s\r\n", evict_policy,
+                "allocator_frag_ratio:%.2f\r\n", mh->allocator_frag,
+                "allocator_frag_bytes:%zu\r\n", mh->allocator_frag_bytes,
+                "allocator_rss_ratio:%.2f\r\n", mh->allocator_rss,
+                "allocator_rss_bytes:%zd\r\n", mh->allocator_rss_bytes,
+                "rss_overhead_ratio:%.2f\r\n", mh->rss_extra,
+                "rss_overhead_bytes:%zd\r\n", mh->rss_extra_bytes,
+                /* The next field (mem_fragmentation_ratio) is the total RSS
+                 * overhead, including fragmentation, but not just it. This field
+                 * (and the next one) is named like that just for backward
+                 * compatibility. */
+                "mem_fragmentation_ratio:%.2f\r\n", mh->total_frag,
+                "mem_fragmentation_bytes:%zd\r\n", mh->total_frag_bytes,
+                "mem_not_counted_for_evict:%zu\r\n", freeMemoryGetNotCountedMemory(),
+                "mem_replication_backlog:%zu\r\n", mh->repl_backlog,
+                "mem_total_replication_buffers:%zu\r\n", server.repl_buffer_mem,
+                "mem_clients_slaves:%zu\r\n", mh->clients_replicas,
+                "mem_clients_normal:%zu\r\n", mh->clients_normal,
+                "mem_cluster_links:%zu\r\n", mh->cluster_links,
+                "mem_aof_buffer:%zu\r\n", mh->aof_buffer,
+                "mem_allocator:%s\r\n", ZMALLOC_LIB,
+                "mem_overhead_db_hashtable_rehashing:%zu\r\n", mh->overhead_db_hashtable_rehashing,
+                "active_defrag_running:%d\r\n", server.active_defrag_cpu_percent,
+                "lazyfree_pending_objects:%zu\r\n", lazyfreeGetPendingObjectsCount(),
+                "lazyfreed_objects:%zu\r\n", lazyfreeGetFreedObjectsCount()));
+        freeMemoryOverheadData(mh);
+    }
+
+    /* Persistence */
+    if (all_sections || (dictFind(section_dict, "persistence") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        double fork_perc = 0;
+        if (server.stat_module_progress) {
+            fork_perc = server.stat_module_progress * 100;
+        } else if (server.stat_current_save_keys_total) {
+            fork_perc = ((double)server.stat_current_save_keys_processed / server.stat_current_save_keys_total) * 100;
+        }
+        int aof_bio_fsync_status = atomic_load_explicit(&server.aof_bio_fsync_status, memory_order_relaxed);
+
+        info = sdscatprintf(
+            info,
+            "# Persistence\r\n" FMTARGS(
+                "loading:%d\r\n", (int)(server.loading && !server.async_loading),
+                "async_loading:%d\r\n", (int)server.async_loading,
+                "current_cow_peak:%zu\r\n", server.stat_current_cow_peak,
+                "current_cow_size:%zu\r\n", server.stat_current_cow_bytes,
+                "current_cow_size_age:%lu\r\n", (server.stat_current_cow_updated ? (unsigned long)elapsedMs(server.stat_current_cow_updated) / 1000 : 0),
+                "current_fork_perc:%.2f\r\n", fork_perc,
+                "current_save_keys_processed:%zu\r\n", server.stat_current_save_keys_processed,
+                "current_save_keys_total:%zu\r\n", server.stat_current_save_keys_total,
+                "rdb_changes_since_last_save:%lld\r\n", server.dirty,
+                "rdb_bgsave_in_progress:%d\r\n", server.child_type == CHILD_TYPE_RDB,
+                "rdb_last_save_time:%jd\r\n", (intmax_t)server.lastsave,
+                "rdb_last_bgsave_status:%s\r\n", (server.lastbgsave_status == C_OK) ? "ok" : "err",
+                "rdb_last_bgsave_time_sec:%jd\r\n", (intmax_t)server.rdb_save_time_last,
+                "rdb_current_bgsave_time_sec:%jd\r\n", (intmax_t)((server.child_type != CHILD_TYPE_RDB) ? -1 : time(NULL) - server.rdb_save_time_start),
+                "rdb_saves:%lld\r\n", server.stat_rdb_saves,
+                "rdb_last_cow_size:%zu\r\n", server.stat_rdb_cow_bytes,
+                "rdb_last_load_keys_expired:%lld\r\n", server.rdb_last_load_keys_expired,
+                "rdb_last_load_keys_loaded:%lld\r\n", server.rdb_last_load_keys_loaded,
+                "aof_enabled:%d\r\n", server.aof_state != AOF_OFF,
+                "aof_rewrite_in_progress:%d\r\n", server.child_type == CHILD_TYPE_AOF,
+                "aof_rewrite_scheduled:%d\r\n", server.aof_rewrite_scheduled,
+                "aof_last_rewrite_time_sec:%jd\r\n", (intmax_t)server.aof_rewrite_time_last,
+                "aof_current_rewrite_time_sec:%jd\r\n", (intmax_t)((server.child_type != CHILD_TYPE_AOF) ? -1 : time(NULL) - server.aof_rewrite_time_start),
+                "aof_last_bgrewrite_status:%s\r\n", (server.aof_lastbgrewrite_status == C_OK ? "ok" : "err"),
+                "aof_rewrites:%lld\r\n", server.stat_aof_rewrites,
+                "aof_rewrites_consecutive_failures:%lld\r\n", server.stat_aofrw_consecutive_failures,
+                "aof_last_write_status:%s\r\n", (server.aof_last_write_status == C_OK && aof_bio_fsync_status == C_OK) ? "ok" : "err",
+                "aof_last_cow_size:%zu\r\n", server.stat_aof_cow_bytes,
+                "module_fork_in_progress:%d\r\n", server.child_type == CHILD_TYPE_MODULE,
+                "module_fork_last_cow_size:%zu\r\n", server.stat_module_cow_bytes));
+
+        if (server.aof_enabled) {
+            info = sdscatprintf(
+                info,
+                FMTARGS(
+                    "aof_current_size:%lld\r\n", (long long)server.aof_current_size,
+                    "aof_base_size:%lld\r\n", (long long)server.aof_rewrite_base_size,
+                    "aof_pending_rewrite:%d\r\n", server.aof_rewrite_scheduled,
+                    "aof_buffer_length:%zu\r\n", sdslen(server.aof_buf),
+                    "aof_pending_bio_fsync:%lu\r\n", bioPendingJobsOfType(BIO_AOF_FSYNC),
+                    "aof_delayed_fsync:%lu\r\n", server.aof_delayed_fsync));
+        }
+
+        if (server.loading) {
+            double perc = 0;
+            time_t eta, elapsed;
+            off_t remaining_bytes = 1;
+
+            if (server.loading_total_bytes) {
+                perc = ((double)server.loading_loaded_bytes / server.loading_total_bytes) * 100;
+                remaining_bytes = server.loading_total_bytes - server.loading_loaded_bytes;
+            } else if (server.loading_rdb_used_mem) {
+                perc = ((double)server.loading_loaded_bytes / server.loading_rdb_used_mem) * 100;
+                remaining_bytes = server.loading_rdb_used_mem - server.loading_loaded_bytes;
+                /* used mem is only a (bad) estimation of the rdb file size, avoid going over 100% */
+                if (perc > 99.99) perc = 99.99;
+                if (remaining_bytes < 1) remaining_bytes = 1;
+            }
+
+            elapsed = time(NULL) - server.loading_start_time;
+            if (elapsed == 0) {
+                eta = 1; /* A fake 1 second figure if we don't have
+                            enough info */
+            } else {
+                eta = (elapsed * remaining_bytes) / (server.loading_loaded_bytes + 1);
+            }
+
+            info = sdscatprintf(
+                info,
+                FMTARGS(
+                    "loading_start_time:%jd\r\n", (intmax_t)server.loading_start_time,
+                    "loading_total_bytes:%llu\r\n", (unsigned long long)server.loading_total_bytes,
+                    "loading_rdb_used_mem:%llu\r\n", (unsigned long long)server.loading_rdb_used_mem,
+                    "loading_loaded_bytes:%llu\r\n", (unsigned long long)server.loading_loaded_bytes,
+                    "loading_loaded_perc:%.2f\r\n", perc,
+                    "loading_eta_seconds:%jd\r\n", (intmax_t)eta));
+        }
+    }
+
+    /* Stats */
+    if (all_sections || (dictFind(section_dict, "stats") != NULL)) {
+        long long current_eviction_exceeded_time =
+            server.stat_last_eviction_exceeded_time ? (long long)elapsedUs(server.stat_last_eviction_exceeded_time) : 0;
+        long long current_active_defrag_time =
+            server.stat_last_active_defrag_time ? (long long)elapsedUs(server.stat_last_active_defrag_time) : 0;
+
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(
+            info,
+            "# Stats\r\n" FMTARGS(
+                "total_connections_received:%lld\r\n", server.stat_numconnections,
+                "total_commands_processed:%lld\r\n", server.stat_numcommands,
+                "instantaneous_ops_per_sec:%lld\r\n", getInstantaneousMetric(STATS_METRIC_COMMAND),
+                "total_net_input_bytes:%lld\r\n", server.stat_net_input_bytes + server.stat_net_repl_input_bytes,
+                "total_net_output_bytes:%lld\r\n", server.stat_net_output_bytes + server.stat_net_repl_output_bytes,
+                "total_net_repl_input_bytes:%lld\r\n", server.stat_net_repl_input_bytes,
+                "total_net_repl_output_bytes:%lld\r\n", server.stat_net_repl_output_bytes,
+                "instantaneous_input_kbps:%.2f\r\n", (float)getInstantaneousMetric(STATS_METRIC_NET_INPUT) / 1024,
+                "instantaneous_output_kbps:%.2f\r\n", (float)getInstantaneousMetric(STATS_METRIC_NET_OUTPUT) / 1024,
+                "instantaneous_input_repl_kbps:%.2f\r\n", (float)getInstantaneousMetric(STATS_METRIC_NET_INPUT_REPLICATION) / 1024,
+                "instantaneous_output_repl_kbps:%.2f\r\n", (float)getInstantaneousMetric(STATS_METRIC_NET_OUTPUT_REPLICATION) / 1024,
+                "rejected_connections:%lld\r\n", server.stat_rejected_conn,
+                "sync_full:%lld\r\n", server.stat_sync_full,
+                "sync_partial_ok:%lld\r\n", server.stat_sync_partial_ok,
+                "sync_partial_err:%lld\r\n", server.stat_sync_partial_err,
+                "expired_keys:%lld\r\n", server.stat_expiredkeys,
+                "expired_stale_perc:%.2f\r\n", server.stat_expired_stale_perc * 100,
+                "expired_time_cap_reached_count:%lld\r\n", server.stat_expired_time_cap_reached_count,
+                "expire_cycle_cpu_milliseconds:%lld\r\n", server.stat_expire_cycle_time_used / 1000,
+                "evicted_keys:%lld\r\n", server.stat_evictedkeys,
+                "evicted_clients:%lld\r\n", server.stat_evictedclients,
+                "evicted_scripts:%lld\r\n", server.stat_evictedscripts,
+                "total_eviction_exceeded_time:%lld\r\n", (server.stat_total_eviction_exceeded_time + current_eviction_exceeded_time) / 1000,
+                "current_eviction_exceeded_time:%lld\r\n", current_eviction_exceeded_time / 1000,
+                "keyspace_hits:%lld\r\n", server.stat_keyspace_hits,
+                "keyspace_misses:%lld\r\n", server.stat_keyspace_misses,
+                "pubsub_channels:%llu\r\n", kvstoreSize(server.pubsub_channels),
+                "pubsub_patterns:%lu\r\n", dictSize(server.pubsub_patterns),
+                "pubsubshard_channels:%llu\r\n", kvstoreSize(server.pubsubshard_channels),
+                "latest_fork_usec:%lld\r\n", server.stat_fork_time,
+                "total_forks:%lld\r\n", server.stat_total_forks,
+                "migrate_cached_sockets:%ld\r\n", dictSize(server.migrate_cached_sockets),
+                "slave_expires_tracked_keys:%zu\r\n", getReplicaKeyWithExpireCount(),
+                "active_defrag_hits:%lld\r\n", server.stat_active_defrag_hits,
+                "active_defrag_misses:%lld\r\n", server.stat_active_defrag_misses,
+                "active_defrag_key_hits:%lld\r\n", server.stat_active_defrag_key_hits,
+                "active_defrag_key_misses:%lld\r\n", server.stat_active_defrag_key_misses,
+                "total_active_defrag_time:%lld\r\n", (server.stat_total_active_defrag_time + current_active_defrag_time) / 1000,
+                "current_active_defrag_time:%lld\r\n", current_active_defrag_time / 1000,
+                "tracking_total_keys:%lld\r\n", (unsigned long long)trackingGetTotalKeys(),
+                "tracking_total_items:%lld\r\n", (unsigned long long)trackingGetTotalItems(),
+                "tracking_total_prefixes:%lld\r\n", (unsigned long long)trackingGetTotalPrefixes(),
+                "unexpected_error_replies:%lld\r\n", server.stat_unexpected_error_replies,
+                "total_error_replies:%lld\r\n", server.stat_total_error_replies,
+                "dump_payload_sanitizations:%lld\r\n", server.stat_dump_payload_sanitizations,
+                "total_reads_processed:%lld\r\n", server.stat_total_reads_processed,
+                "total_writes_processed:%lld\r\n", server.stat_total_writes_processed,
+                "io_threaded_reads_processed:%lld\r\n", server.stat_io_reads_processed,
+                "io_threaded_writes_processed:%lld\r\n", server.stat_io_writes_processed,
+                "io_threaded_freed_objects:%lld\r\n", server.stat_io_freed_objects,
+                "io_threaded_accept_processed:%lld\r\n", server.stat_io_accept_offloaded,
+                "io_threaded_poll_processed:%lld\r\n", server.stat_poll_processed_by_io_threads,
+                "io_threaded_total_prefetch_batches:%lld\r\n", server.stat_total_prefetch_batches,
+                "io_threaded_total_prefetch_entries:%lld\r\n", server.stat_total_prefetch_entries,
+                "client_query_buffer_limit_disconnections:%lld\r\n", server.stat_client_qbuf_limit_disconnections,
+                "client_output_buffer_limit_disconnections:%lld\r\n", server.stat_client_outbuf_limit_disconnections,
+                "reply_buffer_shrinks:%lld\r\n", server.stat_reply_buffer_shrinks,
+                "reply_buffer_expands:%lld\r\n", server.stat_reply_buffer_expands,
+                "eventloop_cycles:%llu\r\n", server.duration_stats[EL_DURATION_TYPE_EL].cnt,
+                "eventloop_duration_sum:%llu\r\n", server.duration_stats[EL_DURATION_TYPE_EL].sum,
+                "eventloop_duration_cmd_sum:%llu\r\n", server.duration_stats[EL_DURATION_TYPE_CMD].sum,
+                "instantaneous_eventloop_cycles_per_sec:%llu\r\n", getInstantaneousMetric(STATS_METRIC_EL_CYCLE),
+                "instantaneous_eventloop_duration_usec:%llu\r\n", getInstantaneousMetric(STATS_METRIC_EL_DURATION)));
+        info = genValkeyInfoStringACLStats(info);
+    }
+
+    /* Replication */
+    if (all_sections || (dictFind(section_dict, "replication") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(info,
+                            "# Replication\r\n"
+                            "role:%s\r\n",
+                            server.primary_host == NULL ? "master" : "slave");
+        if (server.primary_host) {
+            long long replica_repl_offset = 1;
+            long long replica_read_repl_offset = 1;
+
+            if (server.primary) {
+                replica_repl_offset = server.primary->repl_data->reploff;
+                replica_read_repl_offset = server.primary->repl_data->read_reploff;
+            } else if (server.cached_primary) {
+                replica_repl_offset = server.cached_primary->repl_data->reploff;
+                replica_read_repl_offset = server.cached_primary->repl_data->read_reploff;
+            }
+
+            info = sdscatprintf(
+                info,
+                FMTARGS(
+                    "master_host:%s\r\n", server.primary_host,
+                    "master_port:%d\r\n", server.primary_port,
+                    "master_link_status:%s\r\n", (server.repl_state == REPL_STATE_CONNECTED) ? "up" : "down",
+                    "master_last_io_seconds_ago:%d\r\n", server.primary ? ((int)(server.unixtime - server.primary->last_interaction)) : -1,
+                    "master_sync_in_progress:%d\r\n", server.repl_state == REPL_STATE_TRANSFER,
+                    "slave_read_repl_offset:%lld\r\n", replica_read_repl_offset,
+                    "slave_repl_offset:%lld\r\n", replica_repl_offset,
+                    "replicas_repl_buffer_size:%zu\r\n", server.pending_repl_data.len,
+                    "replicas_repl_buffer_peak:%zu\r\n", server.pending_repl_data.peak));
+
+            if (server.repl_state == REPL_STATE_TRANSFER) {
+                double perc = 0;
+                if (server.repl_transfer_size) {
+                    perc = ((double)server.repl_transfer_read / server.repl_transfer_size) * 100;
+                }
+                info = sdscatprintf(
+                    info,
+                    FMTARGS(
+                        "master_sync_total_bytes:%lld\r\n", (long long)server.repl_transfer_size,
+                        "master_sync_read_bytes:%lld\r\n", (long long)server.repl_transfer_read,
+                        "master_sync_left_bytes:%lld\r\n", (long long)(server.repl_transfer_size - server.repl_transfer_read),
+                        "master_sync_perc:%.2f\r\n", perc,
+                        "master_sync_last_io_seconds_ago:%d\r\n", (int)(server.unixtime - server.repl_transfer_lastio)));
+            }
+
+            if (server.repl_state != REPL_STATE_CONNECTED) {
+                info = sdscatprintf(info, "master_link_down_since_seconds:%jd\r\n",
+                                    server.repl_down_since ? (intmax_t)(server.unixtime - server.repl_down_since) : -1);
+            }
+            info = sdscatprintf(
+                info,
+                FMTARGS(
+                    "slave_priority:%d\r\n", server.replica_priority,
+                    "slave_read_only:%d\r\n", server.repl_replica_ro,
+                    "replica_announced:%d\r\n", server.replica_announced));
+        }
+
+        info = sdscatprintf(info, "connected_slaves:%lu\r\n", listLength(server.replicas));
+
+        /* If min-replicas-to-write is active, write the number of replicas
+         * currently considered 'good'. */
+        if (server.repl_min_replicas_to_write && server.repl_min_replicas_max_lag) {
+            info = sdscatprintf(info, "min_slaves_good_slaves:%d\r\n", server.repl_good_replicas_count);
+        }
+
+        if (listLength(server.replicas)) {
+            int replica_id = 0;
+            listNode *ln;
+            listIter li;
+
+            listRewind(server.replicas, &li);
+            while ((ln = listNext(&li))) {
+                client *replica = listNodeValue(ln);
+                char ip[NET_IP_STR_LEN], *replica_ip = replica->repl_data->replica_addr;
+                int port;
+                long lag = 0;
+
+                if (!replica_ip) {
+                    if (connAddrPeerName(replica->conn, ip, sizeof(ip), &port) == -1) continue;
+                    replica_ip = ip;
+                }
+                const char *state = replstateToString(replica->repl_data->repl_state);
+                if (state[0] == '\0') continue;
+                if (replica->repl_data->repl_state == REPLICA_STATE_ONLINE) lag = time(NULL) - replica->repl_data->repl_ack_time;
+
+                info = sdscatprintf(info,
+                                    "slave%d:ip=%s,port=%d,state=%s,"
+                                    "offset=%lld,lag=%ld,type=%s\r\n",
+                                    replica_id, replica_ip, replica->repl_data->replica_listening_port, state,
+                                    replica->repl_data->repl_ack_off, lag,
+                                    replica->flag.repl_rdb_channel                                ? "rdb-channel"
+                                    : replica->repl_data->repl_state == REPLICA_STATE_BG_RDB_LOAD ? "main-channel"
+                                                                                                  : "replica");
+                replica_id++;
+            }
+        }
+        info = sdscatprintf(
+            info,
+            FMTARGS(
+                "replicas_waiting_psync:%llu\r\n", (unsigned long long)raxSize(server.replicas_waiting_psync),
+                "master_failover_state:%s\r\n", getFailoverStateString(),
+                "master_replid:%s\r\n", server.replid,
+                "master_replid2:%s\r\n", server.replid2,
+                "master_repl_offset:%lld\r\n", server.primary_repl_offset,
+                "second_repl_offset:%lld\r\n", server.second_replid_offset,
+                "repl_backlog_active:%d\r\n", server.repl_backlog != NULL,
+                "repl_backlog_size:%lld\r\n", server.repl_backlog_size,
+                "repl_backlog_first_byte_offset:%lld\r\n", server.repl_backlog ? server.repl_backlog->offset : 0,
+                "repl_backlog_histlen:%lld\r\n", server.repl_backlog ? server.repl_backlog->histlen : 0));
+    }
+
+    /* CPU */
+    if (all_sections || (dictFind(section_dict, "cpu") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+
+        struct rusage self_ru, c_ru;
+        getrusage(RUSAGE_SELF, &self_ru);
+        getrusage(RUSAGE_CHILDREN, &c_ru);
+        info = sdscatprintf(info,
+                            "# CPU\r\n"
+                            "used_cpu_sys:%ld.%06ld\r\n"
+                            "used_cpu_user:%ld.%06ld\r\n"
+                            "used_cpu_sys_children:%ld.%06ld\r\n"
+                            "used_cpu_user_children:%ld.%06ld\r\n",
+                            (long)self_ru.ru_stime.tv_sec, (long)self_ru.ru_stime.tv_usec,
+                            (long)self_ru.ru_utime.tv_sec, (long)self_ru.ru_utime.tv_usec, (long)c_ru.ru_stime.tv_sec,
+                            (long)c_ru.ru_stime.tv_usec, (long)c_ru.ru_utime.tv_sec, (long)c_ru.ru_utime.tv_usec);
+#ifdef RUSAGE_THREAD
+        struct rusage m_ru;
+        getrusage(RUSAGE_THREAD, &m_ru);
+        info = sdscatprintf(info,
+                            "used_cpu_sys_main_thread:%ld.%06ld\r\n"
+                            "used_cpu_user_main_thread:%ld.%06ld\r\n",
+                            (long)m_ru.ru_stime.tv_sec, (long)m_ru.ru_stime.tv_usec, (long)m_ru.ru_utime.tv_sec,
+                            (long)m_ru.ru_utime.tv_usec);
+#endif /* RUSAGE_THREAD */
+    }
+
+    /* Modules */
+    if (all_sections || (dictFind(section_dict, "module_list") != NULL) ||
+        (dictFind(section_dict, "modules") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(info, "# Modules\r\n");
+        info = genModulesInfoString(info);
+    }
+
+    /* Command statistics */
+    if (all_sections || (dictFind(section_dict, "commandstats") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(info, "# Commandstats\r\n");
+        info = genValkeyInfoStringCommandStats(info, server.commands);
+    }
+
+    /* Error statistics */
+    if (all_sections || (dictFind(section_dict, "errorstats") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscat(info, "# Errorstats\r\n");
+        raxIterator ri;
+        raxStart(&ri, server.errors);
+        raxSeek(&ri, "^", NULL, 0);
+        struct serverError *e;
+        while (raxNext(&ri)) {
+            char *tmpsafe;
+            e = (struct serverError *)ri.data;
+            info = sdscatprintf(info, "errorstat_%.*s:count=%lld\r\n", (int)ri.key_len,
+                                getSafeInfoString((char *)ri.key, ri.key_len, &tmpsafe), e->count);
+            if (tmpsafe != NULL) zfree(tmpsafe);
+        }
+        raxStop(&ri);
+    }
+
+    /* Latency by percentile distribution per command */
+    if (all_sections || (dictFind(section_dict, "latencystats") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(info, "# Latencystats\r\n");
+        if (server.latency_tracking_enabled) {
+            info = genValkeyInfoStringLatencyStats(info, server.commands);
+        }
+    }
+
+    /* Cluster */
+    if (all_sections || (dictFind(section_dict, "cluster") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(info,
+                            "# Cluster\r\n"
+                            "cluster_enabled:%d\r\n",
+                            server.cluster_enabled);
+    }
+
+    /* Key space */
+    if (all_sections || (dictFind(section_dict, "keyspace") != NULL)) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(info, "# Keyspace\r\n");
+        for (j = 0; j < server.dbnum; j++) {
+            long long keys, vkeys;
+
+            keys = kvstoreSize(server.db[j].keys);
+            vkeys = kvstoreSize(server.db[j].expires);
+            if (keys || vkeys) {
+                info = sdscatprintf(info, "db%d:keys=%lld,expires=%lld,avg_ttl=%lld\r\n", j, keys, vkeys,
+                                    server.db[j].avg_ttl);
+            }
+        }
+    }
+
+    /* Get info from modules.
+     * Returned when the user asked for "everything", "modules", or a specific module section.
+     * We're not aware of the module section names here, and we rather avoid the search when we can.
+     * so we proceed if there's a requested section name that's not found yet, or when the user asked
+     * for "all" with any additional section names. */
+    if (everything || dictFind(section_dict, "modules") != NULL || sections < (int)dictSize(section_dict) ||
+        (all_sections && dictSize(section_dict))) {
+        info = modulesCollectInfo(info, everything || dictFind(section_dict, "modules") != NULL ? NULL : section_dict,
+                                  0, /* not a crash report */
+                                  sections);
+    }
+
+    if (dictFind(section_dict, "debug") != NULL) {
+        if (sections++) info = sdscat(info, "\r\n");
+        info = sdscatprintf(
+            info,
+            "# Debug\r\n" FMTARGS(
+                "eventloop_duration_aof_sum:%llu\r\n", server.duration_stats[EL_DURATION_TYPE_AOF].sum,
+                "eventloop_duration_cron_sum:%llu\r\n", server.duration_stats[EL_DURATION_TYPE_CRON].sum,
+                "eventloop_duration_max:%llu\r\n", server.duration_stats[EL_DURATION_TYPE_EL].max,
+                "eventloop_cmd_per_cycle_max:%lld\r\n", server.el_cmd_cnt_max));
+    }
+
+    return info;
+}
+
+/* INFO [<section> [<section> ...]] */
+void infoCommand(client *c) {
+    if (server.sentinel_mode) {
+        sentinelInfoCommand(c);
+        return;
+    }
+    int all_sections = 0;
+    int everything = 0;
+    dict *sections_dict = genInfoSectionDict(c->argv + 1, c->argc - 1, NULL, &all_sections, &everything);
+    sds info = genValkeyInfoString(sections_dict, all_sections, everything);
+    addReplyVerbatim(c, info, sdslen(info), "txt");
+    sdsfree(info);
+    releaseInfoSectionDict(sections_dict);
+    return;
+}
+
+void monitorCommand(client *c) {
+    if (c->flag.deny_blocking) {
+        /**
+         * A client that has CLIENT_DENY_BLOCKING flag on
+         * expects a reply per command and so can't execute MONITOR. */
+        addReplyError(c, "MONITOR isn't allowed for DENY BLOCKING client");
+        return;
+    }
+
+    /* ignore MONITOR if already replica or in monitor mode */
+    if (c->flag.replica) return;
+
+    initClientReplicationData(c);
+
+    c->flag.replica = 1;
+    c->flag.monitor = 1;
+    listAddNodeTail(server.monitors, c);
+    addReply(c, shared.ok);
+}
+
+/* =================================== Main! ================================ */
+
+int checkIgnoreWarning(const char *warning) {
+    int argc, j;
+    sds *argv = sdssplitargs(server.ignore_warnings, &argc);
+    if (argv == NULL) return 0;
+
+    for (j = 0; j < argc; j++) {
+        char *flag = argv[j];
+        if (!strcasecmp(flag, warning)) break;
+    }
+    sdsfreesplitres(argv, argc);
+    return j < argc;
+}
+
+#ifdef __linux__
+#include <sys/prctl.h>
+/* since linux-3.5, kernel supports to set the state of the "THP disable" flag
+ * for the calling thread. PR_SET_THP_DISABLE is defined in linux/prctl.h */
+static int THPDisable(void) {
+    int ret = -EINVAL;
+
+    if (!server.disable_thp) return ret;
+
+#ifdef PR_SET_THP_DISABLE
+    ret = prctl(PR_SET_THP_DISABLE, 1, 0, 0, 0);
+#endif
+
+    return ret;
+}
+
+void linuxMemoryWarnings(void) {
+    sds err_msg = NULL;
+    if (checkOvercommit(&err_msg) < 0) {
+        serverLog(LL_WARNING, "WARNING %s", err_msg);
+        sdsfree(err_msg);
+    }
+    if (checkTHPEnabled(&err_msg) < 0) {
+        server.thp_enabled = 1;
+        if (THPDisable() == 0) {
+            server.thp_enabled = 0;
+        } else {
+            serverLog(LL_WARNING, "WARNING %s", err_msg);
+        }
+        sdsfree(err_msg);
+    }
+}
+#endif /* __linux__ */
+
+void createPidFile(void) {
+    /* If pidfile requested, but no pidfile defined, use
+     * default pidfile path */
+    if (!server.pidfile) server.pidfile = zstrdup(CONFIG_DEFAULT_PID_FILE);
+
+    /* Try to write the pid file in a best-effort way. */
+    FILE *fp = fopen(server.pidfile, "w");
+    if (fp) {
+        fprintf(fp, "%d\n", (int)getpid());
+        fclose(fp);
+    } else {
+        serverLog(LL_WARNING, "Failed to write PID file: %s", strerror(errno));
+    }
+}
+
+void daemonize(void) {
+    int fd;
+
+    if (fork() != 0) exit(0); /* parent exits */
+    setsid();                 /* create a new session */
+
+    /* Every output goes to /dev/null. If the server is daemonized but
+     * the 'logfile' is set to 'stdout' in the configuration file
+     * it will not log at all. */
+    if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
+        dup2(fd, STDIN_FILENO);
+        dup2(fd, STDOUT_FILENO);
+        dup2(fd, STDERR_FILENO);
+        if (fd > STDERR_FILENO) close(fd);
+    }
+}
+
+sds getVersion(void) {
+    sds version = sdscatprintf(sdsempty(), "v=%s sha=%s:%d malloc=%s bits=%d build=%llx", VALKEY_VERSION,
+                               serverGitSHA1(), atoi(serverGitDirty()) > 0, ZMALLOC_LIB, sizeof(long) == 4 ? 32 : 64,
+                               (unsigned long long)serverBuildId());
+    return version;
+}
+
+void usage(void) {
+    fprintf(stderr, "Usage: ./futriix-server [/path/to/futriix.conf] [options] [-]\n");
+    fprintf(stderr, "       ./futriix-server - (read config from stdin)\n");
+    fprintf(stderr, "       ./futriix-server -v or --version\n");
+    fprintf(stderr, "       ./futriix-server -h or --help\n");
+    fprintf(stderr, "       ./futriix-server --test-memory <megabytes>\n");
+    fprintf(stderr, "       ./futriix-server --check-system\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "Examples:\n");
+    fprintf(stderr, "       ./futriix-server (run the server with default conf)\n");
+    fprintf(stderr, "       echo 'maxmemory 128mb' | ./futriix-server -\n");
+    fprintf(stderr, "       ./futriix-server /etc/futriix/9880.conf\n");
+    fprintf(stderr, "       ./futriix-server --port 7777\n");
+    fprintf(stderr, "       ./futriix-server --port 7777 --replicaof 127.0.0.1 8888\n");
+    fprintf(stderr, "       ./futriix-server /etc/myfutriix.conf --loglevel verbose -\n");
+    fprintf(stderr, "       ./futriix-server /etc/myfutriix.conf --loglevel verbose\n\n");
+    fprintf(stderr, "Sentinel mode:\n");
+    fprintf(stderr, "       ./futriix-server /etc/sentinel.conf --sentinel\n");
+    exit(1);
+}
+
+void serverAsciiArt(void) {
+#include "asciilogo.h"
+    char *buf = zmalloc(1024 * 16);
+    char *mode;
+
+    if (server.cluster_enabled)
+        mode = "cluster";
+    else if (server.sentinel_mode)
+        mode = "sentinel";
+    else
+        mode = "standalone";
+
+    /* Show the ASCII logo if: log file is stdout AND stdout is a
+     * tty AND syslog logging is disabled. Also show logo if the user
+     * forced us to do so via futriix.conf. */
+    int show_logo =
+        ((!server.syslog_enabled && server.logfile[0] == '\0' && isatty(fileno(stdout))) || server.always_show_logo);
+
+    if (!show_logo) {
+        serverLog(LL_NOTICE, "Running mode=%s, port=%d.", mode, server.port ? server.port : server.tls_port);
+    } else {
+        snprintf(buf, 1024 * 16, ascii_logo, VALKEY_VERSION, serverGitSHA1(), strtol(serverGitDirty(), NULL, 10) > 0,
+                 (sizeof(long) == 8) ? "64" : "32", mode, server.port ? server.port : server.tls_port, (long)getpid());
+        serverLogRaw(LL_NOTICE | LL_RAW, buf);
+    }
+    zfree(buf);
+}
+
+/* Get the server listener by type name */
+connListener *listenerByType(const char *typename) {
+    int conn_index;
+
+    conn_index = connectionIndexByType(typename);
+    if (conn_index < 0) return NULL;
+
+    return &server.listeners[conn_index];
+}
+
+/* Close original listener, re-create a new listener from the updated bind address & port */
+int changeListener(connListener *listener) {
+    /* Close old servers */
+    connCloseListener(listener);
+
+    /* Just close the server if port disabled */
+    if (listener->port == 0) {
+        if (server.set_proc_title) serverSetProcTitle(NULL);
+        return C_OK;
+    }
+
+    /* Re-create listener */
+    if (connListen(listener) != C_OK) {
+        return C_ERR;
+    }
+
+    /* Create event handlers */
+    if (createSocketAcceptHandler(listener, listener->ct->accept_handler) != C_OK) {
+        serverPanic("Unrecoverable error creating %s accept handler.", listener->ct->get_type(NULL));
+    }
+
+    if (server.set_proc_title) serverSetProcTitle(NULL);
+
+    return C_OK;
+}
+
+static void sigShutdownHandler(int sig) {
+    char *msg;
+
+    switch (sig) {
+    case SIGINT: msg = "Received SIGINT scheduling shutdown..."; break;
+    case SIGTERM: msg = "Received SIGTERM scheduling shutdown..."; break;
+    default: msg = "Received shutdown signal, scheduling shutdown...";
+    };
+
+    /* SIGINT is often delivered via Ctrl+C in an interactive session.
+     * If we receive the signal the second time, we interpret this as
+     * the user really wanting to quit ASAP without waiting to persist
+     * on disk and without waiting for lagging replicas. */
+    if (server.shutdown_asap && sig == SIGINT) {
+        serverLogRawFromHandler(LL_WARNING, "You insist... exiting now.");
+        rdbRemoveTempFile(getpid(), 1);
+        exit(1); /* Exit with an error since this was not a clean shutdown. */
+    } else if (server.loading) {
+        msg = "Received shutdown signal during loading, scheduling shutdown.";
+    }
+
+    serverLogRawFromHandler(LL_WARNING, msg);
+    server.shutdown_asap = 1;
+    server.last_sig_received = sig;
+}
+
+void setupSignalHandlers(void) {
+    struct sigaction act;
+
+    sigemptyset(&act.sa_mask);
+    act.sa_flags = 0;
+    act.sa_handler = sigShutdownHandler;
+    sigaction(SIGTERM, &act, NULL);
+    sigaction(SIGINT, &act, NULL);
+
+    setupDebugSigHandlers();
+}
+
+/* This is the signal handler for children process. It is currently useful
+ * in order to track the SIGUSR1, that we send to a child in order to terminate
+ * it in a clean way, without the parent detecting an error and stop
+ * accepting writes because of a write error condition. */
+static void sigKillChildHandler(int sig) {
+    UNUSED(sig);
+    int level = server.in_fork_child == CHILD_TYPE_MODULE ? LL_VERBOSE : LL_WARNING;
+    serverLogRawFromHandler(level, "Received SIGUSR1 in child, exiting now.");
+    exitFromChild(SERVER_CHILD_NOERROR_RETVAL);
+}
+
+void setupChildSignalHandlers(void) {
+    struct sigaction act;
+
+    /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction is used.
+     * Otherwise, sa_handler is used. */
+    sigemptyset(&act.sa_mask);
+    act.sa_flags = 0;
+    act.sa_handler = sigKillChildHandler;
+    sigaction(SIGUSR1, &act, NULL);
+}
+
+/* After fork, the child process will inherit the resources
+ * of the parent process, e.g. fd(socket or flock) etc.
+ * should close the resources not used by the child process, so that if the
+ * parent restarts it can bind/lock despite the child possibly still running. */
+void closeChildUnusedResourceAfterFork(void) {
+    closeListeningSockets(0);
+    if (server.cluster_enabled && server.cluster_config_file_lock_fd != -1)
+        close(server.cluster_config_file_lock_fd); /* don't care if this fails */
+
+    /* Clear server.pidfile, this is the parent pidfile which should not
+     * be touched (or deleted) by the child (on exit / crash) */
+    zfree(server.pidfile);
+    server.pidfile = NULL;
+}
+
+/* purpose is one of CHILD_TYPE_ types */
+int serverFork(int purpose) {
+    if (isMutuallyExclusiveChildType(purpose)) {
+        if (hasActiveChildProcess()) {
+            errno = EALREADY;
+            return -1;
+        }
+
+        openChildInfoPipe();
+    }
+
+    int childpid;
+    long long start = ustime();
+    if ((childpid = fork()) == 0) {
+        /* Child.
+         *
+         * The order of setting things up follows some reasoning:
+         * Setup signal handlers first because a signal could fire at any time.
+         * Adjust OOM score before everything else to assist the OOM killer if
+         * memory resources are low.
+         */
+        server.in_fork_child = purpose;
+        setupChildSignalHandlers();
+        setOOMScoreAdj(CONFIG_OOM_BGCHILD);
+        updateDictResizePolicy();
+        dismissMemoryInChild();
+        closeChildUnusedResourceAfterFork();
+        /* Close the reading part, so that if the parent crashes, the child will
+         * get a write error and exit. */
+        if (server.child_info_pipe[0] != -1) close(server.child_info_pipe[0]);
+    } else {
+        /* Parent */
+        if (childpid == -1) {
+            int fork_errno = errno;
+            if (isMutuallyExclusiveChildType(purpose)) closeChildInfoPipe();
+            errno = fork_errno;
+            return -1;
+        }
+
+        server.stat_total_forks++;
+        server.stat_fork_time = ustime() - start;
+        server.stat_fork_rate =
+            (double)zmalloc_used_memory() * 1000000 / server.stat_fork_time / (1024 * 1024 * 1024); /* GB per second. */
+        latencyAddSampleIfNeeded("fork", server.stat_fork_time / 1000);
+
+        /* The child_pid and child_type are only for mutually exclusive children.
+         * other child types should handle and store their pid's in dedicated variables.
+         *
+         * Today, we allows CHILD_TYPE_LDB to run in parallel with the other fork types:
+         * - it isn't used for production, so it will not make the server be less efficient
+         * - used for debugging, and we don't want to block it from running while other
+         *   forks are running (like RDB and AOF) */
+        if (isMutuallyExclusiveChildType(purpose)) {
+            server.child_pid = childpid;
+            server.child_type = purpose;
+            server.stat_current_cow_peak = 0;
+            server.stat_current_cow_bytes = 0;
+            server.stat_current_cow_updated = 0;
+            server.stat_current_save_keys_processed = 0;
+            server.stat_module_progress = 0;
+            server.stat_current_save_keys_total = dbTotalServerKeyCount();
+        }
+
+        updateDictResizePolicy();
+        moduleFireServerEvent(VALKEYMODULE_EVENT_FORK_CHILD, VALKEYMODULE_SUBEVENT_FORK_CHILD_BORN, NULL);
+    }
+    return childpid;
+}
+
+void sendChildCowInfo(childInfoType info_type, char *pname) {
+    sendChildInfoGeneric(info_type, 0, -1, pname);
+}
+
+void sendChildInfo(childInfoType info_type, size_t keys, char *pname) {
+    sendChildInfoGeneric(info_type, keys, -1, pname);
+}
+
+/* Dismiss big chunks of memory inside a client structure, see zmadvise_dontneed() */
+void dismissClientMemory(client *c) {
+    /* Dismiss client query buffer and static reply buffer. */
+    dismissMemory(c->buf, c->buf_usable_size);
+    if (c->querybuf) dismissSds(c->querybuf);
+    /* Dismiss argv array only if we estimate it contains a big buffer. */
+    if (c->argc && c->argv_len_sum / c->argc >= server.page_size) {
+        for (int i = 0; i < c->argc; i++) {
+            dismissObject(c->argv[i], 0);
+        }
+    }
+    if (c->argc) dismissMemory(c->argv, c->argc * sizeof(robj *));
+
+    /* Dismiss the reply array only if the average buffer size is bigger
+     * than a page. */
+    if (listLength(c->reply) && c->reply_bytes / listLength(c->reply) >= server.page_size) {
+        listIter li;
+        listNode *ln;
+        listRewind(c->reply, &li);
+        while ((ln = listNext(&li))) {
+            clientReplyBlock *bulk = listNodeValue(ln);
+            /* Default bulk size is 16k, actually it has extra data, maybe it
+             * occupies 20k according to jemalloc bin size if using jemalloc. */
+            if (bulk) dismissMemory(bulk, bulk->size);
+        }
+    }
+}
+
+/* In the child process, we don't need some buffers anymore, and these are
+ * likely to change in the parent when there's heavy write traffic.
+ * We dismiss them right away, to avoid CoW.
+ * see zmadvise_dontneed(). */
+void dismissMemoryInChild(void) {
+    /* madvise(MADV_DONTNEED) may not work if Transparent Huge Pages is enabled. */
+    if (server.thp_enabled) return;
+
+        /* Currently we use zmadvise_dontneed only when we use jemalloc with Linux.
+         * so we avoid these pointless loops when they're not going to do anything. */
+#if defined(USE_JEMALLOC) && defined(__linux__)
+    listIter li;
+    listNode *ln;
+
+    /* Dismiss replication buffer. We don't need to separately dismiss replication
+     * backlog and replica' output buffer, because they just reference the global
+     * replication buffer but don't cost real memory. */
+    listRewind(server.repl_buffer_blocks, &li);
+    while ((ln = listNext(&li))) {
+        replBufBlock *o = listNodeValue(ln);
+        dismissMemory(o, o->size);
+    }
+
+    /* Dismiss all clients memory. */
+    listRewind(server.clients, &li);
+    while ((ln = listNext(&li))) {
+        client *c = listNodeValue(ln);
+        dismissClientMemory(c);
+    }
+#endif
+}
+
+void memtest(size_t megabytes, int passes);
+
+/* Returns 1 if there is --sentinel among the arguments or if
+ * executable name contains "valkey-sentinel". */
+int checkForSentinelMode(int argc, char **argv, char *exec_name) {
+    if (strstr(exec_name, "valkey-sentinel") != NULL) return 1;
+
+    /* valkey may install symlinks like redis-sentinel -> valkey-sentinel. */
+    if (strstr(exec_name, "redis-sentinel") != NULL) return 1;
+
+    for (int j = 1; j < argc; j++)
+        if (!strcmp(argv[j], "--sentinel")) return 1;
+    return 0;
+}
+
+/* Function called at startup to load RDB or AOF file in memory. */
+void loadDataFromDisk(void) {
+    long long start = ustime();
+    if (server.aof_state == AOF_ON) {
+        int ret = loadAppendOnlyFiles(server.aof_manifest);
+        if (ret == AOF_FAILED || ret == AOF_OPEN_ERR) exit(1);
+        if (ret != AOF_NOT_EXIST)
+            serverLog(LL_NOTICE, "DB loaded from append only file: %.3f seconds", (float)(ustime() - start) / 1000000);
+    } else {
+        rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
+        int rsi_is_valid = 0;
+        errno = 0; /* Prevent a stale value from affecting error checking */
+        int rdb_flags = RDBFLAGS_NONE;
+        if (iAmPrimary()) {
+            /* Primary may delete expired keys when loading, we should
+             * propagate expire to replication backlog. */
+            createReplicationBacklog();
+            rdb_flags |= RDBFLAGS_FEED_REPL;
+        }
+        int rdb_load_ret = rdbLoad(server.rdb_filename, &rsi, rdb_flags);
+        if (rdb_load_ret == RDB_OK) {
+            serverLog(LL_NOTICE, "DB loaded from disk: %.3f seconds", (float)(ustime() - start) / 1000000);
+
+            /* Restore the replication ID / offset from the RDB file. */
+            if (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. */
+                rsi.repl_stream_db != -1) {
+                rsi_is_valid = 1;
+                if (!iAmPrimary()) {
+                    memcpy(server.replid, rsi.repl_id, sizeof(server.replid));
+                    server.primary_repl_offset = rsi.repl_offset;
+                    /* If this is a replica, create a cached primary from this
+                     * information, in order to allow partial resynchronizations
+                     * with primaries. */
+                    replicationCachePrimaryUsingMyself();
+                    selectDb(server.cached_primary, rsi.repl_stream_db);
+                } else {
+                    /* If this is a primary, we can save the replication info
+                     * as secondary ID and offset, in order to allow replicas
+                     * to partial resynchronizations with primaries. */
+                    memcpy(server.replid2, rsi.repl_id, sizeof(server.replid));
+                    server.second_replid_offset = rsi.repl_offset + 1;
+                    /* Rebase primary_repl_offset from rsi.repl_offset. */
+                    server.primary_repl_offset += rsi.repl_offset;
+                    serverAssert(server.repl_backlog);
+                    server.repl_backlog->offset = server.primary_repl_offset - server.repl_backlog->histlen + 1;
+                    rebaseReplicationBuffer(rsi.repl_offset);
+                    server.repl_no_replicas_since = time(NULL);
+                }
+            }
+        } else if (rdb_load_ret != RDB_NOT_EXIST) {
+            serverLog(LL_WARNING, "Fatal error loading the DB, check server logs. Exiting.");
+            exit(1);
+        }
+
+        /* We always create replication backlog if server is a primary, we need
+         * it because we put DELs in it when loading expired keys in RDB, but
+         * if RDB doesn't have replication info or there is no rdb, it is not
+         * possible to support partial resynchronization, to avoid extra memory
+         * of replication backlog, we drop it. */
+        if (!rsi_is_valid && server.repl_backlog) freeReplicationBacklog();
+    }
+}
+
+void serverOutOfMemoryHandler(size_t allocation_size) {
+    serverLog(LL_WARNING, "Out Of Memory allocating %zu bytes!", allocation_size);
+    serverPanic("Valkey aborting for OUT OF MEMORY. Allocating %zu bytes!", allocation_size);
+}
+
+/* Callback for sdstemplate on proc-title-template. See futriix.conf for
+ * supported variables.
+ */
+static sds serverProcTitleGetVariable(const_sds varname, void *arg) {
+    if (!strcmp(varname, "title")) {
+        return sdsnew(arg);
+    } else if (!strcmp(varname, "listen-addr")) {
+        if (server.port || server.tls_port)
+            return sdscatprintf(sdsempty(), "%s:%u", server.bindaddr_count ? server.bindaddr[0] : "*",
+                                server.port ? server.port : server.tls_port);
+        else
+            return sdscatprintf(sdsempty(), "unixsocket:%s", server.unixsocket);
+    } else if (!strcmp(varname, "server-mode")) {
+        if (server.cluster_enabled)
+            return sdsnew("[cluster]");
+        else if (server.sentinel_mode)
+            return sdsnew("[sentinel]");
+        else
+            return sdsempty();
+    } else if (!strcmp(varname, "config-file")) {
+        return sdsnew(server.configfile ? server.configfile : "-");
+    } else if (!strcmp(varname, "port")) {
+        return sdscatprintf(sdsempty(), "%u", server.port);
+    } else if (!strcmp(varname, "tls-port")) {
+        return sdscatprintf(sdsempty(), "%u", server.tls_port);
+    } else if (!strcmp(varname, "unixsocket")) {
+        return sdsnew(server.unixsocket);
+    } else
+        return NULL; /* Unknown variable name */
+}
+
+/* Expand the specified proc-title-template string and return a newly
+ * allocated sds, or NULL. */
+static sds expandProcTitleTemplate(const char *template, const char *title) {
+    sds res = sdstemplate(template, serverProcTitleGetVariable, (void *)title);
+    if (!res) return NULL;
+    return sdstrim(res, " ");
+}
+/* Validate the specified template, returns 1 if valid or 0 otherwise. */
+int validateProcTitleTemplate(const char *template) {
+    int ok = 1;
+    sds res = expandProcTitleTemplate(template, "");
+    if (!res) return 0;
+    if (sdslen(res) == 0) ok = 0;
+    sdsfree(res);
+    return ok;
+}
+
+int serverSetProcTitle(char *title) {
+#ifdef USE_SETPROCTITLE
+    if (!title) title = server.exec_argv[0];
+    sds proc_title = expandProcTitleTemplate(server.proc_title_template, title);
+    if (!proc_title) return C_ERR; /* Not likely, proc_title_template is validated */
+
+    setproctitle("%s", proc_title);
+    sdsfree(proc_title);
+#else
+    UNUSED(title);
+#endif
+
+    return C_OK;
+}
+
+void serverSetCpuAffinity(const char *cpulist) {
+#ifdef USE_SETCPUAFFINITY
+    setcpuaffinity(cpulist);
+#else
+    UNUSED(cpulist);
+#endif
+}
+
+/* Send a notify message to systemd. Returns sd_notify return code which is
+ * a positive number on success. */
+int serverCommunicateSystemd(const char *sd_notify_msg) {
+#ifdef HAVE_LIBSYSTEMD
+    int ret = sd_notify(0, sd_notify_msg);
+
+    if (ret == 0)
+        serverLog(LL_WARNING, "systemd supervision error: NOTIFY_SOCKET not found!");
+    else if (ret < 0)
+        serverLog(LL_WARNING, "systemd supervision error: sd_notify: %d", ret);
+    return ret;
+#else
+    UNUSED(sd_notify_msg);
+    return 0;
+#endif
+}
+
+/* Attempt to set up upstart supervision. Returns 1 if successful. */
+static int serverSupervisedUpstart(void) {
+    const char *upstart_job = getenv("UPSTART_JOB");
+
+    if (!upstart_job) {
+        serverLog(LL_WARNING, "upstart supervision requested, but UPSTART_JOB not found!");
+        return 0;
+    }
+
+    serverLog(LL_NOTICE, "supervised by upstart, will stop to signal readiness.");
+    raise(SIGSTOP);
+    unsetenv("UPSTART_JOB");
+    return 1;
+}
+
+/* Attempt to set up systemd supervision. Returns 1 if successful. */
+static int serverSupervisedSystemd(void) {
+#ifndef HAVE_LIBSYSTEMD
+    serverLog(LL_WARNING,
+              "systemd supervision requested or auto-detected, but Futriix is compiled without libsystemd support!");
+    return 0;
+#else
+    if (serverCommunicateSystemd("STATUS=Futriix is loading...\n") <= 0) return 0;
+    serverLog(LL_NOTICE, "Supervised by systemd. Please make sure you set appropriate values for TimeoutStartSec and "
+                         "TimeoutStopSec in your service unit.");
+    return 1;
+#endif
+}
+
+int serverIsSupervised(int mode) {
+    int ret = 0;
+
+    if (mode == SUPERVISED_AUTODETECT) {
+        if (getenv("UPSTART_JOB")) {
+            serverLog(LL_VERBOSE, "Upstart supervision detected.");
+            mode = SUPERVISED_UPSTART;
+        } else if (getenv("NOTIFY_SOCKET")) {
+            serverLog(LL_VERBOSE, "Systemd supervision detected.");
+            mode = SUPERVISED_SYSTEMD;
+        }
+    }
+
+    switch (mode) {
+    case SUPERVISED_UPSTART: ret = serverSupervisedUpstart(); break;
+    case SUPERVISED_SYSTEMD: ret = serverSupervisedSystemd(); break;
+    default: break;
+    }
+
+    if (ret) server.supervised_mode = mode;
+
+    return ret;
+}
+
+int iAmPrimary(void) {
+    return ((!server.cluster_enabled && server.primary_host == NULL) ||
+            (server.cluster_enabled && clusterNodeIsPrimary(getMyClusterNode())));
+}
+
+/* Main is marked as weak so that unit tests can use their own main function. */
+__attribute__((weak)) int main(int argc, char **argv) {
+    struct timeval tv;
+    int j;
+    char config_from_stdin = 0;
+
+    /* We need to initialize our libraries, and the server configuration. */
+#ifdef INIT_SETPROCTITLE_REPLACEMENT
+    spt_init(argc, argv);
+#endif
+    tzset(); /* Populates 'timezone' global. */
+    zmalloc_set_oom_handler(serverOutOfMemoryHandler);
+#if defined(HAVE_DEFRAG)
+    int res = allocatorDefragInit();
+    serverAssert(res == 0);
+#endif
+    /* To achieve entropy, in case of containers, their time() and getpid() can
+     * be the same. But value of tv_usec is fast enough to make the difference */
+    gettimeofday(&tv, NULL);
+    srand(time(NULL) ^ getpid() ^ tv.tv_usec);
+    srandom(time(NULL) ^ getpid() ^ tv.tv_usec);
+    init_genrand64(((long long)tv.tv_sec * 1000000 + tv.tv_usec) ^ getpid());
+    crc64_init();
+
+    /* Store umask value. Because umask(2) only offers a set-and-get API we have
+     * to reset it and restore it back. We do this early to avoid a potential
+     * race condition with threads that could be creating files or directories.
+     */
+    umask(server.umask = umask(0777));
+
+    uint8_t hashseed[16];
+    getRandomBytes(hashseed, sizeof(hashseed));
+    dictSetHashFunctionSeed(hashseed);
+    hashtableSetHashFunctionSeed(hashseed);
+
+    char *exec_name = strrchr(argv[0], '/');
+    if (exec_name == NULL) exec_name = argv[0];
+    server.sentinel_mode = checkForSentinelMode(argc, argv, exec_name);
+    initServerConfig();
+    server.pid = getpid();
+    ACLInit(); /* The ACL subsystem must be initialized ASAP because the
+                  basic networking code and client creation depends on it. */
+    moduleInitModulesSystem();
+    connTypeInitialize();
+
+    /* Store the executable path and arguments in a safe place in order
+     * to be able to restart the server later. */
+    server.executable = getAbsolutePath(argv[0]);
+    server.exec_argv = zmalloc(sizeof(char *) * (argc + 1));
+    server.exec_argv[argc] = NULL;
+    for (j = 0; j < argc; j++) server.exec_argv[j] = zstrdup(argv[j]);
+
+    /* We need to init sentinel right now as parsing the configuration file
+     * in sentinel mode will have the effect of populating the sentinel
+     * data structures with primary nodes to monitor. */
+    if (server.sentinel_mode) {
+        initSentinelConfig();
+        initSentinel();
+    }
+
+    /* Check if we need to start in valkey-check-rdb/aof mode. We just execute
+     * the program main. However the program is part of the server executable
+     * so that we can easily execute an RDB check on loading errors. */
+    if (strstr(exec_name, "valkey-check-rdb") != NULL)
+        redis_check_rdb_main(argc, argv, NULL);
+    else if (strstr(exec_name, "valkey-check-aof") != NULL)
+        redis_check_aof_main(argc, argv);
+
+    /* valkey may install symlinks like
+     * redis-server -> valkey-server, redis-check-rdb -> valkey-check-rdb,
+     * redis-check-aof -> valkey-check-aof, etc. */
+    if (strstr(exec_name, "redis-check-rdb") != NULL)
+        redis_check_rdb_main(argc, argv, NULL);
+    else if (strstr(exec_name, "redis-check-aof") != NULL)
+        redis_check_aof_main(argc, argv);
+
+    if (argc >= 2) {
+        j = 1; /* First option to parse in argv[] */
+        sds options = sdsempty();
+
+        /* Handle special options --help and --version */
+        if (strcmp(argv[1], "-v") == 0 || strcmp(argv[1], "--version") == 0) {
+            sds version = getVersion();
+            printf("Valkey server %s\n", version);
+            sdsfree(version);
+            exit(0);
+        }
+        if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) usage();
+        if (strcmp(argv[1], "--test-memory") == 0) {
+            if (argc == 3) {
+                memtest(atoi(argv[2]), 50);
+                exit(0);
+            } else {
+                fprintf(stderr, "Please specify the amount of memory to test in megabytes.\n");
+                fprintf(stderr, "Example: ./futriix-server --test-memory 4096\n\n");
+                exit(1);
+            }
+        }
+        if (strcmp(argv[1], "--check-system") == 0) {
+            exit(syscheck() ? 0 : 1);
+        }
+        /* Parse command line options
+         * Precedence wise, File, stdin, explicit options -- last config is the one that matters.
+         *
+         * First argument is the config file name? */
+        if (argv[1][0] != '-') {
+            /* Replace the config file in server.exec_argv with its absolute path. */
+            server.configfile = getAbsolutePath(argv[1]);
+            zfree(server.exec_argv[1]);
+            server.exec_argv[1] = zstrdup(server.configfile);
+            j = 2; // Skip this arg when parsing options
+        }
+        sds *argv_tmp;
+        int argc_tmp;
+        int handled_last_config_arg = 1;
+        while (j < argc) {
+            /* Either first or last argument - Should we read config from stdin? */
+            if (argv[j][0] == '-' && argv[j][1] == '\0' && (j == 1 || j == argc - 1)) {
+                config_from_stdin = 1;
+            }
+            /* All the other options are parsed and conceptually appended to the
+             * configuration file. For instance --port 6380 will generate the
+             * string "port 6380\n" to be parsed after the actual config file
+             * and stdin input are parsed (if they exist).
+             * Only consider that if the last config has at least one argument. */
+            else if (handled_last_config_arg && argv[j][0] == '-' && argv[j][1] == '-') {
+                /* Option name */
+                if (sdslen(options)) options = sdscat(options, "\n");
+                /* argv[j]+2 for removing the preceding `--` */
+                options = sdscat(options, argv[j] + 2);
+                options = sdscat(options, " ");
+
+                argv_tmp = sdssplitargs(argv[j], &argc_tmp);
+                if (argc_tmp == 1) {
+                    /* Means that we only have one option name, like --port or "--port " */
+                    handled_last_config_arg = 0;
+
+                    if ((j != argc - 1) && argv[j + 1][0] == '-' && argv[j + 1][1] == '-' &&
+                        !strcasecmp(argv[j], "--save")) {
+                        /* Special case: handle some things like `--save --config value`.
+                         * In this case, if next argument starts with `--`, we will reset
+                         * handled_last_config_arg flag and append an empty "" config value
+                         * to the options, so it will become `--save "" --config value`.
+                         * We are doing it to be compatible with pre 7.0 behavior (which we
+                         * break it in #10660, 7.0.1), since there might be users who generate
+                         * a command line from an array and when it's empty that's what they produce. */
+                        options = sdscat(options, "\"\"");
+                        handled_last_config_arg = 1;
+                    } else if ((j == argc - 1) && !strcasecmp(argv[j], "--save")) {
+                        /* Special case: when empty save is the last argument.
+                         * In this case, we append an empty "" config value to the options,
+                         * so it will become `--save ""` and will follow the same reset thing. */
+                        options = sdscat(options, "\"\"");
+                    } else if ((j != argc - 1) && argv[j + 1][0] == '-' && argv[j + 1][1] == '-' &&
+                               !strcasecmp(argv[j], "--sentinel")) {
+                        /* Special case: handle some things like `--sentinel --config value`.
+                         * It is a pseudo config option with no value. In this case, if next
+                         * argument starts with `--`, we will reset handled_last_config_arg flag.
+                         * We are doing it to be compatible with pre 7.0 behavior (which we
+                         * break it in #10660, 7.0.1). */
+                        options = sdscat(options, "");
+                        handled_last_config_arg = 1;
+                    } else if ((j == argc - 1) && !strcasecmp(argv[j], "--sentinel")) {
+                        /* Special case: when --sentinel is the last argument.
+                         * It is a pseudo config option with no value. In this case, do nothing.
+                         * We are doing it to be compatible with pre 7.0 behavior (which we
+                         * break it in #10660, 7.0.1). */
+                        options = sdscat(options, "");
+                    }
+                } else {
+                    /* Means that we are passing both config name and it's value in the same arg,
+                     * like "--port 6380", so we need to reset handled_last_config_arg flag. */
+                    handled_last_config_arg = 1;
+                }
+                sdsfreesplitres(argv_tmp, argc_tmp);
+            } else {
+                /* Option argument */
+                options = sdscatrepr(options, argv[j], strlen(argv[j]));
+                options = sdscat(options, " ");
+                handled_last_config_arg = 1;
+            }
+            j++;
+        }
+
+        loadServerConfig(server.configfile, config_from_stdin, options);
+        if (server.sentinel_mode) loadSentinelConfigFromQueue();
+        sdsfree(options);
+    }
+    if (server.sentinel_mode) sentinelCheckConfigFile();
+
+        /* Do system checks */
+#ifdef __linux__
+    linuxMemoryWarnings();
+    sds err_msg = NULL;
+    if (checkXenClocksource(&err_msg) < 0) {
+        serverLog(LL_WARNING, "WARNING %s", err_msg);
+        sdsfree(err_msg);
+    }
+#if defined(__arm64__)
+    int ret;
+    if ((ret = checkLinuxMadvFreeForkBug(&err_msg)) <= 0) {
+        if (ret < 0) {
+            serverLog(LL_WARNING, "WARNING %s", err_msg);
+            sdsfree(err_msg);
+        } else
+            serverLog(LL_WARNING,
+                      "Failed to test the kernel for a bug that could lead to data corruption during background save. "
+                      "Your system could be affected, please report this error.");
+        if (!checkIgnoreWarning("ARM64-COW-BUG")) {
+            serverLog(LL_WARNING, "Futriix will now exit to prevent data corruption. "
+                                  "Note that it is possible to suppress this warning by setting the following config: "
+                                  "ignore-warnings ARM64-COW-BUG");
+            exit(1);
+        }
+    }
+#endif /* __arm64__ */
+#endif /* __linux__ */
+
+    /* Daemonize if needed */
+    server.supervised = serverIsSupervised(server.supervised_mode);
+    int background = server.daemonize && !server.supervised;
+    if (background) {
+        /* We need to reset server.pid after daemonize(), otherwise the
+         * log printing role will always be the child. */
+        daemonize();
+        server.pid = getpid();
+    }
+
+    serverLog(LL_NOTICE, "oO0OoO0OoO0Oo Futriix is starting oO0OoO0OoO0Oo");
+    serverLog(LL_NOTICE, "Futriix version=%s, bits=%d, commit=%s, modified=%d, pid=%d, just started", VALKEY_VERSION,
+              (sizeof(long) == 8) ? 64 : 32, serverGitSHA1(), strtol(serverGitDirty(), NULL, 10) > 0, (int)getpid());
+
+    if (argc == 1) {
+        serverLog(LL_WARNING,
+                  "Warning: no config file specified, using the default config. In order to specify a config file use "
+                  "%s /path/to/futriix.conf",
+                  argv[0]);
+    } else {
+        serverLog(LL_NOTICE, "Configuration loaded");
+    }
+
+    initServer();
+    if (background || server.pidfile) createPidFile();
+    if (server.set_proc_title) serverSetProcTitle(NULL);
+    serverAsciiArt();
+    checkTcpBacklogSettings();
+    if (server.cluster_enabled) {
+        clusterInit();
+    }
+    if (!server.sentinel_mode) {
+        moduleInitModulesSystemLast();
+        moduleLoadFromQueue();
+    }
+    ACLLoadUsersAtStartup();
+    initListeners();
+    if (server.cluster_enabled) {
+        clusterInitLast();
+    }
+    InitServerLast();
+
+    if (!server.sentinel_mode) {
+        /* Things not needed when running in Sentinel mode. */
+        serverLog(LL_NOTICE, "Server initialized");
+        aofLoadManifestFromDisk();
+        loadDataFromDisk();
+        aofOpenIfNeededOnServerStart();
+        aofDelHistoryFiles();
+        if (server.cluster_enabled) {
+            serverAssert(verifyClusterConfigWithData() == C_OK);
+        }
+
+        for (j = 0; j < CONN_TYPE_MAX; j++) {
+            connListener *listener = &server.listeners[j];
+            if (listener->ct == NULL) continue;
+
+            serverLog(LL_NOTICE, "Ready to accept connections %s", listener->ct->get_type(NULL));
+        }
+
+        if (server.supervised_mode == SUPERVISED_SYSTEMD) {
+            if (!server.primary_host) {
+                serverCommunicateSystemd("STATUS=Ready to accept connections\n");
+            } else {
+                serverCommunicateSystemd(
+                    "STATUS=Ready to accept connections in read-only mode. Waiting for MASTER <-> REPLICA sync\n");
+            }
+            serverCommunicateSystemd("READY=1\n");
+        }
+    } else {
+        sentinelIsRunning();
+        if (server.supervised_mode == SUPERVISED_SYSTEMD) {
+            serverCommunicateSystemd("STATUS=Ready to accept connections\n");
+            serverCommunicateSystemd("READY=1\n");
+        }
+    }
+
+    /* Warning the user about suspicious maxmemory setting. */
+    if (server.maxmemory > 0 && server.maxmemory < 1024 * 1024) {
+        serverLog(LL_WARNING,
+                  "WARNING: You specified a maxmemory value that is less than 1MB (current value is %llu bytes). Are "
+                  "you sure this is what you really want?",
+                  server.maxmemory);
+    }
+
+    serverSetCpuAffinity(server.server_cpulist);
+    setOOMScoreAdj(-1);
+
+    aeMain(server.el);
+    aeDeleteEventLoop(server.el);
+    return 0;
+}
+/* The End */
diff --git a/src/valkey-cli.c b/src/valkey-cli.c
new file mode 100644
index 000000000..d2fa53703
--- /dev/null
+++ b/src/valkey-cli.c
@@ -0,0 +1,9749 @@
+/* Server CLI (command line interface)
+ *
+ * Copyright (c) 2009-2012, Redis Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "fmacros.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <time.h>
+#include <ctype.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <math.h>
+#include <termios.h>
+
+#include <hiredis.h>
+#ifdef USE_OPENSSL
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <hiredis_ssl.h>
+#endif
+#include <sdscompat.h> /* Use hiredis' sds compat header that maps sds calls to their hi_ variants */
+#include <sds.h>       /* use sds.h from hiredis, so that only one set of sds functions will be present in the binary */
+#include "dict.h"
+#include "adlist.h"
+#include "zmalloc.h"
+#include "linenoise.h"
+#include "anet.h"
+#include "ae.h"
+#include "connection.h"
+#include "cli_common.h"
+#include "mt19937-64.h"
+#include "cli_commands.h"
+
+#include "valkey_strtod.h"
+
+#define UNUSED(V) ((void)V)
+
+#define OUTPUT_STANDARD 0
+#define OUTPUT_RAW 1
+#define OUTPUT_CSV 2
+#define OUTPUT_JSON 3
+#define OUTPUT_QUOTED_JSON 4
+#define CLI_KEEPALIVE_INTERVAL 15   /* seconds */
+#define CLI_DEFAULT_PIPE_TIMEOUT 30 /* seconds */
+#define CLI_HISTFILE_ENV "REDISCLI_HISTFILE"
+#define CLI_HISTFILE_DEFAULT ".valkeycli_history"
+#define CLI_RCFILE_ENV "REDISCLI_RCFILE"
+#define CLI_RCFILE_DEFAULT ".valkeyclirc"
+#define CLI_AUTH_ENV "REDISCLI_AUTH"
+#define CLI_CLUSTER_YES_ENV "REDISCLI_CLUSTER_YES"
+
+#define CLUSTER_MANAGER_SLOTS 16384
+#define CLUSTER_MANAGER_PORT_INCR 10000 /* same as CLUSTER_PORT_INCR */
+#define CLUSTER_MANAGER_MIGRATE_TIMEOUT 60000
+#define CLUSTER_MANAGER_MIGRATE_PIPELINE 10
+#define CLUSTER_MANAGER_REBALANCE_THRESHOLD 2
+
+#define CLUSTER_MANAGER_INVALID_HOST_ARG                        \
+    "[ERR] Invalid arguments: you need to pass either a valid " \
+    "address (ie. 120.0.0.1:7000) or space separated IP "       \
+    "and port (ie. 120.0.0.1 7000)\n"
+#define CLUSTER_MANAGER_MODE() (config.cluster_manager_command.name != NULL)
+#define CLUSTER_MANAGER_PRIMARIES_COUNT(nodes, replicas) ((nodes) / ((replicas) + 1))
+#define CLUSTER_MANAGER_COMMAND(n, ...) (redisCommand((n)->context, __VA_ARGS__))
+
+#define CLUSTER_MANAGER_NODE_ARRAY_FREE(array) zfree((array)->alloc)
+
+#define CLUSTER_MANAGER_PRINT_REPLY_ERROR(n, err) \
+    clusterManagerLogErr("Node %s:%d replied with error:\n%s\n", (n)->ip, (n)->port, (err));
+
+#define clusterManagerLogInfo(...) clusterManagerLog(CLUSTER_MANAGER_LOG_LVL_INFO, __VA_ARGS__)
+
+#define clusterManagerLogErr(...) clusterManagerLog(CLUSTER_MANAGER_LOG_LVL_ERR, __VA_ARGS__)
+
+#define clusterManagerLogWarn(...) clusterManagerLog(CLUSTER_MANAGER_LOG_LVL_WARN, __VA_ARGS__)
+
+#define clusterManagerLogOk(...) clusterManagerLog(CLUSTER_MANAGER_LOG_LVL_SUCCESS, __VA_ARGS__)
+
+#define CLUSTER_MANAGER_FLAG_MYSELF 1 << 0
+#define CLUSTER_MANAGER_FLAG_REPLICA 1 << 1
+#define CLUSTER_MANAGER_FLAG_FRIEND 1 << 2
+#define CLUSTER_MANAGER_FLAG_NOADDR 1 << 3
+#define CLUSTER_MANAGER_FLAG_DISCONNECT 1 << 4
+#define CLUSTER_MANAGER_FLAG_FAIL 1 << 5
+
+#define CLUSTER_MANAGER_CMD_FLAG_FIX 1 << 0
+#define CLUSTER_MANAGER_CMD_FLAG_REPLICA 1 << 1
+#define CLUSTER_MANAGER_CMD_FLAG_YES 1 << 2
+#define CLUSTER_MANAGER_CMD_FLAG_AUTOWEIGHTS 1 << 3
+#define CLUSTER_MANAGER_CMD_FLAG_EMPTY_PRIMARY 1 << 4
+#define CLUSTER_MANAGER_CMD_FLAG_SIMULATE 1 << 5
+#define CLUSTER_MANAGER_CMD_FLAG_REPLACE 1 << 6
+#define CLUSTER_MANAGER_CMD_FLAG_COPY 1 << 7
+#define CLUSTER_MANAGER_CMD_FLAG_COLOR 1 << 8
+#define CLUSTER_MANAGER_CMD_FLAG_CHECK_OWNERS 1 << 9
+#define CLUSTER_MANAGER_CMD_FLAG_FIX_WITH_UNREACHABLE_PRIMARIES 1 << 10
+#define CLUSTER_MANAGER_CMD_FLAG_PRIMARIES_ONLY 1 << 11
+#define CLUSTER_MANAGER_CMD_FLAG_REPLICAS_ONLY 1 << 12
+
+#define CLUSTER_MANAGER_OPT_GETFRIENDS 1 << 0
+#define CLUSTER_MANAGER_OPT_COLD 1 << 1
+#define CLUSTER_MANAGER_OPT_UPDATE 1 << 2
+#define CLUSTER_MANAGER_OPT_QUIET 1 << 6
+#define CLUSTER_MANAGER_OPT_VERBOSE 1 << 7
+
+#define CLUSTER_MANAGER_LOG_LVL_INFO 1
+#define CLUSTER_MANAGER_LOG_LVL_WARN 2
+#define CLUSTER_MANAGER_LOG_LVL_ERR 3
+#define CLUSTER_MANAGER_LOG_LVL_SUCCESS 4
+
+#define CLUSTER_JOIN_CHECK_AFTER 20
+
+#define LOG_COLOR_BOLD "29;1m"
+#define LOG_COLOR_RED "31;1m"
+#define LOG_COLOR_GREEN "32;1m"
+#define LOG_COLOR_YELLOW "33;1m"
+#define LOG_COLOR_RESET "0m"
+
+/* cliConnect() flags. */
+#define CC_FORCE (1 << 0) /* Re-connect if already connected. */
+#define CC_QUIET (1 << 1) /* Don't log connecting errors. */
+
+/* DNS lookup */
+#define NET_IP_STR_LEN 46 /* INET6_ADDRSTRLEN is 46 */
+
+/* --latency-dist palettes. */
+int spectrum_palette_color_size = 19;
+int spectrum_palette_color[] = {0, 233, 234, 235, 237, 239, 241, 243, 245, 247,
+                                144, 143, 142, 184, 226, 214, 208, 202, 196};
+
+int spectrum_palette_mono_size = 13;
+int spectrum_palette_mono[] = {0, 233, 234, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253};
+
+/* The actual palette in use. */
+int *spectrum_palette;
+int spectrum_palette_size;
+
+static int orig_termios_saved = 0;
+static struct termios orig_termios; /* To restore terminal at exit.*/
+
+/* Dict Helpers */
+static uint64_t dictSdsHash(const void *key);
+static int dictSdsKeyCompare(const void *key1, const void *key2);
+static void dictSdsDestructor(void *val);
+static void dictListDestructor(void *val);
+
+/* Cluster Manager Command Info */
+typedef struct clusterManagerCommand {
+    char *name;
+    int argc;
+    char **argv;
+    sds stdin_arg; /* arg from stdin. (-X option) */
+    int flags;
+    int replicas;
+    char *from;
+    char *to;
+    char **weight;
+    int weight_argc;
+    char *primary_id;
+    int slots;
+    int timeout;
+    int pipeline;
+    float threshold;
+    char *backup_dir;
+    char *from_user;
+    char *from_pass;
+    int from_askpass;
+} clusterManagerCommand;
+
+static int createClusterManagerCommand(char *cmdname, int argc, char **argv);
+
+
+static redisContext *context;
+static struct config {
+    cliConnInfo conn_info;
+    struct timeval connect_timeout;
+    char *hostsocket;
+    int tls;
+    cliSSLconfig sslconfig;
+    long repeat;
+    long interval;
+    int dbnum; /* db num currently selected */
+    int interactive;
+    int shutdown;
+    int monitor_mode;
+    int pubsub_mode;
+    int pubsub_unsharded_count; /* channels and patterns */
+    int pubsub_sharded_count;   /* shard channels */
+    int blocking_state_aborted; /* used to abort monitor_mode and pubsub_mode. */
+    int latency_mode;
+    int latency_dist_mode;
+    int latency_history;
+    int lru_test_mode;
+    long long lru_test_sample_size;
+    int cluster_mode;
+    int cluster_reissue_command;
+    int cluster_send_asking;
+    int replica_mode;
+    int pipe_mode;
+    int pipe_timeout;
+    int getrdb_mode;
+    int get_functions_rdb_mode;
+    int stat_mode;
+    int scan_mode;
+    int count;
+    int intrinsic_latency_mode;
+    int intrinsic_latency_duration;
+    sds pattern;
+    char *rdb_filename;
+    int bigkeys;
+    int memkeys;
+    unsigned memkeys_samples;
+    int hotkeys;
+    int stdin_lastarg;    /* get last arg from stdin. (-x option) */
+    int stdin_tag_arg;    /* get <tag> arg from stdin. (-X option) */
+    char *stdin_tag_name; /* Placeholder(tag name) for user input. */
+    int askpass;
+    int quoted_input; /* Force input args to be treated as quoted strings */
+    int output;       /* output mode, see OUTPUT_* defines */
+    int push_output;  /* Should we display spontaneous PUSH replies */
+    sds mb_delim;
+    sds cmd_delim;
+    char prompt[128];
+    char *eval;
+    int eval_ldb;
+    int eval_ldb_sync;      /* Ask for synchronous mode of the Lua debugger. */
+    int eval_ldb_end;       /* Lua debugging session ended. */
+    int enable_ldb_on_eval; /* Handle manual SCRIPT DEBUG + EVAL commands. */
+    int last_cmd_type;
+    redisReply *last_reply;
+    int verbose;
+    int set_errcode;
+    clusterManagerCommand cluster_manager_command;
+    int no_auth_warning;
+    int resp2;         /* value of 1: specified explicitly with option -2 */
+    int resp3;         /* value of 1: specified explicitly, value of 2: implicit like --json option */
+    int current_resp3; /* 1 if we have RESP3 right now in the current connection. */
+    int in_multi;
+    int pre_multi_dbnum;
+    char *server_version;
+    char *test_hint;
+    char *test_hint_file;
+    int prefer_ipv4; /* Prefer IPv4 over IPv6 on DNS lookup. */
+    int prefer_ipv6; /* Prefer IPv6 over IPv4 on DNS lookup. */
+} config;
+
+/* User preferences. */
+static struct pref {
+    int hints;
+} pref;
+
+static volatile sig_atomic_t force_cancel_loop = 0;
+static void usage(int err);
+static void replicaMode(int send_sync);
+static int cliConnect(int flags);
+
+static char *getInfoField(char *info, char *field);
+static long getLongInfoField(char *info, char *field);
+
+/*------------------------------------------------------------------------------
+ * Utility functions
+ *--------------------------------------------------------------------------- */
+size_t valkey_strlcpy(char *dst, const char *src, size_t dsize);
+
+static void cliPushHandler(void *, void *);
+
+uint16_t crc16(const char *buf, int len);
+
+static long long ustime(void) {
+    struct timeval tv;
+    long long ust;
+
+    gettimeofday(&tv, NULL);
+    ust = ((long long)tv.tv_sec) * 1000000;
+    ust += tv.tv_usec;
+    return ust;
+}
+
+static long long mstime(void) {
+    return ustime() / 1000;
+}
+
+static void cliRefreshPrompt(void) {
+    if (config.eval_ldb) return;
+
+    sds prompt = sdsempty();
+    if (config.hostsocket != NULL) {
+        prompt = sdscatfmt(prompt, "valkey %s", config.hostsocket);
+    } else {
+        char addr[256];
+        formatAddr(addr, sizeof(addr), config.conn_info.hostip, config.conn_info.hostport);
+        prompt = sdscatlen(prompt, addr, strlen(addr));
+    }
+
+    /* Add [dbnum] if needed */
+    if (config.dbnum != 0) prompt = sdscatfmt(prompt, "[%i]", config.dbnum);
+
+    /* Add TX if in transaction state*/
+    if (config.in_multi) prompt = sdscatlen(prompt, "(TX)", 4);
+
+    if (config.pubsub_mode) prompt = sdscatfmt(prompt, "(subscribed mode)");
+
+    /* Copy the prompt in the static buffer. */
+    prompt = sdscatlen(prompt, "> ", 2);
+    snprintf(config.prompt, sizeof(config.prompt), "%s", prompt);
+    sdsfree(prompt);
+}
+
+/* Return the name of the dotfile for the specified 'dotfilename'.
+ * Normally it just concatenates user $HOME to the file specified
+ * in 'dotfilename'. However if the environment variable 'envoverride'
+ * is set, its value is taken as the path.
+ *
+ * The function returns NULL (if the file is /dev/null or cannot be
+ * obtained for some error), or an SDS string that must be freed by
+ * the user. */
+static sds getDotfilePath(char *envoverride, char *dotfilename) {
+    char *path = NULL;
+    sds dotPath = NULL;
+
+    /* Check the env for a dotfile override. */
+    path = getenv(envoverride);
+    if (path != NULL && *path != '\0') {
+        if (!strcmp("/dev/null", path)) {
+            return NULL;
+        }
+
+        /* If the env is set, return it. */
+        dotPath = sdsnew(path);
+    } else {
+        char *home = getenv("HOME");
+        if (home != NULL && *home != '\0') {
+            /* If no override is set use $HOME/<dotfilename>. */
+            dotPath = sdscatprintf(sdsempty(), "%s/%s", home, dotfilename);
+        }
+    }
+    return dotPath;
+}
+
+static uint64_t dictSdsHash(const void *key) {
+    return dictGenHashFunction((unsigned char *)key, sdslen((char *)key));
+}
+
+static int dictSdsKeyCompare(const void *key1, const void *key2) {
+    int l1, l2;
+    l1 = sdslen((sds)key1);
+    l2 = sdslen((sds)key2);
+    if (l1 != l2) return 0;
+    return memcmp(key1, key2, l1) == 0;
+}
+
+static void dictSdsDestructor(void *val) {
+    sdsfree(val);
+}
+
+void dictListDestructor(void *val) {
+    listRelease((list *)val);
+}
+
+/*------------------------------------------------------------------------------
+ * Help functions
+ *--------------------------------------------------------------------------- */
+
+#define CLI_HELP_COMMAND 1
+#define CLI_HELP_GROUP 2
+
+typedef struct {
+    int type;
+    int argc;
+    sds *argv;
+    sds full;
+
+    /* Only used for help on commands */
+    struct commandDocs docs;
+} helpEntry;
+
+static helpEntry *helpEntries = NULL;
+static int helpEntriesLen = 0;
+
+/* For backwards compatibility with pre-7.0 servers.
+ * cliLegacyInitHelp() sets up the helpEntries array with the command and group
+ * names from the commands.c file. However the server instance we are connecting
+ * to may support more commands, so this function integrates the previous
+ * entries with additional entries obtained using the COMMAND command
+ * available in recent versions of the server. */
+static void cliLegacyIntegrateHelp(void) {
+    if (cliConnect(CC_QUIET) == REDIS_ERR) return;
+
+    redisReply *reply = redisCommand(context, "COMMAND");
+    if (reply == NULL || reply->type != REDIS_REPLY_ARRAY) return;
+
+    /* Scan the array reported by COMMAND and fill only the entries that
+     * don't already match what we have. */
+    for (size_t j = 0; j < reply->elements; j++) {
+        redisReply *entry = reply->element[j];
+        if (entry->type != REDIS_REPLY_ARRAY || entry->elements < 4 || entry->element[0]->type != REDIS_REPLY_STRING ||
+            entry->element[1]->type != REDIS_REPLY_INTEGER || entry->element[3]->type != REDIS_REPLY_INTEGER)
+            return;
+        char *cmdname = entry->element[0]->str;
+        int i;
+
+        for (i = 0; i < helpEntriesLen; i++) {
+            helpEntry *he = helpEntries + i;
+            if (!strcasecmp(he->argv[0], cmdname)) break;
+        }
+        if (i != helpEntriesLen) continue;
+
+        helpEntriesLen++;
+        helpEntries = zrealloc(helpEntries, sizeof(helpEntry) * helpEntriesLen);
+        helpEntry *new = helpEntries + (helpEntriesLen - 1);
+
+        new->argc = 1;
+        new->argv = zmalloc(sizeof(sds));
+        new->argv[0] = sdsnew(cmdname);
+        new->full = new->argv[0];
+        new->type = CLI_HELP_COMMAND;
+        sdstoupper(new->argv[0]);
+
+        new->docs.name = new->argv[0];
+        new->docs.args = NULL;
+        new->docs.numargs = 0;
+        new->docs.params = sdsempty();
+        int args = llabs(entry->element[1]->integer);
+        args--; /* Remove the command name itself. */
+        if (entry->element[3]->integer == 1) {
+            new->docs.params = sdscat(new->docs.params, "key ");
+            args--;
+        }
+        while (args-- > 0) new->docs.params = sdscat(new->docs.params, "arg ");
+        if (entry->element[1]->integer < 0) new->docs.params = sdscat(new->docs.params, "...options...");
+        new->docs.summary = "Help not available";
+        new->docs.since = "Not known";
+        new->docs.group = "generic";
+    }
+    freeReplyObject(reply);
+}
+
+/* Concatenate a string to an sds string, but if it's empty substitute double quote marks. */
+static sds sdscat_orempty(sds params, const char *value) {
+    if (value[0] == '\0') {
+        return sdscat(params, "\"\"");
+    }
+    return sdscat(params, value);
+}
+
+static sds makeHint(char **inputargv, int inputargc, int cmdlen, struct commandDocs docs);
+
+static void cliAddCommandDocArg(cliCommandArg *cmdArg, redisReply *argMap);
+
+static void cliMakeCommandDocArgs(redisReply *arguments, cliCommandArg *result) {
+    for (size_t j = 0; j < arguments->elements; j++) {
+        cliAddCommandDocArg(&result[j], arguments->element[j]);
+    }
+}
+
+static void cliAddCommandDocArg(cliCommandArg *cmdArg, redisReply *argMap) {
+    if (argMap->type != REDIS_REPLY_MAP && argMap->type != REDIS_REPLY_ARRAY) {
+        return;
+    }
+
+    for (size_t i = 0; i < argMap->elements; i += 2) {
+        assert(argMap->element[i]->type == REDIS_REPLY_STRING);
+        char *key = argMap->element[i]->str;
+        if (!strcmp(key, "name")) {
+            assert(argMap->element[i + 1]->type == REDIS_REPLY_STRING);
+            cmdArg->name = sdsnew(argMap->element[i + 1]->str);
+        } else if (!strcmp(key, "display_text")) {
+            assert(argMap->element[i + 1]->type == REDIS_REPLY_STRING);
+            cmdArg->display_text = sdsnew(argMap->element[i + 1]->str);
+        } else if (!strcmp(key, "token")) {
+            assert(argMap->element[i + 1]->type == REDIS_REPLY_STRING);
+            cmdArg->token = sdsnew(argMap->element[i + 1]->str);
+        } else if (!strcmp(key, "type")) {
+            assert(argMap->element[i + 1]->type == REDIS_REPLY_STRING);
+            char *type = argMap->element[i + 1]->str;
+            if (!strcmp(type, "string")) {
+                cmdArg->type = ARG_TYPE_STRING;
+            } else if (!strcmp(type, "integer")) {
+                cmdArg->type = ARG_TYPE_INTEGER;
+            } else if (!strcmp(type, "double")) {
+                cmdArg->type = ARG_TYPE_DOUBLE;
+            } else if (!strcmp(type, "key")) {
+                cmdArg->type = ARG_TYPE_KEY;
+            } else if (!strcmp(type, "pattern")) {
+                cmdArg->type = ARG_TYPE_PATTERN;
+            } else if (!strcmp(type, "unix-time")) {
+                cmdArg->type = ARG_TYPE_UNIX_TIME;
+            } else if (!strcmp(type, "pure-token")) {
+                cmdArg->type = ARG_TYPE_PURE_TOKEN;
+            } else if (!strcmp(type, "oneof")) {
+                cmdArg->type = ARG_TYPE_ONEOF;
+            } else if (!strcmp(type, "block")) {
+                cmdArg->type = ARG_TYPE_BLOCK;
+            }
+        } else if (!strcmp(key, "arguments")) {
+            redisReply *arguments = argMap->element[i + 1];
+            cmdArg->subargs = zcalloc(arguments->elements * sizeof(cliCommandArg));
+            cmdArg->numsubargs = arguments->elements;
+            cliMakeCommandDocArgs(arguments, cmdArg->subargs);
+        } else if (!strcmp(key, "flags")) {
+            redisReply *flags = argMap->element[i + 1];
+            assert(flags->type == REDIS_REPLY_SET || flags->type == REDIS_REPLY_ARRAY);
+            for (size_t j = 0; j < flags->elements; j++) {
+                assert(flags->element[j]->type == REDIS_REPLY_STATUS);
+                char *flag = flags->element[j]->str;
+                if (!strcmp(flag, "optional")) {
+                    cmdArg->flags |= CMD_ARG_OPTIONAL;
+                } else if (!strcmp(flag, "multiple")) {
+                    cmdArg->flags |= CMD_ARG_MULTIPLE;
+                } else if (!strcmp(flag, "multiple_token")) {
+                    cmdArg->flags |= CMD_ARG_MULTIPLE_TOKEN;
+                }
+            }
+        }
+    }
+}
+
+/* Fill in the fields of a help entry for the command/subcommand name. */
+static void cliFillInCommandHelpEntry(helpEntry *help, char *cmdname, char *subcommandname) {
+    help->argc = subcommandname ? 2 : 1;
+    help->argv = zmalloc(sizeof(sds) * help->argc);
+    help->argv[0] = sdsnew(cmdname);
+    sdstoupper(help->argv[0]);
+    if (subcommandname) {
+        /* Subcommand name may be two words separated by a pipe character. */
+        char *pipe = strchr(subcommandname, '|');
+        if (pipe != NULL) {
+            help->argv[1] = sdsnew(pipe + 1);
+        } else {
+            help->argv[1] = sdsnew(subcommandname);
+        }
+        sdstoupper(help->argv[1]);
+    }
+    sds fullname = sdsnew(help->argv[0]);
+    if (subcommandname) {
+        fullname = sdscat(fullname, " ");
+        fullname = sdscat(fullname, help->argv[1]);
+    }
+    help->full = fullname;
+    help->type = CLI_HELP_COMMAND;
+
+    help->docs.name = help->full;
+    help->docs.params = NULL;
+    help->docs.args = NULL;
+    help->docs.numargs = 0;
+    help->docs.since = NULL;
+}
+
+/* Initialize a command help entry for the command/subcommand described in 'specs'.
+ * 'next' points to the next help entry to be filled in.
+ * 'groups' is a set of command group names to be filled in.
+ * Returns a pointer to the next available position in the help entries table.
+ * If the command has subcommands, this is called recursively for the subcommands.
+ */
+static helpEntry *
+cliInitCommandHelpEntry(char *cmdname, char *subcommandname, helpEntry *next, redisReply *specs, dict *groups) {
+    helpEntry *help = next++;
+    cliFillInCommandHelpEntry(help, cmdname, subcommandname);
+
+    assert(specs->type == REDIS_REPLY_MAP || specs->type == REDIS_REPLY_ARRAY);
+    for (size_t j = 0; j < specs->elements; j += 2) {
+        assert(specs->element[j]->type == REDIS_REPLY_STRING);
+        char *key = specs->element[j]->str;
+        if (!strcmp(key, "summary")) {
+            redisReply *reply = specs->element[j + 1];
+            assert(reply->type == REDIS_REPLY_STRING);
+            help->docs.summary = sdsnew(reply->str);
+        } else if (!strcmp(key, "since")) {
+            redisReply *reply = specs->element[j + 1];
+            assert(reply->type == REDIS_REPLY_STRING);
+            help->docs.since = sdsnew(reply->str);
+        } else if (!strcmp(key, "group")) {
+            redisReply *reply = specs->element[j + 1];
+            assert(reply->type == REDIS_REPLY_STRING);
+            help->docs.group = sdsnew(reply->str);
+            sds group = sdsdup(help->docs.group);
+            if (dictAdd(groups, group, NULL) != DICT_OK) {
+                sdsfree(group);
+            }
+        } else if (!strcmp(key, "arguments")) {
+            redisReply *arguments = specs->element[j + 1];
+            assert(arguments->type == REDIS_REPLY_ARRAY);
+            help->docs.args = zcalloc(arguments->elements * sizeof(cliCommandArg));
+            help->docs.numargs = arguments->elements;
+            cliMakeCommandDocArgs(arguments, help->docs.args);
+            help->docs.params = makeHint(NULL, 0, 0, help->docs);
+        } else if (!strcmp(key, "subcommands")) {
+            redisReply *subcommands = specs->element[j + 1];
+            assert(subcommands->type == REDIS_REPLY_MAP || subcommands->type == REDIS_REPLY_ARRAY);
+            for (size_t i = 0; i < subcommands->elements; i += 2) {
+                assert(subcommands->element[i]->type == REDIS_REPLY_STRING);
+                char *subcommandname = subcommands->element[i]->str;
+                redisReply *subcommand = subcommands->element[i + 1];
+                assert(subcommand->type == REDIS_REPLY_MAP || subcommand->type == REDIS_REPLY_ARRAY);
+                next = cliInitCommandHelpEntry(cmdname, subcommandname, next, subcommand, groups);
+            }
+        }
+    }
+    return next;
+}
+
+/* Returns the total number of commands and subcommands in the command docs table. */
+static size_t cliCountCommands(redisReply *commandTable) {
+    size_t numCommands = commandTable->elements / 2;
+
+    /* The command docs table maps command names to a map of their specs. */
+    for (size_t i = 0; i < commandTable->elements; i += 2) {
+        assert(commandTable->element[i]->type == REDIS_REPLY_STRING); /* Command name. */
+        assert(commandTable->element[i + 1]->type == REDIS_REPLY_MAP ||
+               commandTable->element[i + 1]->type == REDIS_REPLY_ARRAY);
+        redisReply *map = commandTable->element[i + 1];
+        for (size_t j = 0; j < map->elements; j += 2) {
+            assert(map->element[j]->type == REDIS_REPLY_STRING);
+            char *key = map->element[j]->str;
+            if (!strcmp(key, "subcommands")) {
+                redisReply *subcommands = map->element[j + 1];
+                assert(subcommands->type == REDIS_REPLY_MAP || subcommands->type == REDIS_REPLY_ARRAY);
+                numCommands += subcommands->elements / 2;
+            }
+        }
+    }
+    return numCommands;
+}
+
+/* Comparator for sorting help table entries. */
+int helpEntryCompare(const void *entry1, const void *entry2) {
+    helpEntry *i1 = (helpEntry *)entry1;
+    helpEntry *i2 = (helpEntry *)entry2;
+    return strcmp(i1->full, i2->full);
+}
+
+/* Initializes command help entries for command groups.
+ * Called after the command help entries have already been filled in.
+ * Extends the help table with new entries for the command groups.
+ */
+void cliInitGroupHelpEntries(dict *groups) {
+    dictIterator *iter = dictGetIterator(groups);
+    dictEntry *entry;
+    helpEntry tmp;
+
+    int numGroups = dictSize(groups);
+    int pos = helpEntriesLen;
+    helpEntriesLen += numGroups;
+    helpEntries = zrealloc(helpEntries, sizeof(helpEntry) * helpEntriesLen);
+
+    for (entry = dictNext(iter); entry != NULL; entry = dictNext(iter)) {
+        tmp.argc = 1;
+        tmp.argv = zmalloc(sizeof(sds));
+        tmp.argv[0] = sdscatprintf(sdsempty(), "@%s", (char *)dictGetKey(entry));
+        tmp.full = tmp.argv[0];
+        tmp.type = CLI_HELP_GROUP;
+        tmp.docs.name = NULL;
+        tmp.docs.params = NULL;
+        tmp.docs.args = NULL;
+        tmp.docs.numargs = 0;
+        tmp.docs.summary = NULL;
+        tmp.docs.since = NULL;
+        tmp.docs.group = NULL;
+        helpEntries[pos++] = tmp;
+    }
+    dictReleaseIterator(iter);
+}
+
+/* Initializes help entries for all commands in the COMMAND DOCS reply. */
+void cliInitCommandHelpEntries(redisReply *commandTable, dict *groups) {
+    helpEntry *next = helpEntries;
+    for (size_t i = 0; i < commandTable->elements; i += 2) {
+        assert(commandTable->element[i]->type == REDIS_REPLY_STRING);
+        char *cmdname = commandTable->element[i]->str;
+
+        assert(commandTable->element[i + 1]->type == REDIS_REPLY_MAP ||
+               commandTable->element[i + 1]->type == REDIS_REPLY_ARRAY);
+        redisReply *cmdspecs = commandTable->element[i + 1];
+        next = cliInitCommandHelpEntry(cmdname, NULL, next, cmdspecs, groups);
+    }
+}
+
+/* Does the server version support a command/argument only available "since" some version?
+ * Returns 1 when supported, or 0 when the "since" version is newer than "version". */
+static int versionIsSupported(sds version, sds since) {
+    int i;
+    char *versionPos = version;
+    char *sincePos = since;
+    if (!since) {
+        return 1;
+    }
+
+    for (i = 0; i != 3; i++) {
+        int versionPart = atoi(versionPos);
+        int sincePart = atoi(sincePos);
+        if (versionPart > sincePart) {
+            return 1;
+        } else if (sincePart > versionPart) {
+            return 0;
+        }
+        versionPos = strchr(versionPos, '.');
+        sincePos = strchr(sincePos, '.');
+
+        /* If we finished to parse both `version` and `since`, it means they are equal */
+        if (!versionPos && !sincePos) return 1;
+
+        /* Different number of digits considered as not supported */
+        if (!versionPos || !sincePos) return 0;
+
+        versionPos++;
+        sincePos++;
+    }
+    return 0;
+}
+
+static void removeUnsupportedArgs(struct cliCommandArg *args, int *numargs, sds version) {
+    int i = 0, j;
+    while (i != *numargs) {
+        if (versionIsSupported(version, args[i].since)) {
+            if (args[i].subargs) {
+                removeUnsupportedArgs(args[i].subargs, &args[i].numsubargs, version);
+            }
+            i++;
+            continue;
+        }
+        for (j = i; j != *numargs - 1; j++) {
+            args[j] = args[j + 1];
+        }
+        (*numargs)--;
+    }
+}
+
+static helpEntry *cliLegacyInitCommandHelpEntry(char *cmdname,
+                                                char *subcommandname,
+                                                helpEntry *next,
+                                                struct commandDocs *command,
+                                                dict *groups,
+                                                sds version) {
+    helpEntry *help = next++;
+    cliFillInCommandHelpEntry(help, cmdname, subcommandname);
+
+    help->docs.summary = sdsnew(command->summary);
+    help->docs.since = sdsnew(command->since);
+    help->docs.group = sdsnew(command->group);
+    sds group = sdsdup(help->docs.group);
+    if (dictAdd(groups, group, NULL) != DICT_OK) {
+        sdsfree(group);
+    }
+
+    if (command->args != NULL) {
+        help->docs.args = command->args;
+        help->docs.numargs = command->numargs;
+        if (version) removeUnsupportedArgs(help->docs.args, &help->docs.numargs, version);
+        help->docs.params = makeHint(NULL, 0, 0, help->docs);
+    }
+
+    if (command->subcommands != NULL) {
+        for (size_t i = 0; command->subcommands[i].name != NULL; i++) {
+            if (!version || versionIsSupported(version, command->subcommands[i].since)) {
+                char *subcommandname = command->subcommands[i].name;
+                next = cliLegacyInitCommandHelpEntry(cmdname, subcommandname, next, &command->subcommands[i], groups,
+                                                     version);
+            }
+        }
+    }
+    return next;
+}
+
+int cliLegacyInitCommandHelpEntries(struct commandDocs *commands, dict *groups, sds version) {
+    helpEntry *next = helpEntries;
+    for (size_t i = 0; commands[i].name != NULL; i++) {
+        if (!version || versionIsSupported(version, commands[i].since)) {
+            next = cliLegacyInitCommandHelpEntry(commands[i].name, NULL, next, &commands[i], groups, version);
+        }
+    }
+    return next - helpEntries;
+}
+
+/* Returns the total number of commands and subcommands in the command docs table,
+ * filtered by server version (if provided).
+ */
+static size_t cliLegacyCountCommands(struct commandDocs *commands, sds version) {
+    int numCommands = 0;
+    for (size_t i = 0; commands[i].name != NULL; i++) {
+        if (version && !versionIsSupported(version, commands[i].since)) {
+            continue;
+        }
+        numCommands++;
+        if (commands[i].subcommands != NULL) {
+            numCommands += cliLegacyCountCommands(commands[i].subcommands, version);
+        }
+    }
+    return numCommands;
+}
+
+/* Gets the server version string by calling INFO SERVER.
+ * Stores the result in config.server_version.
+ * When not connected, or not possible, returns NULL. */
+static sds cliGetServerVersion(void) {
+    static const char *key = "\nvalkey_version:";
+    redisReply *serverInfo = NULL;
+    char *pos;
+
+    if (config.server_version != NULL) {
+        return config.server_version;
+    }
+
+    if (!context) return NULL;
+    serverInfo = redisCommand(context, "INFO SERVER");
+    if (serverInfo == NULL || serverInfo->type == REDIS_REPLY_ERROR) {
+        freeReplyObject(serverInfo);
+        return sdsempty();
+    }
+
+    assert(serverInfo->type == REDIS_REPLY_STRING || serverInfo->type == REDIS_REPLY_VERB);
+    sds info = serverInfo->str;
+
+    /* Finds the first appearance of "valkey_version" in the INFO SERVER reply. */
+    pos = strstr(info, key);
+    if (pos) {
+        pos += strlen(key);
+        char *end = strchr(pos, '\r');
+        if (end) {
+            sds version = sdsnewlen(pos, end - pos);
+            freeReplyObject(serverInfo);
+            config.server_version = version;
+            return version;
+        }
+    }
+    freeReplyObject(serverInfo);
+    return NULL;
+}
+
+static void cliLegacyInitHelp(dict *groups) {
+    sds serverVersion = cliGetServerVersion();
+
+    /* Scan the commandDocs array and fill in the entries */
+    helpEntriesLen = cliLegacyCountCommands(serverCommandTable, serverVersion);
+    helpEntries = zmalloc(sizeof(helpEntry) * helpEntriesLen);
+
+    helpEntriesLen = cliLegacyInitCommandHelpEntries(serverCommandTable, groups, serverVersion);
+    cliInitGroupHelpEntries(groups);
+
+    qsort(helpEntries, helpEntriesLen, sizeof(helpEntry), helpEntryCompare);
+    dictRelease(groups);
+}
+
+/* cliInitHelp() sets up the helpEntries array with the command and group
+ * names and command descriptions obtained using the COMMAND DOCS command.
+ */
+static void cliInitHelp(void) {
+    /* Dict type for a set of strings, used to collect names of command groups. */
+    dictType groupsdt = {
+        dictSdsHash,       /* hash function */
+        NULL,              /* key dup */
+        dictSdsKeyCompare, /* key compare */
+        dictSdsDestructor, /* key destructor */
+        NULL,              /* val destructor */
+        NULL               /* allow to expand */
+    };
+    redisReply *commandTable;
+    dict *groups;
+
+    if (cliConnect(CC_QUIET) == REDIS_ERR) {
+        /* Can not connect to the server, but we still want to provide
+         * help, generate it only from the static cli_commands.c data instead. */
+        groups = dictCreate(&groupsdt);
+        cliLegacyInitHelp(groups);
+        return;
+    }
+    commandTable = redisCommand(context, "COMMAND DOCS");
+    if (commandTable == NULL || commandTable->type == REDIS_REPLY_ERROR) {
+        /* New COMMAND DOCS subcommand not supported - generate help from
+         * static cli_commands.c data instead. */
+        freeReplyObject(commandTable);
+
+        groups = dictCreate(&groupsdt);
+        cliLegacyInitHelp(groups);
+        cliLegacyIntegrateHelp();
+        return;
+    };
+    if (commandTable->type != REDIS_REPLY_MAP && commandTable->type != REDIS_REPLY_ARRAY) return;
+
+    /* Scan the array reported by COMMAND DOCS and fill in the entries */
+    helpEntriesLen = cliCountCommands(commandTable);
+    helpEntries = zmalloc(sizeof(helpEntry) * helpEntriesLen);
+
+    groups = dictCreate(&groupsdt);
+    cliInitCommandHelpEntries(commandTable, groups);
+    cliInitGroupHelpEntries(groups);
+
+    qsort(helpEntries, helpEntriesLen, sizeof(helpEntry), helpEntryCompare);
+    freeReplyObject(commandTable);
+    dictRelease(groups);
+}
+
+/* Output command help to stdout. */
+static void cliOutputCommandHelp(struct commandDocs *help, int group) {
+    printf("\r\n  \x1b[1m%s\x1b[0m \x1b[90m%s\x1b[0m\r\n", help->name, help->params);
+    printf("  \x1b[33msummary:\x1b[0m %s\r\n", help->summary);
+    if (help->since != NULL) {
+        printf("  \x1b[33msince:\x1b[0m %s\r\n", help->since);
+    }
+    if (group) {
+        printf("  \x1b[33mgroup:\x1b[0m %s\r\n", help->group);
+    }
+}
+
+/* Print generic help. */
+static void cliOutputGenericHelp(void) {
+    sds version = cliVersion();
+    printf("valkey-cli %s\n"
+           "To get help about Valkey commands type:\n"
+           "      \"help @<group>\" to get a list of commands in <group>\n"
+           "      \"help <command>\" for help on <command>\n"
+           "      \"help <tab>\" to get a list of possible help topics\n"
+           "      \"quit\" to exit\n"
+           "\n"
+           "To set valkey-cli preferences:\n"
+           "      \":set hints\" enable online hints\n"
+           "      \":set nohints\" disable online hints\n"
+           "Set your preferences in ~/.valkeyclirc\n",
+           version);
+    sdsfree(version);
+}
+
+/* Output all command help, filtering by group or command name. */
+static void cliOutputHelp(int argc, char **argv) {
+    int i, j;
+    char *group = NULL;
+    helpEntry *entry;
+    struct commandDocs *help;
+
+    if (argc == 0) {
+        cliOutputGenericHelp();
+        return;
+    } else if (argc > 0 && argv[0][0] == '@') {
+        group = argv[0] + 1;
+    }
+
+    if (helpEntries == NULL) {
+        /* Initialize the help using the results of the COMMAND command.
+         * In case we are using valkey-cli help XXX, we need to init it. */
+        cliInitHelp();
+    }
+
+    assert(argc > 0);
+    for (i = 0; i < helpEntriesLen; i++) {
+        entry = &helpEntries[i];
+        if (entry->type != CLI_HELP_COMMAND) continue;
+
+        help = &entry->docs;
+        if (group == NULL) {
+            /* Compare all arguments */
+            if (argc <= entry->argc) {
+                for (j = 0; j < argc; j++) {
+                    if (strcasecmp(argv[j], entry->argv[j]) != 0) break;
+                }
+                if (j == argc) {
+                    cliOutputCommandHelp(help, 1);
+                }
+            }
+        } else if (strcasecmp(group, help->group) == 0) {
+            cliOutputCommandHelp(help, 0);
+        }
+    }
+    printf("\r\n");
+}
+
+/* Linenoise completion callback. */
+static void completionCallback(const char *buf, linenoiseCompletions *lc) {
+    size_t startpos = 0;
+    int mask;
+    int i;
+    size_t matchlen;
+    sds tmp;
+
+    if (strncasecmp(buf, "help ", 5) == 0) {
+        startpos = 5;
+        while (isspace(buf[startpos])) startpos++;
+        mask = CLI_HELP_COMMAND | CLI_HELP_GROUP;
+    } else {
+        mask = CLI_HELP_COMMAND;
+    }
+
+    for (i = 0; i < helpEntriesLen; i++) {
+        if (!(helpEntries[i].type & mask)) continue;
+
+        matchlen = strlen(buf + startpos);
+        if (strncasecmp(buf + startpos, helpEntries[i].full, matchlen) == 0) {
+            tmp = sdsnewlen(buf, startpos);
+            tmp = sdscat(tmp, helpEntries[i].full);
+            linenoiseAddCompletion(lc, tmp);
+            sdsfree(tmp);
+        }
+    }
+}
+
+static sds addHintForArgument(sds hint, cliCommandArg *arg);
+
+/* Adds a separator character between words of a string under construction.
+ * A separator is added if the string length is greater than its previously-recorded
+ * length (*len), which is then updated, and it's not the last word to be added.
+ */
+static sds addSeparator(sds str, size_t *len, char *separator, int is_last) {
+    if (sdslen(str) > *len && !is_last) {
+        str = sdscat(str, separator);
+        *len = sdslen(str);
+    }
+    return str;
+}
+
+/* Recursively zeros the matched* fields of all arguments. */
+static void clearMatchedArgs(cliCommandArg *args, int numargs) {
+    for (int i = 0; i != numargs; ++i) {
+        args[i].matched = 0;
+        args[i].matched_token = 0;
+        args[i].matched_name = 0;
+        args[i].matched_all = 0;
+        if (args[i].subargs) {
+            clearMatchedArgs(args[i].subargs, args[i].numsubargs);
+        }
+    }
+}
+
+/* Builds a completion hint string describing the arguments, skipping parts already matched.
+ * Hints for all arguments are added to the input 'hint' parameter, separated by 'separator'.
+ */
+static sds addHintForArguments(sds hint, cliCommandArg *args, int numargs, char *separator) {
+    int i, j, incomplete;
+    size_t len = sdslen(hint);
+    for (i = 0; i < numargs; i++) {
+        if (!(args[i].flags & CMD_ARG_OPTIONAL)) {
+            hint = addHintForArgument(hint, &args[i]);
+            hint = addSeparator(hint, &len, separator, i == numargs - 1);
+            continue;
+        }
+
+        /* The rule is that successive "optional" arguments can appear in any order.
+         * But if they are followed by a required argument, no more of those optional arguments
+         * can appear after that.
+         *
+         * This code handles all successive optional args together. This lets us show the
+         * completion of the currently-incomplete optional arg first, if there is one.
+         */
+        for (j = i, incomplete = -1; j < numargs; j++) {
+            if (!(args[j].flags & CMD_ARG_OPTIONAL)) break;
+            if (args[j].matched != 0 && args[j].matched_all == 0) {
+                /* User has started typing this arg; show its completion first. */
+                hint = addHintForArgument(hint, &args[j]);
+                hint = addSeparator(hint, &len, separator, i == numargs - 1);
+                incomplete = j;
+            }
+        }
+
+        /* If the following non-optional arg has not been matched, add hints for
+         * any remaining optional args in this group.
+         */
+        if (j == numargs || args[j].matched == 0) {
+            for (; i < j; i++) {
+                if (incomplete != i) {
+                    hint = addHintForArgument(hint, &args[i]);
+                    hint = addSeparator(hint, &len, separator, i == numargs - 1);
+                }
+            }
+        }
+
+        i = j - 1;
+    }
+    return hint;
+}
+
+/* Adds the "repeating" section of the hint string for a multiple-typed argument: [ABC def ...]
+ * The repeating part is a fixed unit; we don't filter matched elements from it.
+ */
+static sds addHintForRepeatedArgument(sds hint, cliCommandArg *arg) {
+    if (!(arg->flags & CMD_ARG_MULTIPLE)) {
+        return hint;
+    }
+
+    /* The repeating part is always shown at the end of the argument's hint,
+     * so we can safely clear its matched flags before printing it.
+     */
+    clearMatchedArgs(arg, 1);
+
+    if (hint[0] != '\0') {
+        hint = sdscat(hint, " ");
+    }
+    hint = sdscat(hint, "[");
+
+    if (arg->flags & CMD_ARG_MULTIPLE_TOKEN) {
+        hint = sdscat_orempty(hint, arg->token);
+        if (arg->type != ARG_TYPE_PURE_TOKEN) {
+            hint = sdscat(hint, " ");
+        }
+    }
+
+    switch (arg->type) {
+    case ARG_TYPE_ONEOF: hint = addHintForArguments(hint, arg->subargs, arg->numsubargs, "|"); break;
+
+    case ARG_TYPE_BLOCK: hint = addHintForArguments(hint, arg->subargs, arg->numsubargs, " "); break;
+
+    case ARG_TYPE_PURE_TOKEN: break;
+
+    default: hint = sdscat_orempty(hint, arg->display_text ? arg->display_text : arg->name); break;
+    }
+
+    hint = sdscat(hint, " ...]");
+    return hint;
+}
+
+/* Adds hint string for one argument, if not already matched. */
+static sds addHintForArgument(sds hint, cliCommandArg *arg) {
+    if (arg->matched_all) {
+        return hint;
+    }
+
+    /* Surround an optional arg with brackets, unless it's partially matched. */
+    if ((arg->flags & CMD_ARG_OPTIONAL) && !arg->matched) {
+        hint = sdscat(hint, "[");
+    }
+
+    /* Start with the token, if present and not matched. */
+    if (arg->token != NULL && !arg->matched_token) {
+        hint = sdscat_orempty(hint, arg->token);
+        if (arg->type != ARG_TYPE_PURE_TOKEN) {
+            hint = sdscat(hint, " ");
+        }
+    }
+
+    /* Add the body of the syntax string. */
+    switch (arg->type) {
+    case ARG_TYPE_ONEOF:
+        if (arg->matched == 0) {
+            hint = addHintForArguments(hint, arg->subargs, arg->numsubargs, "|");
+        } else {
+            int i;
+            for (i = 0; i < arg->numsubargs; i++) {
+                if (arg->subargs[i].matched != 0) {
+                    hint = addHintForArgument(hint, &arg->subargs[i]);
+                }
+            }
+        }
+        break;
+
+    case ARG_TYPE_BLOCK: hint = addHintForArguments(hint, arg->subargs, arg->numsubargs, " "); break;
+
+    case ARG_TYPE_PURE_TOKEN: break;
+
+    default:
+        if (!arg->matched_name) {
+            hint = sdscat_orempty(hint, arg->display_text ? arg->display_text : arg->name);
+        }
+        break;
+    }
+
+    hint = addHintForRepeatedArgument(hint, arg);
+
+    if ((arg->flags & CMD_ARG_OPTIONAL) && !arg->matched) {
+        hint = sdscat(hint, "]");
+    }
+
+    return hint;
+}
+
+static int matchArg(char **nextword, int numwords, cliCommandArg *arg);
+static int matchArgs(char **words, int numwords, cliCommandArg *args, int numargs);
+
+/* Tries to match the next words of the input against an argument. */
+static int matchNoTokenArg(char **nextword, int numwords, cliCommandArg *arg) {
+    int i;
+    switch (arg->type) {
+    case ARG_TYPE_BLOCK: {
+        arg->matched += matchArgs(nextword, numwords, arg->subargs, arg->numsubargs);
+
+        /* All the subargs must be matched for the block to match. */
+        arg->matched_all = 1;
+        for (i = 0; i < arg->numsubargs; i++) {
+            if (arg->subargs[i].matched_all == 0) {
+                arg->matched_all = 0;
+            }
+        }
+        break;
+    }
+    case ARG_TYPE_ONEOF: {
+        for (i = 0; i < arg->numsubargs; i++) {
+            if (matchArg(nextword, numwords, &arg->subargs[i])) {
+                arg->matched += arg->subargs[i].matched;
+                arg->matched_all = arg->subargs[i].matched_all;
+                break;
+            }
+        }
+        break;
+    }
+
+    case ARG_TYPE_INTEGER:
+    case ARG_TYPE_UNIX_TIME: {
+        long long value;
+        if (sscanf(*nextword, "%lld", &value) == 1) {
+            arg->matched += 1;
+            arg->matched_name = 1;
+            arg->matched_all = 1;
+        } else {
+            /* Matching failed due to incorrect arg type. */
+            arg->matched = 0;
+            arg->matched_name = 0;
+        }
+        break;
+    }
+
+    case ARG_TYPE_DOUBLE: {
+        double value;
+        if (sscanf(*nextword, "%lf", &value) == 1) {
+            arg->matched += 1;
+            arg->matched_name = 1;
+            arg->matched_all = 1;
+        } else {
+            /* Matching failed due to incorrect arg type. */
+            arg->matched = 0;
+            arg->matched_name = 0;
+        }
+        break;
+    }
+
+    default:
+        arg->matched += 1;
+        arg->matched_name = 1;
+        arg->matched_all = 1;
+        break;
+    }
+    return arg->matched;
+}
+
+/* Tries to match the next word of the input against a token literal. */
+static int matchToken(char **nextword, cliCommandArg *arg) {
+    if (strcasecmp(arg->token, nextword[0]) != 0) {
+        return 0;
+    }
+    arg->matched_token = 1;
+    arg->matched = 1;
+    return 1;
+}
+
+/* Tries to match the next words of the input against the next argument.
+ * If the arg is repeated ("multiple"), it will be matched only once.
+ * If the next input word(s) can't be matched, returns 0 for failure.
+ */
+static int matchArgOnce(char **nextword, int numwords, cliCommandArg *arg) {
+    /* First match the token, if present. */
+    if (arg->token != NULL) {
+        if (!matchToken(nextword, arg)) {
+            return 0;
+        }
+        if (arg->type == ARG_TYPE_PURE_TOKEN) {
+            arg->matched_all = 1;
+            return 1;
+        }
+        if (numwords == 1) {
+            return 1;
+        }
+        nextword++;
+        numwords--;
+    }
+
+    /* Then match the rest of the argument. */
+    if (!matchNoTokenArg(nextword, numwords, arg)) {
+        return 0;
+    }
+    return arg->matched;
+}
+
+/* Tries to match the next words of the input against the next argument.
+ * If the arg is repeated ("multiple"), it will be matched as many times as possible.
+ */
+static int matchArg(char **nextword, int numwords, cliCommandArg *arg) {
+    int matchedWords = 0;
+    int matchedOnce = matchArgOnce(nextword, numwords, arg);
+    if (!(arg->flags & CMD_ARG_MULTIPLE)) {
+        return matchedOnce;
+    }
+
+    /* Found one match; now match a "multiple" argument as many times as possible. */
+    matchedWords += matchedOnce;
+    while (arg->matched_all && matchedWords < numwords) {
+        clearMatchedArgs(arg, 1);
+        if (arg->token != NULL && !(arg->flags & CMD_ARG_MULTIPLE_TOKEN)) {
+            /* The token only appears the first time; the rest of the times,
+             * pretend we saw it so we don't hint it.
+             */
+            matchedOnce = matchNoTokenArg(nextword + matchedWords, numwords - matchedWords, arg);
+            if (arg->matched) {
+                arg->matched_token = 1;
+            }
+        } else {
+            matchedOnce = matchArgOnce(nextword + matchedWords, numwords - matchedWords, arg);
+        }
+        matchedWords += matchedOnce;
+    }
+    arg->matched_all = 0; /* Because more repetitions are still possible. */
+    return matchedWords;
+}
+
+/* Tries to match the next words of the input against
+ * any one of a consecutive set of optional arguments.
+ */
+static int matchOneOptionalArg(char **words, int numwords, cliCommandArg *args, int numargs, int *matchedarg) {
+    for (int nextword = 0, nextarg = 0; nextword != numwords && nextarg != numargs; ++nextarg) {
+        if (args[nextarg].matched) {
+            /* Already matched this arg. */
+            continue;
+        }
+
+        int matchedWords = matchArg(&words[nextword], numwords - nextword, &args[nextarg]);
+        if (matchedWords != 0) {
+            *matchedarg = nextarg;
+            return matchedWords;
+        }
+    }
+    return 0;
+}
+
+/* Matches as many input words as possible against a set of consecutive optional arguments. */
+static int matchOptionalArgs(char **words, int numwords, cliCommandArg *args, int numargs) {
+    int nextword = 0;
+    int matchedarg = -1, lastmatchedarg = -1;
+    while (nextword != numwords) {
+        int matchedWords = matchOneOptionalArg(&words[nextword], numwords - nextword, args, numargs, &matchedarg);
+        if (matchedWords == 0) {
+            break;
+        }
+        /* Successfully matched an optional arg; mark any previous match as completed
+         * so it won't be partially hinted.
+         */
+        if (lastmatchedarg != -1) {
+            args[lastmatchedarg].matched_all = 1;
+        }
+        lastmatchedarg = matchedarg;
+        nextword += matchedWords;
+    }
+    return nextword;
+}
+
+/* Matches as many input words as possible against command arguments. */
+static int matchArgs(char **words, int numwords, cliCommandArg *args, int numargs) {
+    int nextword, nextarg, matchedWords;
+    for (nextword = 0, nextarg = 0; nextword != numwords && nextarg != numargs; ++nextarg) {
+        /* Optional args can occur in any order. Collect a range of consecutive optional args
+         * and try to match them as a group against the next input words.
+         */
+        if (args[nextarg].flags & CMD_ARG_OPTIONAL) {
+            int lastoptional;
+            for (lastoptional = nextarg; lastoptional < numargs; lastoptional++) {
+                if (!(args[lastoptional].flags & CMD_ARG_OPTIONAL)) break;
+            }
+            matchedWords =
+                matchOptionalArgs(&words[nextword], numwords - nextword, &args[nextarg], lastoptional - nextarg);
+            nextarg = lastoptional - 1;
+        } else {
+            matchedWords = matchArg(&words[nextword], numwords - nextword, &args[nextarg]);
+            if (matchedWords == 0) {
+                /* Couldn't match a required word - matching fails! */
+                return 0;
+            }
+        }
+
+        nextword += matchedWords;
+    }
+    return nextword;
+}
+
+/* Compute the linenoise hint for the input prefix in inputargv/inputargc.
+ * cmdlen is the number of words from the start of the input that make up the command.
+ * If docs.args exists, dynamically creates a hint string by matching the arg specs
+ * against the input words.
+ */
+static sds makeHint(char **inputargv, int inputargc, int cmdlen, struct commandDocs docs) {
+    sds hint;
+
+    if (docs.args) {
+        /* Remove arguments from the returned hint to show only the
+         * ones the user did not yet type. */
+        clearMatchedArgs(docs.args, docs.numargs);
+        hint = sdsempty();
+        int matchedWords = 0;
+        if (inputargv && inputargc)
+            matchedWords = matchArgs(inputargv + cmdlen, inputargc - cmdlen, docs.args, docs.numargs);
+        if (matchedWords == inputargc - cmdlen) {
+            hint = addHintForArguments(hint, docs.args, docs.numargs, " ");
+        }
+        return hint;
+    }
+
+    /* If arg specs are not available, show the hint string until the user types something. */
+    if (inputargc <= cmdlen) {
+        hint = sdsnew(docs.params);
+    } else {
+        hint = sdsempty();
+    }
+    return hint;
+}
+
+/* Search for a command matching the longest possible prefix of input words. */
+static helpEntry *findHelpEntry(int argc, char **argv) {
+    helpEntry *entry = NULL;
+    int i, rawargc, matchlen = 0;
+    sds *rawargv;
+
+    for (i = 0; i < helpEntriesLen; i++) {
+        if (!(helpEntries[i].type & CLI_HELP_COMMAND)) continue;
+
+        rawargv = helpEntries[i].argv;
+        rawargc = helpEntries[i].argc;
+        if (rawargc <= argc) {
+            int j;
+            for (j = 0; j < rawargc; j++) {
+                if (strcasecmp(rawargv[j], argv[j])) {
+                    break;
+                }
+            }
+            if (j == rawargc && rawargc > matchlen) {
+                matchlen = rawargc;
+                entry = &helpEntries[i];
+            }
+        }
+    }
+    return entry;
+}
+
+/* Returns the command-line hint string for a given partial input. */
+static sds getHintForInput(const char *charinput) {
+    sds hint = NULL;
+    int inputargc, inputlen = strlen(charinput);
+    sds *inputargv = sdssplitargs(charinput, &inputargc);
+    int endspace = inputlen && isspace(charinput[inputlen - 1]);
+
+    /* Don't match the last word until the user has typed a space after it. */
+    int matchargc = endspace ? inputargc : inputargc - 1;
+
+    helpEntry *entry = findHelpEntry(matchargc, inputargv);
+    if (entry) {
+        hint = makeHint(inputargv, matchargc, entry->argc, entry->docs);
+    }
+    sdsfreesplitres(inputargv, inputargc);
+    return hint;
+}
+
+/* Linenoise hints callback. */
+static char *hintsCallback(const char *buf, int *color, int *bold) {
+    if (!pref.hints) return NULL;
+
+    sds hint = getHintForInput(buf);
+    if (hint == NULL) {
+        return NULL;
+    }
+
+    *color = 90;
+    *bold = 0;
+
+    /* Add an initial space if needed. */
+    int len = strlen(buf);
+    int endspace = len && isspace(buf[len - 1]);
+    if (!endspace) {
+        sds newhint = sdsnewlen(" ", 1);
+        newhint = sdscatsds(newhint, hint);
+        sdsfree(hint);
+        hint = newhint;
+    }
+
+    return hint;
+}
+
+static void freeHintsCallback(void *ptr) {
+    sdsfree(ptr);
+}
+
+/*------------------------------------------------------------------------------
+ * TTY manipulation
+ *--------------------------------------------------------------------------- */
+
+/* Restore terminal if we've changed it. */
+void cliRestoreTTY(void) {
+    if (orig_termios_saved) tcsetattr(STDIN_FILENO, TCSANOW, &orig_termios);
+}
+
+/* Put the terminal in "press any key" mode */
+static void cliPressAnyKeyTTY(void) {
+    if (!isatty(STDIN_FILENO)) return;
+    if (!orig_termios_saved) {
+        if (tcgetattr(STDIN_FILENO, &orig_termios) == -1) return;
+        atexit(cliRestoreTTY);
+        orig_termios_saved = 1;
+    }
+    struct termios mode = orig_termios;
+    mode.c_lflag &= ~(ECHO | ICANON); /* echoing off, canonical off */
+    tcsetattr(STDIN_FILENO, TCSANOW, &mode);
+}
+
+/*------------------------------------------------------------------------------
+ * Networking / parsing
+ *--------------------------------------------------------------------------- */
+
+/* Send AUTH command to the server */
+static int cliAuth(redisContext *ctx, char *user, char *auth) {
+    redisReply *reply;
+    if (auth == NULL) return REDIS_OK;
+
+    if (user == NULL)
+        reply = redisCommand(ctx, "AUTH %s", auth);
+    else
+        reply = redisCommand(ctx, "AUTH %s %s", user, auth);
+
+    if (reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        return REDIS_ERR;
+    }
+
+    int result = REDIS_OK;
+    if (reply->type == REDIS_REPLY_ERROR) {
+        result = REDIS_ERR;
+        fprintf(stderr, "AUTH failed: %s\n", reply->str);
+    }
+    freeReplyObject(reply);
+    return result;
+}
+
+/* Send SELECT input_dbnum to the server */
+static int cliSelect(void) {
+    redisReply *reply;
+    if (config.conn_info.input_dbnum == config.dbnum) return REDIS_OK;
+
+    reply = redisCommand(context, "SELECT %d", config.conn_info.input_dbnum);
+    if (reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        return REDIS_ERR;
+    }
+
+    int result = REDIS_OK;
+    if (reply->type == REDIS_REPLY_ERROR) {
+        result = REDIS_ERR;
+        fprintf(stderr, "SELECT %d failed: %s\n", config.conn_info.input_dbnum, reply->str);
+    } else {
+        config.dbnum = config.conn_info.input_dbnum;
+        cliRefreshPrompt();
+    }
+    freeReplyObject(reply);
+    return result;
+}
+
+/* Select RESP3 mode if valkey-cli was started with the -3 option.  */
+static int cliSwitchProto(void) {
+    redisReply *reply;
+    if (!config.resp3 || config.resp2) return REDIS_OK;
+
+    reply = redisCommand(context, "HELLO 3");
+    if (reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        return REDIS_ERR;
+    }
+
+    int result = REDIS_OK;
+    if (reply->type == REDIS_REPLY_ERROR) {
+        fprintf(stderr, "HELLO 3 failed: %s\n", reply->str);
+        if (config.resp3 == 1) {
+            result = REDIS_ERR;
+        } else if (config.resp3 == 2) {
+            result = REDIS_OK;
+        }
+    }
+
+    /* Retrieve server version string for later use. */
+    for (size_t i = 0; i < reply->elements; i += 2) {
+        assert(reply->element[i]->type == REDIS_REPLY_STRING);
+        char *key = reply->element[i]->str;
+        if (!strcmp(key, "version")) {
+            assert(reply->element[i + 1]->type == REDIS_REPLY_STRING);
+            config.server_version = sdsnew(reply->element[i + 1]->str);
+        }
+    }
+    freeReplyObject(reply);
+    config.current_resp3 = 1;
+    return result;
+}
+
+/* Connect to the server. It is possible to pass certain flags to the function:
+ *      CC_FORCE: The connection is performed even if there is already
+ *                a connected socket.
+ *      CC_QUIET: Don't print errors if connection fails. */
+static int cliConnect(int flags) {
+    if (context == NULL || flags & CC_FORCE) {
+        if (context != NULL) {
+            redisFree(context);
+            config.dbnum = 0;
+            config.in_multi = 0;
+            config.pubsub_mode = 0;
+            cliRefreshPrompt();
+        }
+
+        /* Do not use hostsocket when we got redirected in cluster mode */
+        if (config.hostsocket == NULL || (config.cluster_mode && config.cluster_reissue_command)) {
+            context = redisConnectWrapper(config.conn_info.hostip, config.conn_info.hostport, config.connect_timeout);
+        } else {
+            context = redisConnectUnixWrapper(config.hostsocket, config.connect_timeout);
+        }
+
+        if (!context->err && config.tls) {
+            const char *err = NULL;
+            if (cliSecureConnection(context, config.sslconfig, &err) == REDIS_ERR && err) {
+                fprintf(stderr, "Could not negotiate a TLS connection: %s\n", err);
+                redisFree(context);
+                context = NULL;
+                return REDIS_ERR;
+            }
+        }
+
+        if (context->err) {
+            if (!(flags & CC_QUIET)) {
+                fprintf(stderr, "Could not connect to Valkey at ");
+                if (config.hostsocket == NULL || (config.cluster_mode && config.cluster_reissue_command)) {
+                    fprintf(stderr, "%s:%d: %s\n", config.conn_info.hostip, config.conn_info.hostport, context->errstr);
+                } else {
+                    fprintf(stderr, "%s: %s\n", config.hostsocket, context->errstr);
+                }
+            }
+            redisFree(context);
+            context = NULL;
+            return REDIS_ERR;
+        }
+
+
+        /* Set aggressive KEEP_ALIVE socket option in the server context socket
+         * in order to prevent timeouts caused by the execution of long
+         * commands. At the same time this improves the detection of real
+         * errors. */
+        anetKeepAlive(NULL, context->fd, CLI_KEEPALIVE_INTERVAL);
+
+        /* State of the current connection. */
+        config.current_resp3 = 0;
+
+        /* Do AUTH, select the right DB, switch to RESP3 if needed. */
+        if (cliAuth(context, config.conn_info.user, config.conn_info.auth) != REDIS_OK) return REDIS_ERR;
+        if (cliSelect() != REDIS_OK) return REDIS_ERR;
+        if (cliSwitchProto() != REDIS_OK) return REDIS_ERR;
+    }
+
+    /* Set a PUSH handler if configured to do so. */
+    if (config.push_output) {
+        redisSetPushCallback(context, cliPushHandler);
+    }
+
+    return REDIS_OK;
+}
+
+/* In cluster, if server replies ASK, we will redirect to a different node.
+ * Before sending the real command, we need to send ASKING command first. */
+static int cliSendAsking(void) {
+    redisReply *reply;
+
+    config.cluster_send_asking = 0;
+    if (context == NULL) {
+        return REDIS_ERR;
+    }
+    reply = redisCommand(context, "ASKING");
+    if (reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        return REDIS_ERR;
+    }
+    int result = REDIS_OK;
+    if (reply->type == REDIS_REPLY_ERROR) {
+        result = REDIS_ERR;
+        fprintf(stderr, "ASKING failed: %s\n", reply->str);
+    }
+    freeReplyObject(reply);
+    return result;
+}
+
+static void cliPrintContextError(void) {
+    if (context == NULL) return;
+    fprintf(stderr, "Error: %s\n", context->errstr);
+}
+
+static int isInvalidateReply(redisReply *reply) {
+    return reply->type == REDIS_REPLY_PUSH && reply->elements == 2 && reply->element[0]->type == REDIS_REPLY_STRING &&
+           !strncmp(reply->element[0]->str, "invalidate", 10) && reply->element[1]->type == REDIS_REPLY_ARRAY;
+}
+
+/* Special display handler for RESP3 'invalidate' messages.
+ * This function does not validate the reply, so it should
+ * already be confirmed correct */
+static sds cliFormatInvalidateTTY(redisReply *r) {
+    sds out = sdsnew("-> invalidate: ");
+
+    for (size_t i = 0; i < r->element[1]->elements; i++) {
+        redisReply *key = r->element[1]->element[i];
+        assert(key->type == REDIS_REPLY_STRING);
+
+        out = sdscatfmt(out, "'%s'", key->str, key->len);
+        if (i < r->element[1]->elements - 1) out = sdscatlen(out, ", ", 2);
+    }
+
+    return sdscatlen(out, "\n", 1);
+}
+
+/* Returns non-zero if cliFormatReplyTTY renders the reply in multiple lines. */
+static int cliIsMultilineValueTTY(redisReply *r) {
+    switch (r->type) {
+    case REDIS_REPLY_ARRAY:
+    case REDIS_REPLY_SET:
+    case REDIS_REPLY_PUSH:
+        if (r->elements == 0) return 0;
+        if (r->elements > 1) return 1;
+        return cliIsMultilineValueTTY(r->element[0]);
+    case REDIS_REPLY_MAP:
+        if (r->elements == 0) return 0;
+        if (r->elements > 2) return 1;
+        return cliIsMultilineValueTTY(r->element[1]);
+    default: return 0;
+    }
+}
+
+static sds cliFormatReplyTTY(redisReply *r, char *prefix) {
+    sds out = sdsempty();
+    switch (r->type) {
+    case REDIS_REPLY_ERROR: out = sdscatprintf(out, "(error) %s\n", r->str); break;
+    case REDIS_REPLY_STATUS:
+        out = sdscat(out, r->str);
+        out = sdscat(out, "\n");
+        break;
+    case REDIS_REPLY_INTEGER: out = sdscatprintf(out, "(integer) %lld\n", r->integer); break;
+    case REDIS_REPLY_DOUBLE: out = sdscatprintf(out, "(double) %s\n", r->str); break;
+    case REDIS_REPLY_STRING:
+    case REDIS_REPLY_VERB:
+        /* If you are producing output for the standard output we want
+         * a more interesting output with quoted characters and so forth,
+         * unless it's a verbatim string type. */
+        if (r->type == REDIS_REPLY_STRING) {
+            out = sdscatrepr(out, r->str, r->len);
+            out = sdscat(out, "\n");
+        } else {
+            out = sdscatlen(out, r->str, r->len);
+            out = sdscat(out, "\n");
+        }
+        break;
+    case REDIS_REPLY_NIL: out = sdscat(out, "(nil)\n"); break;
+    case REDIS_REPLY_BOOL: out = sdscat(out, r->integer ? "(true)\n" : "(false)\n"); break;
+    case REDIS_REPLY_ARRAY:
+    case REDIS_REPLY_MAP:
+    case REDIS_REPLY_SET:
+    case REDIS_REPLY_PUSH:
+        if (r->elements == 0) {
+            if (r->type == REDIS_REPLY_ARRAY)
+                out = sdscat(out, "(empty array)\n");
+            else if (r->type == REDIS_REPLY_MAP)
+                out = sdscat(out, "(empty hash)\n");
+            else if (r->type == REDIS_REPLY_SET)
+                out = sdscat(out, "(empty set)\n");
+            else if (r->type == REDIS_REPLY_PUSH)
+                out = sdscat(out, "(empty push)\n");
+            else
+                out = sdscat(out, "(empty aggregate type)\n");
+        } else {
+            unsigned int i, idxlen = 0;
+            char _prefixlen[16];
+            char _prefixfmt[16];
+            sds _prefix;
+            sds tmp;
+
+            /* Calculate chars needed to represent the largest index */
+            i = r->elements;
+            if (r->type == REDIS_REPLY_MAP) i /= 2;
+            do {
+                idxlen++;
+                i /= 10;
+            } while (i);
+
+            /* Prefix for nested multi bulks should grow with idxlen+2 spaces */
+            memset(_prefixlen, ' ', idxlen + 2);
+            _prefixlen[idxlen + 2] = '\0';
+            _prefix = sdscat(sdsnew(prefix), _prefixlen);
+
+            /* Setup prefix format for every entry */
+            char numsep;
+            if (r->type == REDIS_REPLY_SET)
+                numsep = '~';
+            else if (r->type == REDIS_REPLY_MAP)
+                numsep = '#';
+            /* TODO: this would be a breaking change for scripts, do that in a major version. */
+            /* else if (r->type == REDIS_REPLY_PUSH) numsep = '>'; */
+            else
+                numsep = ')';
+            snprintf(_prefixfmt, sizeof(_prefixfmt), "%%s%%%ud%c ", idxlen, numsep);
+
+            for (i = 0; i < r->elements; i++) {
+                unsigned int human_idx = (r->type == REDIS_REPLY_MAP) ? i / 2 : i;
+                human_idx++; /* Make it 1-based. */
+
+                /* Don't use the prefix for the first element, as the parent
+                 * caller already prepended the index number. */
+                out = sdscatprintf(out, _prefixfmt, i == 0 ? "" : prefix, human_idx);
+
+                /* Format the multi bulk entry */
+                tmp = cliFormatReplyTTY(r->element[i], _prefix);
+                out = sdscatlen(out, tmp, sdslen(tmp));
+                sdsfree(tmp);
+
+                /* For maps, format the value as well. */
+                if (r->type == REDIS_REPLY_MAP) {
+                    i++;
+                    sdsrange(out, 0, -2);
+                    out = sdscat(out, " => ");
+                    if (cliIsMultilineValueTTY(r->element[i])) {
+                        /* linebreak before multiline value to fix alignment */
+                        out = sdscat(out, "\n");
+                        out = sdscat(out, _prefix);
+                    }
+                    tmp = cliFormatReplyTTY(r->element[i], _prefix);
+                    out = sdscatlen(out, tmp, sdslen(tmp));
+                    sdsfree(tmp);
+                }
+            }
+            sdsfree(_prefix);
+        }
+        break;
+    default: fprintf(stderr, "Unknown reply type: %d\n", r->type); exit(1);
+    }
+    return out;
+}
+
+/* Returns 1 if the reply is a pubsub pushed reply. */
+int isPubsubPush(redisReply *r) {
+    if (r == NULL || r->type != (config.current_resp3 ? REDIS_REPLY_PUSH : REDIS_REPLY_ARRAY) || r->elements < 3 ||
+        r->element[0]->type != REDIS_REPLY_STRING) {
+        return 0;
+    }
+    char *str = r->element[0]->str;
+    size_t len = r->element[0]->len;
+    /* Check if it is [p|s][un]subscribe or [p|s]message, but even simpler, we
+     * just check that it ends with "message" or "subscribe". */
+    return ((len >= strlen("message") && !strcmp(str + len - strlen("message"), "message")) ||
+            (len >= strlen("subscribe") && !strcmp(str + len - strlen("subscribe"), "subscribe")));
+}
+
+int isColorTerm(void) {
+    char *t = getenv("TERM");
+    return t != NULL && strstr(t, "xterm") != NULL;
+}
+
+/* Helper function for sdsCatColorizedLdbReply() appending colorize strings
+ * to an SDS string. */
+sds sdscatcolor(sds o, char *s, size_t len, char *color) {
+    if (!isColorTerm()) return sdscatlen(o, s, len);
+
+    int bold = strstr(color, "bold") != NULL;
+    int ccode = 37; /* Defaults to white. */
+    if (strstr(color, "red"))
+        ccode = 31;
+    else if (strstr(color, "green"))
+        ccode = 32;
+    else if (strstr(color, "yellow"))
+        ccode = 33;
+    else if (strstr(color, "blue"))
+        ccode = 34;
+    else if (strstr(color, "magenta"))
+        ccode = 35;
+    else if (strstr(color, "cyan"))
+        ccode = 36;
+    else if (strstr(color, "white"))
+        ccode = 37;
+
+    o = sdscatfmt(o, "\033[%i;%i;49m", bold, ccode);
+    o = sdscatlen(o, s, len);
+    o = sdscat(o, "\033[0m");
+    return o;
+}
+
+/* Colorize Lua debugger status replies according to the prefix they
+ * have. */
+sds sdsCatColorizedLdbReply(sds o, char *s, size_t len) {
+    char *color = "white";
+
+    if (strstr(s, "<debug>")) color = "bold";
+    if (strstr(s, "<command>")) color = "green";
+    if (strstr(s, "<redis>")) color = "green";
+    if (strstr(s, "<reply>")) color = "cyan";
+    if (strstr(s, "<error>")) color = "red";
+    if (strstr(s, "<hint>")) color = "bold";
+    if (strstr(s, "<value>") || strstr(s, "<retval>")) color = "magenta";
+    if (len > 4 && isdigit(s[3])) {
+        if (s[1] == '>')
+            color = "yellow"; /* Current line. */
+        else if (s[2] == '#')
+            color = "bold"; /* Break point. */
+    }
+    return sdscatcolor(o, s, len, color);
+}
+
+static sds cliFormatReplyRaw(redisReply *r) {
+    sds out = sdsempty(), tmp;
+    size_t i;
+
+    switch (r->type) {
+    case REDIS_REPLY_NIL:
+        /* Nothing... */
+        break;
+    case REDIS_REPLY_ERROR:
+        out = sdscatlen(out, r->str, r->len);
+        out = sdscatlen(out, "\n", 1);
+        break;
+    case REDIS_REPLY_STATUS:
+    case REDIS_REPLY_STRING:
+    case REDIS_REPLY_VERB:
+        if (r->type == REDIS_REPLY_STATUS && config.eval_ldb) {
+            /* The Lua debugger replies with arrays of simple (status)
+             * strings. We colorize the output for more fun if this
+             * is a debugging session. */
+
+            /* Detect the end of a debugging session. */
+            if (strstr(r->str, "<endsession>") == r->str) {
+                config.enable_ldb_on_eval = 0;
+                config.eval_ldb = 0;
+                config.eval_ldb_end = 1; /* Signal the caller session ended. */
+                config.output = OUTPUT_STANDARD;
+                cliRefreshPrompt();
+            } else {
+                out = sdsCatColorizedLdbReply(out, r->str, r->len);
+            }
+        } else {
+            out = sdscatlen(out, r->str, r->len);
+        }
+        break;
+    case REDIS_REPLY_BOOL: out = sdscat(out, r->integer ? "(true)" : "(false)"); break;
+    case REDIS_REPLY_INTEGER: out = sdscatprintf(out, "%lld", r->integer); break;
+    case REDIS_REPLY_DOUBLE: out = sdscatprintf(out, "%s", r->str); break;
+    case REDIS_REPLY_SET:
+    case REDIS_REPLY_ARRAY:
+    case REDIS_REPLY_PUSH:
+        for (i = 0; i < r->elements; i++) {
+            if (i > 0) out = sdscat(out, config.mb_delim);
+            tmp = cliFormatReplyRaw(r->element[i]);
+            out = sdscatlen(out, tmp, sdslen(tmp));
+            sdsfree(tmp);
+        }
+        break;
+    case REDIS_REPLY_MAP:
+        for (i = 0; i < r->elements; i += 2) {
+            if (i > 0) out = sdscat(out, config.mb_delim);
+            tmp = cliFormatReplyRaw(r->element[i]);
+            out = sdscatlen(out, tmp, sdslen(tmp));
+            sdsfree(tmp);
+
+            out = sdscatlen(out, " ", 1);
+            tmp = cliFormatReplyRaw(r->element[i + 1]);
+            out = sdscatlen(out, tmp, sdslen(tmp));
+            sdsfree(tmp);
+        }
+        break;
+    default: fprintf(stderr, "Unknown reply type: %d\n", r->type); exit(1);
+    }
+    return out;
+}
+
+static sds cliFormatReplyCSV(redisReply *r) {
+    unsigned int i;
+
+    sds out = sdsempty();
+    switch (r->type) {
+    case REDIS_REPLY_ERROR:
+        out = sdscat(out, "ERROR,");
+        out = sdscatrepr(out, r->str, strlen(r->str));
+        break;
+    case REDIS_REPLY_STATUS: out = sdscatrepr(out, r->str, r->len); break;
+    case REDIS_REPLY_INTEGER: out = sdscatprintf(out, "%lld", r->integer); break;
+    case REDIS_REPLY_DOUBLE: out = sdscatprintf(out, "%s", r->str); break;
+    case REDIS_REPLY_STRING:
+    case REDIS_REPLY_VERB: out = sdscatrepr(out, r->str, r->len); break;
+    case REDIS_REPLY_NIL: out = sdscat(out, "NULL"); break;
+    case REDIS_REPLY_BOOL: out = sdscat(out, r->integer ? "true" : "false"); break;
+    case REDIS_REPLY_ARRAY:
+    case REDIS_REPLY_SET:
+    case REDIS_REPLY_PUSH:
+    case REDIS_REPLY_MAP: /* CSV has no map type, just output flat list. */
+        for (i = 0; i < r->elements; i++) {
+            sds tmp = cliFormatReplyCSV(r->element[i]);
+            out = sdscatlen(out, tmp, sdslen(tmp));
+            if (i != r->elements - 1) out = sdscat(out, ",");
+            sdsfree(tmp);
+        }
+        break;
+    default: fprintf(stderr, "Unknown reply type: %d\n", r->type); exit(1);
+    }
+    return out;
+}
+
+/* Append specified buffer to out and return it, using required JSON output
+ * mode. */
+static sds jsonStringOutput(sds out, const char *p, int len, int mode) {
+    if (mode == OUTPUT_JSON) {
+        return escapeJsonString(out, p, len);
+    } else if (mode == OUTPUT_QUOTED_JSON) {
+        /* Need to double-quote backslashes */
+        sds tmp = sdscatrepr(sdsempty(), p, len);
+        int tmplen = sdslen(tmp);
+        char *n = tmp;
+        while (tmplen--) {
+            if (*n == '\\')
+                out = sdscatlen(out, "\\\\", 2);
+            else
+                out = sdscatlen(out, n, 1);
+            n++;
+        }
+
+        sdsfree(tmp);
+        return out;
+    } else {
+        assert(0);
+    }
+    /* Silence compiler warning */
+    return NULL;
+}
+
+static sds cliFormatReplyJson(sds out, redisReply *r, int mode) {
+    unsigned int i;
+
+    switch (r->type) {
+    case REDIS_REPLY_ERROR:
+        out = sdscat(out, "error:");
+        out = jsonStringOutput(out, r->str, strlen(r->str), mode);
+        break;
+    case REDIS_REPLY_STATUS: out = jsonStringOutput(out, r->str, r->len, mode); break;
+    case REDIS_REPLY_INTEGER: out = sdscatprintf(out, "%lld", r->integer); break;
+    case REDIS_REPLY_DOUBLE: out = sdscatprintf(out, "%s", r->str); break;
+    case REDIS_REPLY_STRING:
+    case REDIS_REPLY_VERB: out = jsonStringOutput(out, r->str, r->len, mode); break;
+    case REDIS_REPLY_NIL: out = sdscat(out, "null"); break;
+    case REDIS_REPLY_BOOL: out = sdscat(out, r->integer ? "true" : "false"); break;
+    case REDIS_REPLY_ARRAY:
+    case REDIS_REPLY_SET:
+    case REDIS_REPLY_PUSH:
+        out = sdscat(out, "[");
+        for (i = 0; i < r->elements; i++) {
+            out = cliFormatReplyJson(out, r->element[i], mode);
+            if (i != r->elements - 1) out = sdscat(out, ",");
+        }
+        out = sdscat(out, "]");
+        break;
+    case REDIS_REPLY_MAP:
+        out = sdscat(out, "{");
+        for (i = 0; i < r->elements; i += 2) {
+            redisReply *key = r->element[i];
+            if (key->type == REDIS_REPLY_ERROR || key->type == REDIS_REPLY_STATUS || key->type == REDIS_REPLY_STRING ||
+                key->type == REDIS_REPLY_VERB) {
+                out = cliFormatReplyJson(out, key, mode);
+            } else {
+                /* According to JSON spec, JSON map keys must be strings,
+                 * and in RESP3, they can be other types.
+                 * The first one(cliFormatReplyJson) is to convert non string type to string
+                 * The Second one(escapeJsonString) is to escape the converted string */
+                sds keystr = cliFormatReplyJson(sdsempty(), key, mode);
+                if (keystr[0] == '"')
+                    out = sdscatsds(out, keystr);
+                else
+                    out = sdscatfmt(out, "\"%S\"", keystr);
+                sdsfree(keystr);
+            }
+            out = sdscat(out, ":");
+
+            out = cliFormatReplyJson(out, r->element[i + 1], mode);
+            if (i != r->elements - 2) out = sdscat(out, ",");
+        }
+        out = sdscat(out, "}");
+        break;
+    default: fprintf(stderr, "Unknown reply type: %d\n", r->type); exit(1);
+    }
+    return out;
+}
+
+/* Generate reply strings in various output modes */
+static sds cliFormatReply(redisReply *reply, int mode, int verbatim) {
+    sds out;
+
+    if (verbatim) {
+        out = cliFormatReplyRaw(reply);
+    } else if (mode == OUTPUT_STANDARD) {
+        out = cliFormatReplyTTY(reply, "");
+    } else if (mode == OUTPUT_RAW) {
+        out = cliFormatReplyRaw(reply);
+        out = sdscatsds(out, config.cmd_delim);
+    } else if (mode == OUTPUT_CSV) {
+        out = cliFormatReplyCSV(reply);
+        out = sdscatlen(out, "\n", 1);
+    } else if (mode == OUTPUT_JSON || mode == OUTPUT_QUOTED_JSON) {
+        out = cliFormatReplyJson(sdsempty(), reply, mode);
+        out = sdscatlen(out, "\n", 1);
+    } else {
+        fprintf(stderr, "Error:  Unknown output encoding %d\n", mode);
+        exit(1);
+    }
+
+    return out;
+}
+
+/* Output any spontaneous PUSH reply we receive */
+static void cliPushHandler(void *privdata, void *reply) {
+    UNUSED(privdata);
+    sds out;
+
+    if (config.output == OUTPUT_STANDARD && isInvalidateReply(reply)) {
+        out = cliFormatInvalidateTTY(reply);
+    } else {
+        out = cliFormatReply(reply, config.output, 0);
+    }
+
+    fwrite(out, sdslen(out), 1, stdout);
+
+    freeReplyObject(reply);
+    sdsfree(out);
+}
+
+static int cliReadReply(int output_raw_strings) {
+    void *_reply;
+    redisReply *reply;
+    sds out = NULL;
+    int output = 1;
+
+    if (config.last_reply) {
+        freeReplyObject(config.last_reply);
+        config.last_reply = NULL;
+    }
+
+    if (redisGetReply(context, &_reply) != REDIS_OK) {
+        if (config.blocking_state_aborted) {
+            config.blocking_state_aborted = 0;
+            config.monitor_mode = 0;
+            config.pubsub_mode = 0;
+            return cliConnect(CC_FORCE);
+        }
+
+        if (config.shutdown) {
+            redisFree(context);
+            context = NULL;
+            return REDIS_OK;
+        }
+        if (config.interactive) {
+            /* Filter cases where we should reconnect */
+            if (context->err == REDIS_ERR_IO && (errno == ECONNRESET || errno == EPIPE)) return REDIS_ERR;
+            if (context->err == REDIS_ERR_EOF) return REDIS_ERR;
+        }
+        cliPrintContextError();
+        exit(1);
+        return REDIS_ERR; /* avoid compiler warning */
+    }
+
+    config.last_reply = reply = (redisReply *)_reply;
+
+    config.last_cmd_type = reply->type;
+
+    /* Check if we need to connect to a different node and reissue the
+     * request. */
+    if (config.cluster_mode && reply->type == REDIS_REPLY_ERROR &&
+        (!strncmp(reply->str, "MOVED ", 6) || !strncmp(reply->str, "ASK ", 4))) {
+        char *p = reply->str, *s;
+        int slot;
+
+        output = 0;
+        /* Comments show the position of the pointer as:
+         *
+         * [S] for pointer 's'
+         * [P] for pointer 'p'
+         */
+        s = strchr(p, ' ');     /* MOVED[S]3999 127.0.0.1:6381 */
+        p = strchr(s + 1, ' '); /* MOVED[S]3999[P]127.0.0.1:6381 */
+        *p = '\0';
+        slot = atoi(s + 1);
+        s = strrchr(p + 1, ':'); /* MOVED 3999[P]127.0.0.1[S]6381 */
+        *s = '\0';
+        if (p + 1 != s) {
+            /* Host might be empty, like 'MOVED 3999 :6381', if endpoint type is unknown. Only update the
+             * host if it's non-empty. */
+            sdsfree(config.conn_info.hostip);
+            config.conn_info.hostip = sdsnew(p + 1);
+        }
+        config.conn_info.hostport = atoi(s + 1);
+        if (config.interactive)
+            printf("-> Redirected to slot [%d] located at %s:%d\n", slot, config.conn_info.hostip,
+                   config.conn_info.hostport);
+        config.cluster_reissue_command = 1;
+        if (!strncmp(reply->str, "ASK ", 4)) {
+            config.cluster_send_asking = 1;
+        }
+        cliRefreshPrompt();
+    } else if (!config.interactive && config.set_errcode && reply->type == REDIS_REPLY_ERROR) {
+        fprintf(stderr, "%s\n", reply->str);
+        exit(1);
+        return REDIS_ERR; /* avoid compiler warning */
+    }
+
+    if (output) {
+        out = cliFormatReply(reply, config.output, output_raw_strings);
+        fwrite(out, sdslen(out), 1, stdout);
+        fflush(stdout);
+        sdsfree(out);
+    }
+    return REDIS_OK;
+}
+
+/* Helper method to handle pubsub subscription/unsubscription. */
+static void handlePubSubMode(redisReply *reply) {
+    char *cmd = reply->element[0]->str;
+    int count = reply->element[2]->integer;
+
+    /* Update counts based on the command type */
+    if (strcmp(cmd, "subscribe") == 0 || strcmp(cmd, "psubscribe") == 0 || strcmp(cmd, "unsubscribe") == 0 || strcmp(cmd, "punsubscribe") == 0) {
+        config.pubsub_unsharded_count = count;
+    } else if (strcmp(cmd, "ssubscribe") == 0 || strcmp(cmd, "sunsubscribe") == 0) {
+        config.pubsub_sharded_count = count;
+    }
+
+    /* Update pubsub mode based on the current counts */
+    if (config.pubsub_unsharded_count + config.pubsub_sharded_count == 0 && config.pubsub_mode) {
+        config.pubsub_mode = 0;
+        cliRefreshPrompt();
+    } else if (config.pubsub_unsharded_count + config.pubsub_sharded_count > 0 && !config.pubsub_mode) {
+        config.pubsub_mode = 1;
+        cliRefreshPrompt();
+    }
+}
+
+/* Simultaneously wait for pubsub messages from the server and input on stdin. */
+static void cliWaitForMessagesOrStdin(void) {
+    int show_info = config.output != OUTPUT_RAW && (isatty(STDOUT_FILENO) || getenv("FAKETTY"));
+    int use_color = show_info && isColorTerm();
+    cliPressAnyKeyTTY();
+    while (config.pubsub_mode) {
+        /* First check if there are any buffered replies. */
+        redisReply *reply;
+        do {
+            if (redisGetReplyFromReader(context, (void **)&reply) != REDIS_OK) {
+                cliPrintContextError();
+                exit(1);
+            }
+            if (reply) {
+                sds out = cliFormatReply(reply, config.output, 0);
+                fwrite(out, sdslen(out), 1, stdout);
+                fflush(stdout);
+
+                if (isPubsubPush(reply)) {
+                    handlePubSubMode(reply);
+                }
+
+                sdsfree(out);
+                freeReplyObject(reply);
+            }
+        } while (reply);
+
+        /* Wait for input, either on the server socket or on stdin. */
+        struct timeval tv;
+        fd_set readfds;
+        FD_ZERO(&readfds);
+        FD_SET(context->fd, &readfds);
+        FD_SET(STDIN_FILENO, &readfds);
+        tv.tv_sec = 5;
+        tv.tv_usec = 0;
+        if (show_info) {
+            if (use_color) printf("\033[1;90m"); /* Bold, bright color. */
+            printf("Reading messages... (press Ctrl-C to quit or any key to type command)\r");
+            if (use_color) printf("\033[0m"); /* Reset color. */
+            fflush(stdout);
+        }
+        select(context->fd + 1, &readfds, NULL, NULL, &tv);
+        if (show_info) {
+            printf("\033[K"); /* Erase current line */
+            fflush(stdout);
+        }
+        if (config.blocking_state_aborted) {
+            /* Ctrl-C pressed */
+            config.blocking_state_aborted = 0;
+            config.pubsub_mode = 0;
+            printf("Closing current connection. Ready to reconnect to Valkey server... \n");
+            fflush(stdout);
+            if (cliConnect(CC_FORCE) != REDIS_OK) {
+                cliPrintContextError();
+                exit(1);
+            }
+            break;
+        } else if (FD_ISSET(context->fd, &readfds)) {
+            /* Message from the server */
+            if (cliReadReply(0) != REDIS_OK) {
+                cliPrintContextError();
+                exit(1);
+            }
+            fflush(stdout);
+        } else if (FD_ISSET(STDIN_FILENO, &readfds)) {
+            /* Any key pressed */
+            break;
+        }
+    }
+    cliRestoreTTY();
+}
+
+static int cliSendCommand(int argc, char **argv, long repeat) {
+    char *command = argv[0];
+    size_t *argvlen;
+    int j, output_raw;
+
+    if (context == NULL) return REDIS_ERR;
+
+    output_raw = 0;
+    if (!strcasecmp(command, "info") || !strcasecmp(command, "lolwut") ||
+        (argc >= 2 && !strcasecmp(command, "debug") && !strcasecmp(argv[1], "htstats")) ||
+        (argc >= 2 && !strcasecmp(command, "debug") && !strcasecmp(argv[1], "htstats-key")) ||
+        (argc >= 2 && !strcasecmp(command, "debug") && !strcasecmp(argv[1], "client-eviction")) ||
+        (argc >= 2 && !strcasecmp(command, "memory") &&
+         (!strcasecmp(argv[1], "malloc-stats") || !strcasecmp(argv[1], "doctor"))) ||
+        (argc == 2 && !strcasecmp(command, "cluster") &&
+         (!strcasecmp(argv[1], "nodes") || !strcasecmp(argv[1], "info"))) ||
+        (argc >= 2 && !strcasecmp(command, "client") &&
+         (!strcasecmp(argv[1], "list") || !strcasecmp(argv[1], "info"))) ||
+        (argc == 3 && !strcasecmp(command, "latency") && !strcasecmp(argv[1], "graph")) ||
+        (argc == 2 && !strcasecmp(command, "latency") && !strcasecmp(argv[1], "doctor")) ||
+        /* Format PROXY INFO command for Cluster Proxy:
+         * https://github.com/artix75/redis-cluster-proxy */
+        (argc >= 2 && !strcasecmp(command, "proxy") && !strcasecmp(argv[1], "info"))) {
+        output_raw = 1;
+    }
+
+    if (!strcasecmp(command, "shutdown")) config.shutdown = 1;
+    if (!strcasecmp(command, "monitor")) config.monitor_mode = 1;
+    int is_subscribe =
+        (!strcasecmp(command, "subscribe") || !strcasecmp(command, "psubscribe") || !strcasecmp(command, "ssubscribe"));
+    int is_unsubscribe = (!strcasecmp(command, "unsubscribe") || !strcasecmp(command, "punsubscribe") ||
+                          !strcasecmp(command, "sunsubscribe"));
+    if (!strcasecmp(command, "sync") || !strcasecmp(command, "psync")) config.replica_mode = 1;
+
+    /* When the user manually calls SCRIPT DEBUG, setup the activation of
+     * debugging mode on the next eval if needed. */
+    if (argc == 3 && !strcasecmp(argv[0], "script") && !strcasecmp(argv[1], "debug")) {
+        if (!strcasecmp(argv[2], "yes") || !strcasecmp(argv[2], "sync")) {
+            config.enable_ldb_on_eval = 1;
+        } else {
+            config.enable_ldb_on_eval = 0;
+        }
+    }
+
+    /* Actually activate LDB on EVAL if needed. */
+    if (!strcasecmp(command, "eval") && config.enable_ldb_on_eval) {
+        config.eval_ldb = 1;
+        config.output = OUTPUT_RAW;
+    }
+
+    /* Setup argument length */
+    argvlen = zmalloc(argc * sizeof(size_t));
+    for (j = 0; j < argc; j++) argvlen[j] = sdslen(argv[j]);
+
+    /* Negative repeat is allowed and causes infinite loop,
+       works well with the interval option. */
+    while (repeat < 0 || repeat-- > 0) {
+        redisAppendCommandArgv(context, argc, (const char **)argv, argvlen);
+
+        if (config.monitor_mode) {
+            do {
+                if (cliReadReply(output_raw) != REDIS_OK) {
+                    cliPrintContextError();
+                    exit(1);
+                }
+                fflush(stdout);
+
+                /* This happens when the MONITOR command returns an error. */
+                if (config.last_cmd_type == REDIS_REPLY_ERROR) config.monitor_mode = 0;
+            } while (config.monitor_mode);
+            zfree(argvlen);
+            return REDIS_OK;
+        }
+
+        int num_expected_pubsub_push = 0;
+        if (is_subscribe || is_unsubscribe) {
+            /* When a push callback is set, redisGetReply (hiredis) loops until
+             * an in-band message is received, but these commands are confirmed
+             * using push replies only. There is one push reply per channel if
+             * channels are specified, otherwise at least one. */
+            num_expected_pubsub_push = argc > 1 ? argc - 1 : 1;
+            /* Unset our default PUSH handler so this works in RESP2/RESP3 */
+            redisSetPushCallback(context, NULL);
+        }
+
+        if (config.replica_mode) {
+            printf("Entering replica output mode...  (press Ctrl-C to quit)\n");
+            replicaMode(0);
+            config.replica_mode = 0;
+            zfree(argvlen);
+            return REDIS_ERR; /* Error = replilcaMode lost connection to primary */
+        }
+
+        /* Read response, possibly skipping pubsub/push messages. */
+        while (1) {
+            if (cliReadReply(output_raw) != REDIS_OK) {
+                zfree(argvlen);
+                return REDIS_ERR;
+            }
+            fflush(stdout);
+            if (config.pubsub_mode || num_expected_pubsub_push > 0) {
+                if (isPubsubPush(config.last_reply)) {
+                    handlePubSubMode(config.last_reply);
+
+                    if (num_expected_pubsub_push > 0 && !strcasecmp(config.last_reply->element[0]->str, command)) {
+                        /* This pushed message confirms the
+                         * [p|s][un]subscribe command. */
+                        if (--num_expected_pubsub_push > 0) {
+                            continue; /* We need more of these. */
+                        }
+                    } else {
+                        continue; /* Skip this pubsub message. */
+                    }
+                } else if (config.last_reply->type == REDIS_REPLY_PUSH) {
+                    continue; /* Skip other push message. */
+                }
+            }
+
+            /* Store database number when SELECT was successfully executed. */
+            if (!strcasecmp(command, "select") && argc == 2 && config.last_cmd_type != REDIS_REPLY_ERROR) {
+                config.conn_info.input_dbnum = config.dbnum = atoi(argv[1]);
+                cliRefreshPrompt();
+            } else if (!strcasecmp(command, "auth") && (argc == 2 || argc == 3)) {
+                cliSelect();
+            } else if (!strcasecmp(command, "multi") && argc == 1 && config.last_cmd_type != REDIS_REPLY_ERROR) {
+                config.in_multi = 1;
+                config.pre_multi_dbnum = config.dbnum;
+                cliRefreshPrompt();
+            } else if (!strcasecmp(command, "exec") && argc == 1 && config.in_multi) {
+                config.in_multi = 0;
+                if (config.last_cmd_type == REDIS_REPLY_ERROR || config.last_cmd_type == REDIS_REPLY_NIL) {
+                    config.conn_info.input_dbnum = config.dbnum = config.pre_multi_dbnum;
+                }
+                cliRefreshPrompt();
+            } else if (!strcasecmp(command, "discard") && argc == 1 && config.last_cmd_type != REDIS_REPLY_ERROR) {
+                config.in_multi = 0;
+                config.conn_info.input_dbnum = config.dbnum = config.pre_multi_dbnum;
+                cliRefreshPrompt();
+            } else if (!strcasecmp(command, "reset") && argc == 1 && config.last_cmd_type != REDIS_REPLY_ERROR) {
+                config.in_multi = 0;
+                config.dbnum = 0;
+                config.conn_info.input_dbnum = 0;
+                config.current_resp3 = 0;
+                if (config.pubsub_mode && config.push_output) {
+                    redisSetPushCallback(context, cliPushHandler);
+                }
+                config.pubsub_mode = 0;
+                cliRefreshPrompt();
+            } else if (!strcasecmp(command, "hello")) {
+                if (config.last_cmd_type == REDIS_REPLY_MAP) {
+                    config.current_resp3 = 1;
+                } else if (config.last_cmd_type == REDIS_REPLY_ARRAY) {
+                    config.current_resp3 = 0;
+                }
+            } else if ((is_subscribe || is_unsubscribe) && !config.pubsub_mode) {
+                /* We didn't enter pubsub mode. Restore push callback. */
+                if (config.push_output) redisSetPushCallback(context, cliPushHandler);
+            }
+
+            break;
+        }
+        if (config.cluster_reissue_command) {
+            /* If we need to reissue the command, break to prevent a
+               further 'repeat' number of dud interactions */
+            break;
+        }
+        if (config.interval) usleep(config.interval);
+        fflush(stdout); /* Make it grep friendly */
+    }
+
+    zfree(argvlen);
+    return REDIS_OK;
+}
+
+/* Send a command reconnecting the link if needed. */
+static redisReply *reconnectingRedisCommand(redisContext *c, const char *fmt, ...) {
+    redisReply *reply = NULL;
+    int tries = 0;
+    va_list ap;
+
+    assert(!c->err);
+    while (reply == NULL) {
+        while (c->err & (REDIS_ERR_IO | REDIS_ERR_EOF)) {
+            printf("\r\x1b[0K"); /* Cursor to left edge + clear line. */
+            printf("Reconnecting... %d\r", ++tries);
+            fflush(stdout);
+
+            redisFree(c);
+            c = redisConnectWrapper(config.conn_info.hostip, config.conn_info.hostport, config.connect_timeout);
+            if (!c->err && config.tls) {
+                const char *err = NULL;
+                if (cliSecureConnection(c, config.sslconfig, &err) == REDIS_ERR && err) {
+                    fprintf(stderr, "TLS Error: %s\n", err);
+                    exit(1);
+                }
+            }
+            usleep(1000000);
+        }
+
+        va_start(ap, fmt);
+        reply = redisvCommand(c, fmt, ap);
+        va_end(ap);
+
+        if (c->err && !(c->err & (REDIS_ERR_IO | REDIS_ERR_EOF))) {
+            fprintf(stderr, "Error: %s\n", c->errstr);
+            exit(1);
+        } else if (tries > 0) {
+            printf("\r\x1b[0K"); /* Cursor to left edge + clear line. */
+        }
+    }
+
+    context = c;
+    return reply;
+}
+
+/*------------------------------------------------------------------------------
+ * User interface
+ *--------------------------------------------------------------------------- */
+
+static int parseOptions(int argc, char **argv) {
+    int i;
+
+    for (i = 1; i < argc; i++) {
+        int lastarg = i == argc - 1;
+
+        if (!strcmp(argv[i], "-h") && !lastarg) {
+            sdsfree(config.conn_info.hostip);
+            config.conn_info.hostip = sdsnew(argv[++i]);
+        } else if (!strcmp(argv[i], "-h") && lastarg) {
+            usage(0);
+        } else if (!strcmp(argv[i], "--help")) {
+            usage(0);
+        } else if (!strcmp(argv[i], "-x")) {
+            config.stdin_lastarg = 1;
+        } else if (!strcmp(argv[i], "-X") && !lastarg) {
+            config.stdin_tag_arg = 1;
+            config.stdin_tag_name = argv[++i];
+        } else if (!strcmp(argv[i], "-p") && !lastarg) {
+            config.conn_info.hostport = atoi(argv[++i]);
+            if (config.conn_info.hostport < 0 || config.conn_info.hostport > 65535) {
+                fprintf(stderr, "Invalid server port.\n");
+                exit(1);
+            }
+        } else if (!strcmp(argv[i], "-t") && !lastarg) {
+            errno = 0;
+            char *eptr;
+            double seconds = valkey_strtod(argv[++i], &eptr);
+            if (eptr[0] != '\0' || isnan(seconds) || seconds < 0.0 || errno == EINVAL || errno == ERANGE) {
+                fprintf(stderr, "Invalid connection timeout for -t.\n");
+                exit(1);
+            }
+            config.connect_timeout.tv_sec = (long long)seconds;
+            config.connect_timeout.tv_usec = ((long long)(seconds * 1000000)) % 1000000;
+        } else if (!strcmp(argv[i], "-s") && !lastarg) {
+            config.hostsocket = argv[++i];
+        } else if (!strcmp(argv[i], "-r") && !lastarg) {
+            config.repeat = strtoll(argv[++i], NULL, 10);
+        } else if (!strcmp(argv[i], "-i") && !lastarg) {
+            double seconds = atof(argv[++i]);
+            config.interval = seconds * 1000000;
+        } else if (!strcmp(argv[i], "-n") && !lastarg) {
+            config.conn_info.input_dbnum = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--no-auth-warning")) {
+            config.no_auth_warning = 1;
+        } else if (!strcmp(argv[i], "--askpass")) {
+            config.askpass = 1;
+        } else if ((!strcmp(argv[i], "-a") || !strcmp(argv[i], "--pass")) && !lastarg) {
+            config.conn_info.auth = sdsnew(argv[++i]);
+        } else if (!strcmp(argv[i], "--user") && !lastarg) {
+            config.conn_info.user = sdsnew(argv[++i]);
+        } else if (!strcmp(argv[i], "-u") && !lastarg) {
+            parseRedisUri(argv[++i], "valkey-cli", &config.conn_info, &config.tls);
+            if (config.conn_info.hostport < 0 || config.conn_info.hostport > 65535) {
+                fprintf(stderr, "Invalid server port.\n");
+                exit(1);
+            }
+        } else if (!strcmp(argv[i], "--raw")) {
+            config.output = OUTPUT_RAW;
+        } else if (!strcmp(argv[i], "--no-raw")) {
+            config.output = OUTPUT_STANDARD;
+        } else if (!strcmp(argv[i], "--quoted-input")) {
+            config.quoted_input = 1;
+        } else if (!strcmp(argv[i], "--csv")) {
+            config.output = OUTPUT_CSV;
+        } else if (!strcmp(argv[i], "--json")) {
+            /* Not overwrite explicit value by -3 */
+            if (config.resp3 == 0) {
+                config.resp3 = 2;
+            }
+            config.output = OUTPUT_JSON;
+        } else if (!strcmp(argv[i], "--quoted-json")) {
+            /* Not overwrite explicit value by -3*/
+            if (config.resp3 == 0) {
+                config.resp3 = 2;
+            }
+            config.output = OUTPUT_QUOTED_JSON;
+        } else if (!strcmp(argv[i], "--latency")) {
+            config.latency_mode = 1;
+        } else if (!strcmp(argv[i], "--latency-dist")) {
+            config.latency_dist_mode = 1;
+        } else if (!strcmp(argv[i], "--mono")) {
+            spectrum_palette = spectrum_palette_mono;
+            spectrum_palette_size = spectrum_palette_mono_size;
+        } else if (!strcmp(argv[i], "--latency-history")) {
+            config.latency_mode = 1;
+            config.latency_history = 1;
+        } else if (!strcmp(argv[i], "--lru-test") && !lastarg) {
+            config.lru_test_mode = 1;
+            config.lru_test_sample_size = strtoll(argv[++i], NULL, 10);
+        } else if (!strcmp(argv[i], "--slave") || !strcmp(argv[i], "--replica")) {
+            config.replica_mode = 1;
+        } else if (!strcmp(argv[i], "--stat")) {
+            config.stat_mode = 1;
+        } else if (!strcmp(argv[i], "--scan")) {
+            config.scan_mode = 1;
+        } else if (!strcmp(argv[i], "--pattern") && !lastarg) {
+            sdsfree(config.pattern);
+            config.pattern = sdsnew(argv[++i]);
+        } else if (!strcmp(argv[i], "--count") && !lastarg) {
+            config.count = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--quoted-pattern") && !lastarg) {
+            sdsfree(config.pattern);
+            config.pattern = unquoteCString(argv[++i]);
+            if (!config.pattern) {
+                fprintf(stderr, "Invalid quoted string specified for --quoted-pattern.\n");
+                exit(1);
+            }
+        } else if (!strcmp(argv[i], "--intrinsic-latency") && !lastarg) {
+            config.intrinsic_latency_mode = 1;
+            config.intrinsic_latency_duration = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--rdb") && !lastarg) {
+            config.getrdb_mode = 1;
+            config.rdb_filename = argv[++i];
+        } else if (!strcmp(argv[i], "--functions-rdb") && !lastarg) {
+            config.get_functions_rdb_mode = 1;
+            config.rdb_filename = argv[++i];
+        } else if (!strcmp(argv[i], "--pipe")) {
+            config.pipe_mode = 1;
+        } else if (!strcmp(argv[i], "--pipe-timeout") && !lastarg) {
+            config.pipe_timeout = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--bigkeys")) {
+            config.bigkeys = 1;
+        } else if (!strcmp(argv[i], "--memkeys")) {
+            config.memkeys = 1;
+            config.memkeys_samples = 0; /* use the server default */
+        } else if (!strcmp(argv[i], "--memkeys-samples") && !lastarg) {
+            config.memkeys = 1;
+            config.memkeys_samples = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--hotkeys")) {
+            config.hotkeys = 1;
+        } else if (!strcmp(argv[i], "--eval") && !lastarg) {
+            config.eval = argv[++i];
+        } else if (!strcmp(argv[i], "--ldb")) {
+            config.eval_ldb = 1;
+            config.output = OUTPUT_RAW;
+        } else if (!strcmp(argv[i], "--ldb-sync-mode")) {
+            config.eval_ldb = 1;
+            config.eval_ldb_sync = 1;
+            config.output = OUTPUT_RAW;
+        } else if (!strcmp(argv[i], "-c")) {
+            config.cluster_mode = 1;
+        } else if (!strcmp(argv[i], "-d") && !lastarg) {
+            sdsfree(config.mb_delim);
+            config.mb_delim = sdsnew(argv[++i]);
+        } else if (!strcmp(argv[i], "-D") && !lastarg) {
+            sdsfree(config.cmd_delim);
+            config.cmd_delim = sdsnew(argv[++i]);
+        } else if (!strcmp(argv[i], "-e")) {
+            config.set_errcode = 1;
+        } else if (!strcmp(argv[i], "--verbose")) {
+            config.verbose = 1;
+        } else if (!strcmp(argv[i], "-4")) {
+            config.prefer_ipv4 = 1;
+        } else if (!strcmp(argv[i], "-6")) {
+            config.prefer_ipv6 = 1;
+        } else if (!strcmp(argv[i], "--cluster") && !lastarg) {
+            if (CLUSTER_MANAGER_MODE()) usage(1);
+            char *cmd = argv[++i];
+            int j = i;
+            while (j < argc && argv[j][0] != '-') j++;
+            if (j > i) j--;
+            int err = createClusterManagerCommand(cmd, j - i, argv + i + 1);
+            if (err) exit(err);
+            i = j;
+        } else if (!strcmp(argv[i], "--cluster") && lastarg) {
+            usage(1);
+        } else if (!strcmp(argv[i], "--cluster-only-masters") || !strcmp(argv[i], "--cluster-only-primaries")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_PRIMARIES_ONLY;
+        } else if ((!strcmp(argv[i], "--cluster-only-replicas"))) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_REPLICAS_ONLY;
+        } else if (!strcmp(argv[i], "--cluster-replicas") && !lastarg) {
+            config.cluster_manager_command.replicas = atoi(argv[++i]);
+        } else if ((!strcmp(argv[i], "--cluster-master-id") || !strcmp(argv[i], "--cluster-primary-id")) && !lastarg) {
+            config.cluster_manager_command.primary_id = argv[++i];
+        } else if (!strcmp(argv[i], "--cluster-from") && !lastarg) {
+            config.cluster_manager_command.from = argv[++i];
+        } else if (!strcmp(argv[i], "--cluster-to") && !lastarg) {
+            config.cluster_manager_command.to = argv[++i];
+        } else if (!strcmp(argv[i], "--cluster-from-user") && !lastarg) {
+            config.cluster_manager_command.from_user = argv[++i];
+        } else if (!strcmp(argv[i], "--cluster-from-pass") && !lastarg) {
+            config.cluster_manager_command.from_pass = argv[++i];
+        } else if (!strcmp(argv[i], "--cluster-from-askpass")) {
+            config.cluster_manager_command.from_askpass = 1;
+        } else if (!strcmp(argv[i], "--cluster-weight") && !lastarg) {
+            if (config.cluster_manager_command.weight != NULL) {
+                fprintf(stderr, "WARNING: you cannot use --cluster-weight "
+                                "more than once.\n"
+                                "You can set more weights by adding them "
+                                "as a space-separated list, ie:\n"
+                                "--cluster-weight n1=w n2=w\n");
+                exit(1);
+            }
+            int widx = i + 1;
+            char **weight = argv + widx;
+            int wargc = 0;
+            for (; widx < argc; widx++) {
+                if (strstr(argv[widx], "--") == argv[widx]) break;
+                if (strchr(argv[widx], '=') == NULL) break;
+                wargc++;
+            }
+            if (wargc > 0) {
+                config.cluster_manager_command.weight = weight;
+                config.cluster_manager_command.weight_argc = wargc;
+                i += wargc;
+            }
+        } else if (!strcmp(argv[i], "--cluster-slots") && !lastarg) {
+            config.cluster_manager_command.slots = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--cluster-timeout") && !lastarg) {
+            config.cluster_manager_command.timeout = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--cluster-pipeline") && !lastarg) {
+            config.cluster_manager_command.pipeline = atoi(argv[++i]);
+        } else if (!strcmp(argv[i], "--cluster-threshold") && !lastarg) {
+            config.cluster_manager_command.threshold = atof(argv[++i]);
+        } else if (!strcmp(argv[i], "--cluster-yes")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_YES;
+        } else if (!strcmp(argv[i], "--cluster-simulate")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_SIMULATE;
+        } else if (!strcmp(argv[i], "--cluster-replace")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_REPLACE;
+        } else if (!strcmp(argv[i], "--cluster-copy")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_COPY;
+        } else if (!strcmp(argv[i], "--cluster-slave") || !strcmp(argv[i], "--cluster-replica")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_REPLICA;
+        } else if (!strcmp(argv[i], "--cluster-use-empty-masters") ||
+                   !strcmp(argv[i], "--cluster-use-empty-primaries")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_EMPTY_PRIMARY;
+        } else if (!strcmp(argv[i], "--cluster-search-multiple-owners")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_CHECK_OWNERS;
+        } else if (!strcmp(argv[i], "--cluster-fix-with-unreachable-masters") ||
+                   !strcmp(argv[i], "--cluster-fix-with-unreachable-primaries")) {
+            config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_FIX_WITH_UNREACHABLE_PRIMARIES;
+        } else if (!strcmp(argv[i], "--test_hint") && !lastarg) {
+            config.test_hint = argv[++i];
+        } else if (!strcmp(argv[i], "--test_hint_file") && !lastarg) {
+            config.test_hint_file = argv[++i];
+#ifdef USE_OPENSSL
+        } else if (!strcmp(argv[i], "--tls")) {
+            config.tls = 1;
+        } else if (!strcmp(argv[i], "--sni") && !lastarg) {
+            config.sslconfig.sni = argv[++i];
+        } else if (!strcmp(argv[i], "--cacertdir") && !lastarg) {
+            config.sslconfig.cacertdir = argv[++i];
+        } else if (!strcmp(argv[i], "--cacert") && !lastarg) {
+            config.sslconfig.cacert = argv[++i];
+        } else if (!strcmp(argv[i], "--cert") && !lastarg) {
+            config.sslconfig.cert = argv[++i];
+        } else if (!strcmp(argv[i], "--key") && !lastarg) {
+            config.sslconfig.key = argv[++i];
+        } else if (!strcmp(argv[i], "--tls-ciphers") && !lastarg) {
+            config.sslconfig.ciphers = argv[++i];
+        } else if (!strcmp(argv[i], "--insecure")) {
+            config.sslconfig.skip_cert_verify = 1;
+#ifdef TLS1_3_VERSION
+        } else if (!strcmp(argv[i], "--tls-ciphersuites") && !lastarg) {
+            config.sslconfig.ciphersuites = argv[++i];
+#endif
+#endif
+        } else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) {
+            sds version = cliVersion();
+            printf("valkey-cli %s\n", version);
+            sdsfree(version);
+            exit(0);
+        } else if (!strcmp(argv[i], "-2")) {
+            config.resp2 = 1;
+        } else if (!strcmp(argv[i], "-3")) {
+            config.resp3 = 1;
+        } else if (!strcmp(argv[i], "--show-pushes") && !lastarg) {
+            char *argval = argv[++i];
+            if (!strncasecmp(argval, "n", 1)) {
+                config.push_output = 0;
+            } else if (!strncasecmp(argval, "y", 1)) {
+                config.push_output = 1;
+            } else {
+                fprintf(stderr,
+                        "Unknown --show-pushes value '%s' "
+                        "(valid: '[y]es', '[n]o')\n",
+                        argval);
+            }
+        } else if (CLUSTER_MANAGER_MODE() && argv[i][0] != '-') {
+            if (config.cluster_manager_command.argc == 0) {
+                int j = i + 1;
+                while (j < argc && argv[j][0] != '-') j++;
+                int cmd_argc = j - i;
+                config.cluster_manager_command.argc = cmd_argc;
+                config.cluster_manager_command.argv = argv + i;
+                if (cmd_argc > 1) i = j - 1;
+            }
+        } else {
+            if (argv[i][0] == '-') {
+                fprintf(stderr, "Unrecognized option or bad number of args for: '%s'\n", argv[i]);
+                exit(1);
+            } else {
+                /* Likely the command name, stop here. */
+                break;
+            }
+        }
+    }
+
+    if (config.hostsocket && config.cluster_mode) {
+        fprintf(stderr, "Options -c and -s are mutually exclusive.\n");
+        exit(1);
+    }
+
+    if (config.resp2 && config.resp3 == 1) {
+        fprintf(stderr, "Options -2 and -3 are mutually exclusive.\n");
+        exit(1);
+    }
+
+    /* --ldb requires --eval. */
+    if (config.eval_ldb && config.eval == NULL) {
+        fprintf(stderr, "Options --ldb and --ldb-sync-mode require --eval.\n");
+        fprintf(stderr, "Try %s --help for more information.\n", argv[0]);
+        exit(1);
+    }
+
+    if (!config.no_auth_warning && config.conn_info.auth != NULL) {
+        fputs("Warning: Using a password with '-a' or '-u' option on the command"
+              " line interface may not be safe.\n",
+              stderr);
+    }
+
+    if (config.get_functions_rdb_mode && config.getrdb_mode) {
+        fprintf(stderr, "Option --functions-rdb and --rdb are mutually exclusive.\n");
+        exit(1);
+    }
+
+    if (config.stdin_lastarg && config.stdin_tag_arg) {
+        fprintf(stderr, "Options -x and -X are mutually exclusive.\n");
+        exit(1);
+    }
+
+    if (config.prefer_ipv4 && config.prefer_ipv6) {
+        fprintf(stderr, "Options -4 and -6 are mutually exclusive.\n");
+        exit(1);
+    }
+
+    return i;
+}
+
+static void parseEnv(void) {
+    /* Set auth from env, but do not overwrite CLI arguments if passed */
+    char *auth = getenv(CLI_AUTH_ENV);
+    if (auth != NULL && config.conn_info.auth == NULL) {
+        config.conn_info.auth = auth;
+    }
+
+    char *cluster_yes = getenv(CLI_CLUSTER_YES_ENV);
+    if (cluster_yes != NULL && !strcmp(cluster_yes, "1")) {
+        config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_YES;
+    }
+}
+
+static void usage(int err) {
+    sds version = cliVersion();
+    FILE *target = err ? stderr : stdout;
+    const char *tls_usage =
+#ifdef USE_OPENSSL
+        "  --tls              Establish a secure TLS connection.\n"
+        "  --sni <host>       Server name indication for TLS.\n"
+        "  --cacert <file>    CA Certificate file to verify with.\n"
+        "  --cacertdir <dir>  Directory where trusted CA certificates are stored.\n"
+        "                     If neither cacert nor cacertdir are specified, the default\n"
+        "                     system-wide trusted root certs configuration will apply.\n"
+        "  --insecure         Allow insecure TLS connection by skipping cert validation.\n"
+        "  --cert <file>      Client certificate to authenticate with.\n"
+        "  --key <file>       Private key file to authenticate with.\n"
+        "  --tls-ciphers <list> Sets the list of preferred ciphers (TLSv1.2 and below)\n"
+        "                     in order of preference from highest to lowest separated by colon (\":\").\n"
+        "                     See the ciphers(1ssl) manpage for more information about the syntax of this string.\n"
+#ifdef TLS1_3_VERSION
+        "  --tls-ciphersuites <list> Sets the list of preferred ciphersuites (TLSv1.3)\n"
+        "                     in order of preference from highest to lowest separated by colon (\":\").\n"
+        "                     See the ciphers(1ssl) manpage for more information about the syntax of this string,\n"
+        "                     and specifically for TLSv1.3 ciphersuites.\n"
+#endif
+#endif
+        "";
+
+    fprintf(target,
+            "valkey-cli %s\n"
+            "\n"
+            "Usage: valkey-cli [OPTIONS] [cmd [arg [arg ...]]]\n"
+            "  -h <hostname>      Server hostname (default: 127.0.0.1).\n"
+            "  -p <port>          Server port (default: 6379).\n"
+            "  -t <timeout>       Server connection timeout in seconds (decimals allowed).\n"
+            "                     Default timeout is 0, meaning no limit, depending on the OS.\n"
+            "  -s <socket>        Server socket (overrides hostname and port).\n"
+            "  -a <password>      Password to use when connecting to the server.\n"
+            "                     You can also use the " CLI_AUTH_ENV " environment\n"
+            "                     variable to pass this password more safely\n"
+            "                     (if both are used, this argument takes precedence).\n"
+            "  --user <username>  Used to send ACL style 'AUTH username pass'. Needs -a.\n"
+            "  --pass <password>  Alias of -a for consistency with the new --user option.\n"
+            "  --askpass          Force user to input password with mask from STDIN.\n"
+            "                     If this argument is used, '-a' and " CLI_AUTH_ENV "\n"
+            "                     environment variable will be ignored.\n"
+            "  -u <uri>           Server URI on format valkey://user:password@host:port/dbnum\n"
+            "                     User, password and dbnum are optional. For authentication\n"
+            "                     without a username, use username 'default'. For TLS, use\n"
+            "                     the scheme 'valkeys'.\n"
+            "  -r <repeat>        Execute specified command N times.\n"
+            "  -i <interval>      When -r is used, waits <interval> seconds per command.\n"
+            "                     It is possible to specify sub-second times like -i 0.1.\n"
+            "                     This interval is also used in --scan and --stat per cycle.\n"
+            "                     and in --bigkeys, --memkeys, and --hotkeys per 100 cycles.\n"
+            "  -n <db>            Database number.\n"
+            "  -2                 Start session in RESP2 protocol mode.\n"
+            "  -3                 Start session in RESP3 protocol mode.\n"
+            "  -x                 Read last argument from STDIN (see example below).\n"
+            "  -X                 Read <tag> argument from STDIN (see example below).\n"
+            "  -d <delimiter>     Delimiter between response bulks for raw formatting (default: \\n).\n"
+            "  -D <delimiter>     Delimiter between responses for raw formatting (default: \\n).\n"
+            "  -c                 Enable cluster mode (follow -ASK and -MOVED redirections).\n"
+            "  -e                 Return exit error code when command execution fails.\n"
+            "  -4                 Prefer IPv4 over IPv6 on DNS lookup.\n"
+            "  -6                 Prefer IPv6 over IPv4 on DNS lookup.\n"
+            "%s"
+            "  --raw              Use raw formatting for replies (default when STDOUT is\n"
+            "                     not a tty).\n"
+            "  --no-raw           Force formatted output even when STDOUT is not a tty.\n"
+            "  --quoted-input     Force input to be handled as quoted strings.\n"
+            "  --csv              Output in CSV format.\n"
+            "  --json             Output in JSON format (default RESP3, use -2 if you want to use with RESP2).\n"
+            "  --quoted-json      Same as --json, but produce ASCII-safe quoted strings, not Unicode.\n"
+            "  --show-pushes <yn> Whether to print RESP3 PUSH messages.  Enabled by default when\n"
+            "                     STDOUT is a tty but can be overridden with --show-pushes no.\n"
+            "  --stat             Print rolling stats about server: mem, clients, ...\n",
+            version, tls_usage);
+
+    fprintf(target,
+            "  --latency          Enter a special mode continuously sampling latency.\n"
+            "                     If you use this mode in an interactive session it runs\n"
+            "                     forever displaying real-time stats. Otherwise if --raw or\n"
+            "                     --csv is specified, or if you redirect the output to a non\n"
+            "                     TTY, it samples the latency for 1 second (you can use\n"
+            "                     -i to change the interval), then produces a single output\n"
+            "                     and exits.\n"
+            "  --latency-history  Like --latency but tracking latency changes over time.\n"
+            "                     Default time interval is 15 sec. Change it using -i.\n"
+            "  --latency-dist     Shows latency as a spectrum, requires xterm 256 colors.\n"
+            "                     Default time interval is 1 sec. Change it using -i.\n"
+            "  --lru-test <keys>  Simulate a cache workload with an 80-20 distribution.\n"
+            "  --replica          Simulate a replica showing commands received from the primaries.\n"
+            "  --rdb <filename>   Transfer an RDB dump from remote server to local file.\n"
+            "                     Use filename of \"-\" to write to stdout.\n"
+            "  --functions-rdb <filename> Like --rdb but only get the functions (not the keys)\n"
+            "                     when getting the RDB dump file.\n"
+            "  --pipe             Transfer raw RESP protocol from stdin to server.\n"
+            "  --pipe-timeout <n> In --pipe mode, abort with error if after sending all data.\n"
+            "                     no reply is received within <n> seconds.\n"
+            "                     Default timeout: %d. Use 0 to wait forever.\n",
+            CLI_DEFAULT_PIPE_TIMEOUT);
+    fprintf(target,
+            "  --bigkeys          Sample keys looking for keys with many elements (complexity).\n"
+            "  --memkeys          Sample keys looking for keys consuming a lot of memory.\n"
+            "  --memkeys-samples <n> Sample keys looking for keys consuming a lot of memory.\n"
+            "                     And define number of key elements to sample\n"
+            "  --hotkeys          Sample keys looking for hot keys.\n"
+            "                     only works when maxmemory-policy is *lfu.\n"
+            "  --scan             List all keys using the SCAN command.\n"
+            "  --pattern <pat>    Keys pattern when using the --scan, --bigkeys or --hotkeys\n"
+            "                     options (default: *).\n"
+            "  --count <count>    Count option when using the --scan, --bigkeys or --hotkeys (default: 10).\n"
+            "  --quoted-pattern <pat> Same as --pattern, but the specified string can be\n"
+            "                         quoted, in order to pass an otherwise non binary-safe string.\n"
+            "  --intrinsic-latency <sec> Run a test to measure intrinsic system latency.\n"
+            "                     The test will run for the specified amount of seconds.\n"
+            "  --eval <file>      Send an EVAL command using the Lua script at <file>.\n"
+            "  --ldb              Used with --eval enable the Server Lua debugger.\n"
+            "  --ldb-sync-mode    Like --ldb but uses the synchronous Lua debugger, in\n"
+            "                     this mode the server is blocked and script changes are\n"
+            "                     not rolled back from the server memory.\n"
+            "  --cluster <command> [args...] [opts...]\n"
+            "                     Cluster Manager command and arguments (see below).\n"
+            "  --verbose          Verbose mode.\n"
+            "  --no-auth-warning  Don't show warning message when using password on command\n"
+            "                     line interface.\n"
+            "  --help             Output this help and exit.\n"
+            "  --version          Output version and exit.\n"
+            "\n");
+    /* Using another fprintf call to avoid -Woverlength-strings compile warning */
+    fprintf(target,
+            "Cluster Manager Commands:\n"
+            "  Use --cluster help to list all available cluster manager commands.\n"
+            "\n"
+            "Examples:\n"
+            "  valkey-cli -u valkey://default:PASSWORD@localhost:6379/0\n"
+            "  cat /etc/passwd | valkey-cli -x set mypasswd\n"
+            "  valkey-cli -D \"\" --raw dump key > key.dump && valkey-cli -X dump_tag restore key2 0 dump_tag replace < key.dump\n"
+            "  valkey-cli -r 100 lpush mylist x\n"
+            "  valkey-cli -r 100 -i 1 info | grep used_memory_human:\n"
+            "  valkey-cli --quoted-input set '\"null-\\x00-separated\"' value\n"
+            "  valkey-cli --eval myscript.lua key1 key2 , arg1 arg2 arg3\n"
+            "  valkey-cli --scan --pattern '*:12345*'\n"
+            "  valkey-cli --scan --pattern '*:12345*' --count 100\n"
+            "\n"
+            "  (Note: when using --eval the comma separates KEYS[] from ARGV[] items)\n"
+            "\n"
+            "When no command is given, valkey-cli starts in interactive mode.\n"
+            "Type \"help\" in interactive mode for information on available commands\n"
+            "and settings.\n"
+            "\n");
+    sdsfree(version);
+    exit(err);
+}
+
+static int confirmWithYes(char *msg, int ignore_force) {
+    /* if --cluster-yes option is set and ignore_force is false,
+     * do not prompt for an answer */
+    if (!ignore_force && (config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_YES)) {
+        return 1;
+    }
+
+    printf("%s (type 'yes' to accept): ", msg);
+    fflush(stdout);
+    char buf[4];
+    int nread = read(fileno(stdin), buf, 4);
+    buf[3] = '\0';
+    return (nread != 0 && !strcmp("yes", buf));
+}
+
+static int issueCommandRepeat(int argc, char **argv, long repeat) {
+    /* In Lua debugging mode, we want to pass the "help" to the server to get
+     * it's own HELP message, rather than handle it by the CLI, see ldbRepl.
+     *
+     * For the normal server HELP, we can process it without a connection. */
+    if (!config.eval_ldb && (!strcasecmp(argv[0], "help") || !strcasecmp(argv[0], "?"))) {
+        cliOutputHelp(--argc, ++argv);
+        return REDIS_OK;
+    }
+
+    while (1) {
+        if (config.cluster_reissue_command || context == NULL || context->err == REDIS_ERR_IO ||
+            context->err == REDIS_ERR_EOF) {
+            if (cliConnect(CC_FORCE) != REDIS_OK) {
+                cliPrintContextError();
+                config.cluster_reissue_command = 0;
+                return REDIS_ERR;
+            }
+        }
+        config.cluster_reissue_command = 0;
+        if (config.cluster_send_asking) {
+            if (cliSendAsking() != REDIS_OK) {
+                cliPrintContextError();
+                return REDIS_ERR;
+            }
+        }
+        if (cliSendCommand(argc, argv, repeat) != REDIS_OK) {
+            cliPrintContextError();
+            redisFree(context);
+            context = NULL;
+            return REDIS_ERR;
+        }
+
+        /* Issue the command again if we got redirected in cluster mode */
+        if (config.cluster_mode && config.cluster_reissue_command) {
+            continue;
+        }
+        break;
+    }
+    return REDIS_OK;
+}
+
+static int issueCommand(int argc, char **argv) {
+    return issueCommandRepeat(argc, argv, config.repeat);
+}
+
+/* Split the user provided command into multiple SDS arguments.
+ * This function normally uses sdssplitargs() from sds.c which is able
+ * to understand "quoted strings", escapes and so forth. However when
+ * we are in Lua debugging mode and the "eval" command is used, we want
+ * the remaining Lua script (after "e " or "eval ") to be passed verbatim
+ * as a single big argument. */
+static sds *cliSplitArgs(char *line, int *argc) {
+    if (config.eval_ldb && (strstr(line, "eval ") == line || strstr(line, "e ") == line)) {
+        sds *argv = sds_malloc(sizeof(sds) * 2);
+        *argc = 2;
+        int len = strlen(line);
+        int elen = line[1] == ' ' ? 2 : 5; /* "e " or "eval "? */
+        argv[0] = sdsnewlen(line, elen - 1);
+        argv[1] = sdsnewlen(line + elen, len - elen);
+        return argv;
+    } else {
+        return sdssplitargs(line, argc);
+    }
+}
+
+/* Set the CLI preferences. This function is invoked when an interactive
+ * ":command" is called, or when reading ~/.valkeyclirc file, in order to
+ * set user preferences. */
+void cliSetPreferences(char **argv, int argc, int interactive) {
+    if (!strcasecmp(argv[0], ":set") && argc >= 2) {
+        if (!strcasecmp(argv[1], "hints"))
+            pref.hints = 1;
+        else if (!strcasecmp(argv[1], "nohints"))
+            pref.hints = 0;
+        else {
+            printf("%sunknown valkey-cli preference '%s'\n", interactive ? "" : ".valkeyclirc: ", argv[1]);
+        }
+    } else if (!strcasecmp(argv[0], ":get") && argc >= 2) {
+        if (!strcasecmp(argv[1], "pubsub")) {
+            printf("%d\n", config.pubsub_mode);
+        } else {
+            printf("%sunknown valkey-cli get option '%s'\n", interactive ? "" : ".valkeyclirc: ", argv[1]);
+        }
+        fflush(stdout);
+    } else {
+        printf("%sunknown valkey-cli internal command '%s'\n", interactive ? "" : ".valkeyclirc: ", argv[0]);
+    }
+}
+
+/* Load the ~/.valkeyclirc file if any. */
+void cliLoadPreferences(void) {
+    sds rcfile = getDotfilePath(CLI_RCFILE_ENV, CLI_RCFILE_DEFAULT);
+    if (rcfile == NULL) return;
+    FILE *fp = fopen(rcfile, "r");
+    char buf[1024];
+
+    if (fp) {
+        while (fgets(buf, sizeof(buf), fp) != NULL) {
+            sds *argv;
+            int argc;
+
+            argv = sdssplitargs(buf, &argc);
+            if (argc > 0) cliSetPreferences(argv, argc, 0);
+            sdsfreesplitres(argv, argc);
+        }
+        fclose(fp);
+    }
+    sdsfree(rcfile);
+}
+
+/* Some commands can include sensitive information and shouldn't be put in the
+ * history file. Currently these commands are include:
+ * - AUTH
+ * - ACL DELUSER, ACL SETUSER, ACL GETUSER
+ * - CONFIG SET primaryauth/primaryuser/tls-key-file-pass/tls-client-key-file-pass/requirepass
+ * - HELLO with [AUTH username password]
+ * - MIGRATE with [AUTH password] or [AUTH2 username password]
+ * - SENTINEL CONFIG SET sentinel-pass password, SENTINEL CONFIG SET sentinel-user username
+ * - SENTINEL SET <primaryname> auth-pass password, SENTINEL SET <primaryname> auth-user username */
+static int isSensitiveCommand(int argc, char **argv) {
+    if (!strcasecmp(argv[0], "auth")) {
+        return 1;
+    } else if (argc > 1 && !strcasecmp(argv[0], "acl") &&
+               (!strcasecmp(argv[1], "deluser") || !strcasecmp(argv[1], "setuser") ||
+                !strcasecmp(argv[1], "getuser"))) {
+        return 1;
+    } else if (argc > 2 && !strcasecmp(argv[0], "config") && !strcasecmp(argv[1], "set")) {
+        for (int j = 2; j < argc; j = j + 2) {
+            if (!strcasecmp(argv[j], "masterauth") || !strcasecmp(argv[j], "masteruser") ||
+                !strcasecmp(argv[j], "primaryuser") || !strcasecmp(argv[j], "primaryauth") ||
+                !strcasecmp(argv[j], "tls-key-file-pass") || !strcasecmp(argv[j], "tls-client-key-file-pass") ||
+                !strcasecmp(argv[j], "requirepass")) {
+                return 1;
+            }
+        }
+        return 0;
+        /* HELLO [protover [AUTH username password] [SETNAME clientname]] */
+    } else if (argc > 4 && !strcasecmp(argv[0], "hello")) {
+        for (int j = 2; j < argc; j++) {
+            int moreargs = argc - 1 - j;
+            if (!strcasecmp(argv[j], "AUTH") && moreargs >= 2) {
+                return 1;
+            } else if (!strcasecmp(argv[j], "SETNAME") && moreargs) {
+                j++;
+            } else {
+                return 0;
+            }
+        }
+        /* MIGRATE host port key|"" destination-db timeout [COPY] [REPLACE]
+         * [AUTH password] [AUTH2 username password] [KEYS key [key ...]] */
+    } else if (argc > 7 && !strcasecmp(argv[0], "migrate")) {
+        for (int j = 6; j < argc; j++) {
+            int moreargs = argc - 1 - j;
+            if (!strcasecmp(argv[j], "auth") && moreargs) {
+                return 1;
+            } else if (!strcasecmp(argv[j], "auth2") && moreargs >= 2) {
+                return 1;
+            } else if (!strcasecmp(argv[j], "keys") && moreargs) {
+                return 0;
+            }
+        }
+    } else if (argc > 4 && !strcasecmp(argv[0], "sentinel")) {
+        /* SENTINEL CONFIG SET sentinel-pass password
+         * SENTINEL CONFIG SET sentinel-user username */
+        if (!strcasecmp(argv[1], "config") && !strcasecmp(argv[2], "set") &&
+            (!strcasecmp(argv[3], "sentinel-pass") || !strcasecmp(argv[3], "sentinel-user"))) {
+            return 1;
+        }
+        /* SENTINEL SET <primaryname> auth-pass password
+         * SENTINEL SET <primaryname> auth-user username */
+        if (!strcasecmp(argv[1], "set") && (!strcasecmp(argv[3], "auth-pass") || !strcasecmp(argv[3], "auth-user"))) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static void repl(void) {
+    sds historyfile = NULL;
+    int history = 0;
+    char *line;
+    int argc;
+    sds *argv;
+
+    /* There is no need to initialize HELP when we are in lua debugger mode.
+     * It has its own HELP and commands (COMMAND or COMMAND DOCS will fail and got nothing).
+     * We will initialize the HELP after the Lua debugging session ended.*/
+    if ((!config.eval_ldb) && isatty(fileno(stdin))) {
+        /* Initialize the help using the results of the COMMAND command. */
+        cliInitHelp();
+    }
+
+    config.interactive = 1;
+    linenoiseSetMultiLine(1);
+    linenoiseSetCompletionCallback(completionCallback);
+    linenoiseSetHintsCallback(hintsCallback);
+    linenoiseSetFreeHintsCallback(freeHintsCallback);
+
+    /* Only use history and load the rc file when stdin is a tty. */
+    if (isatty(fileno(stdin))) {
+        historyfile = getDotfilePath(CLI_HISTFILE_ENV, CLI_HISTFILE_DEFAULT);
+        // keep in-memory history always regardless if history file can be determined
+        history = 1;
+        if (historyfile != NULL) {
+            linenoiseHistoryLoad(historyfile);
+        }
+        cliLoadPreferences();
+    }
+
+    cliRefreshPrompt();
+    while (1) {
+        line = linenoise(context ? config.prompt : "not connected> ");
+        if (line == NULL) {
+            /* ^C, ^D or similar. */
+            if (config.pubsub_mode) {
+                config.pubsub_mode = 0;
+                if (cliConnect(CC_FORCE) == REDIS_OK) continue;
+            }
+            break;
+        } else if (line[0] != '\0') {
+            long repeat = 1;
+            int skipargs = 0;
+            char *endptr = NULL;
+
+            argv = cliSplitArgs(line, &argc);
+            if (argv == NULL) {
+                printf("Invalid argument(s)\n");
+                fflush(stdout);
+                if (history) linenoiseHistoryAdd(line, 0);
+                if (historyfile) linenoiseHistorySave(historyfile);
+                linenoiseFree(line);
+                continue;
+            } else if (argc == 0) {
+                sdsfreesplitres(argv, argc);
+                linenoiseFree(line);
+                continue;
+            }
+
+            /* check if we have a repeat command option and
+             * need to skip the first arg */
+            errno = 0;
+            repeat = strtol(argv[0], &endptr, 10);
+            if (argc > 1 && *endptr == '\0') {
+                if (errno == ERANGE || errno == EINVAL || repeat <= 0) {
+                    fputs("Invalid valkey-cli repeat command option value.\n", stdout);
+                    sdsfreesplitres(argv, argc);
+                    linenoiseFree(line);
+                    continue;
+                }
+                skipargs = 1;
+            } else {
+                repeat = 1;
+            }
+
+            /* Always keep in-memory history. But for commands with sensitive information,
+             * avoid writing them to the history file. */
+            int is_sensitive = isSensitiveCommand(argc - skipargs, argv + skipargs);
+            if (history) linenoiseHistoryAdd(line, is_sensitive);
+            if (!is_sensitive && historyfile) linenoiseHistorySave(historyfile);
+
+            if (strcasecmp(argv[0], "quit") == 0 || strcasecmp(argv[0], "exit") == 0) {
+                exit(0);
+            } else if (argv[0][0] == ':') {
+                cliSetPreferences(argv, argc, 1);
+                sdsfreesplitres(argv, argc);
+                linenoiseFree(line);
+                continue;
+            } else if (strcasecmp(argv[0], "restart") == 0) {
+                if (config.eval) {
+                    config.eval_ldb = 1;
+                    config.output = OUTPUT_RAW;
+                    sdsfreesplitres(argv, argc);
+                    linenoiseFree(line);
+                    return; /* Return to evalMode to restart the session. */
+                } else {
+                    printf("Use 'restart' only in Lua debugging mode.\n");
+                    fflush(stdout);
+                }
+            } else if (argc == 3 && !strcasecmp(argv[0], "connect")) {
+                sdsfree(config.conn_info.hostip);
+                config.conn_info.hostip = sdsnew(argv[1]);
+                config.conn_info.hostport = atoi(argv[2]);
+                cliRefreshPrompt();
+                cliConnect(CC_FORCE);
+            } else if (argc == 1 && !strcasecmp(argv[0], "clear")) {
+                linenoiseClearScreen();
+            } else {
+                long long start_time = mstime(), elapsed;
+
+                issueCommandRepeat(argc - skipargs, argv + skipargs, repeat);
+
+                /* If our debugging session ended, show the EVAL final
+                 * reply. */
+                if (config.eval_ldb_end) {
+                    config.eval_ldb_end = 0;
+                    cliReadReply(0);
+                    printf("\n(Lua debugging session ended%s)\n\n",
+                           config.eval_ldb_sync ? "" : " -- dataset changes rolled back");
+                    cliInitHelp();
+                }
+
+                elapsed = mstime() - start_time;
+                if (elapsed >= 500 && config.output == OUTPUT_STANDARD) {
+                    printf("(%.2fs)\n", (double)elapsed / 1000);
+                }
+            }
+            /* Free the argument vector */
+            sdsfreesplitres(argv, argc);
+        }
+
+        if (config.pubsub_mode) {
+            cliWaitForMessagesOrStdin();
+        }
+
+        /* linenoise() returns malloc-ed lines like readline() */
+        linenoiseFree(line);
+    }
+    exit(0);
+}
+
+static int noninteractive(int argc, char **argv) {
+    int retval = 0;
+    sds *sds_args = getSdsArrayFromArgv(argc, argv, config.quoted_input);
+
+    if (!sds_args) {
+        printf("Invalid quoted string\n");
+        return 1;
+    }
+
+    if (config.stdin_lastarg) {
+        sds_args = sds_realloc(sds_args, (argc + 1) * sizeof(sds));
+        sds_args[argc] = readArgFromStdin();
+        argc++;
+    } else if (config.stdin_tag_arg) {
+        int i = 0, tag_match = 0;
+
+        for (; i < argc; i++) {
+            if (strcmp(config.stdin_tag_name, sds_args[i]) != 0) continue;
+
+            tag_match = 1;
+            sdsfree(sds_args[i]);
+            sds_args[i] = readArgFromStdin();
+            break;
+        }
+
+        if (!tag_match) {
+            sdsfreesplitres(sds_args, argc);
+            fprintf(stderr, "Using -X option but stdin tag not match.\n");
+            return 1;
+        }
+    }
+
+    retval = issueCommand(argc, sds_args);
+    sdsfreesplitres(sds_args, argc);
+    while (config.pubsub_mode) {
+        if (cliReadReply(0) != REDIS_OK) {
+            cliPrintContextError();
+            exit(1);
+        }
+        fflush(stdout);
+    }
+    return retval == REDIS_OK ? 0 : 1;
+}
+
+/*------------------------------------------------------------------------------
+ * Eval mode
+ *--------------------------------------------------------------------------- */
+
+static int evalMode(int argc, char **argv) {
+    sds script = NULL;
+    FILE *fp;
+    char buf[1024];
+    size_t nread;
+    char **argv2;
+    int j, got_comma, keys;
+    int retval = REDIS_OK;
+
+    while (1) {
+        if (config.eval_ldb) {
+            printf("Lua debugging session started, please use:\n"
+                   "quit    -- End the session.\n"
+                   "restart -- Restart the script in debug mode again.\n"
+                   "help    -- Show Lua script debugging commands.\n\n");
+        }
+
+        sdsfree(script);
+        script = sdsempty();
+        got_comma = 0;
+        keys = 0;
+
+        /* Load the script from the file, as an sds string. */
+        fp = fopen(config.eval, "r");
+        if (!fp) {
+            fprintf(stderr, "Can't open file '%s': %s\n", config.eval, strerror(errno));
+            exit(1);
+        }
+        while ((nread = fread(buf, 1, sizeof(buf), fp)) != 0) {
+            script = sdscatlen(script, buf, nread);
+        }
+        fclose(fp);
+
+        /* If we are debugging a script, enable the Lua debugger. */
+        if (config.eval_ldb) {
+            redisReply *reply = redisCommand(context, config.eval_ldb_sync ? "SCRIPT DEBUG sync" : "SCRIPT DEBUG yes");
+            if (reply) freeReplyObject(reply);
+        }
+
+        /* Create our argument vector */
+        argv2 = zmalloc(sizeof(sds) * (argc + 3));
+        argv2[0] = sdsnew("EVAL");
+        argv2[1] = script;
+        for (j = 0; j < argc; j++) {
+            if (!got_comma && argv[j][0] == ',' && argv[j][1] == 0) {
+                got_comma = 1;
+                continue;
+            }
+            argv2[j + 3 - got_comma] = sdsnew(argv[j]);
+            if (!got_comma) keys++;
+        }
+        argv2[2] = sdscatprintf(sdsempty(), "%d", keys);
+
+        /* Call it */
+        int eval_ldb = config.eval_ldb; /* Save it, may be reverted. */
+        retval = issueCommand(argc + 3 - got_comma, argv2);
+        if (eval_ldb) {
+            if (!config.eval_ldb) {
+                /* If the debugging session ended immediately, there was an
+                 * error compiling the script. Show it and they don't enter
+                 * the REPL at all. */
+                printf("Eval debugging session can't start:\n");
+                cliReadReply(0);
+                break; /* Return to the caller. */
+            } else {
+                strncpy(config.prompt, "lua debugger> ", sizeof(config.prompt));
+                repl();
+                /* Restart the session if repl() returned. */
+                cliConnect(CC_FORCE);
+                printf("\n");
+            }
+        } else {
+            break; /* Return to the caller. */
+        }
+    }
+    return retval == REDIS_OK ? 0 : 1;
+}
+
+/*------------------------------------------------------------------------------
+ * Cluster Manager
+ *--------------------------------------------------------------------------- */
+
+/* The Cluster Manager global structure */
+static struct clusterManager {
+    list *nodes; /* List of nodes in the configuration. */
+    list *errors;
+    int unreachable_primaries; /* Primaries we are not able to reach. */
+} cluster_manager;
+
+/* Used by clusterManagerFixSlotsCoverage */
+dict *clusterManagerUncoveredSlots = NULL;
+
+typedef struct clusterManagerNode {
+    redisContext *context;
+    sds name;
+    char *ip;
+    int port;
+    int bus_port; /* cluster-port */
+    uint64_t current_epoch;
+    time_t ping_sent;
+    time_t ping_recv;
+    int flags;
+    list *flags_str; /* Flags string representations */
+    sds replicate;   /* Primary ID if node is a replica */
+    int dirty;       /* Node has changes that can be flushed */
+    uint8_t slots[CLUSTER_MANAGER_SLOTS];
+    int slots_count;
+    int replicas_count;
+    list *friends;
+    sds *migrating;      /* An array of sds where even strings are slots and odd
+                          * strings are the destination node IDs. */
+    sds *importing;      /* An array of sds where even strings are slots and odd
+                          * strings are the source node IDs. */
+    int migrating_count; /* Length of the migrating array (migrating slots*2) */
+    int importing_count; /* Length of the importing array (importing slots*2) */
+    float weight;        /* Weight used by rebalance */
+    int balance;         /* Used by rebalance */
+} clusterManagerNode;
+
+/* Data structure used to represent a sequence of cluster nodes. */
+typedef struct clusterManagerNodeArray {
+    clusterManagerNode **nodes; /* Actual nodes array */
+    clusterManagerNode **alloc; /* Pointer to the allocated memory */
+    int len;                    /* Actual length of the array */
+    int count;                  /* Non-NULL nodes count */
+} clusterManagerNodeArray;
+
+/* Used for the reshard table. */
+typedef struct clusterManagerReshardTableItem {
+    clusterManagerNode *source;
+    int slot;
+} clusterManagerReshardTableItem;
+
+/* Info about a cluster internal link. */
+
+typedef struct clusterManagerLink {
+    sds node_name;
+    sds node_addr;
+    int connected;
+    int handshaking;
+} clusterManagerLink;
+
+static dictType clusterManagerDictType = {
+    dictSdsHash,       /* hash function */
+    NULL,              /* key dup */
+    dictSdsKeyCompare, /* key compare */
+    NULL,              /* key destructor */
+    dictSdsDestructor, /* val destructor */
+    NULL               /* allow to expand */
+};
+
+static dictType clusterManagerLinkDictType = {
+    dictSdsHash,        /* hash function */
+    NULL,               /* key dup */
+    dictSdsKeyCompare,  /* key compare */
+    dictSdsDestructor,  /* key destructor */
+    dictListDestructor, /* val destructor */
+    NULL                /* allow to expand */
+};
+
+typedef int clusterManagerCommandProc(int argc, char **argv);
+typedef int (*clusterManagerOnReplyError)(redisReply *reply, clusterManagerNode *n, int bulk_idx);
+
+/* Cluster Manager helper functions */
+
+static clusterManagerNode *clusterManagerNewNode(char *ip, int port, int bus_port);
+static clusterManagerNode *clusterManagerNodeByName(const char *name);
+static clusterManagerNode *clusterManagerNodeByAbbreviatedName(const char *n);
+static void clusterManagerNodeResetSlots(clusterManagerNode *node);
+static int clusterManagerNodeIsCluster(clusterManagerNode *node, char **err);
+static void clusterManagerPrintNotClusterNodeError(clusterManagerNode *node, char *err);
+static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts, char **err);
+static int clusterManagerLoadInfoFromNode(clusterManagerNode *node);
+static int clusterManagerNodeIsEmpty(clusterManagerNode *node, char **err);
+static int clusterManagerGetAntiAffinityScore(clusterManagerNodeArray *ipnodes,
+                                              int ip_count,
+                                              clusterManagerNode ***offending,
+                                              int *offending_len);
+static void clusterManagerOptimizeAntiAffinity(clusterManagerNodeArray *ipnodes, int ip_count);
+static sds clusterManagerNodeInfo(clusterManagerNode *node, int indent);
+static void clusterManagerShowNodes(void);
+static void clusterManagerShowClusterInfo(void);
+static int clusterManagerFlushNodeConfig(clusterManagerNode *node, char **err);
+static void clusterManagerWaitForClusterJoin(void);
+static int clusterManagerCheckCluster(int quiet);
+static void clusterManagerLog(int level, const char *fmt, ...);
+static int clusterManagerIsConfigConsistent(void);
+static dict *clusterManagerGetLinkStatus(void);
+static void clusterManagerOnError(sds err);
+static void clusterManagerNodeArrayInit(clusterManagerNodeArray *array, int len);
+static void clusterManagerNodeArrayReset(clusterManagerNodeArray *array);
+static void clusterManagerNodeArrayShift(clusterManagerNodeArray *array, clusterManagerNode **nodeptr);
+static void clusterManagerNodeArrayAdd(clusterManagerNodeArray *array, clusterManagerNode *node);
+
+/* Cluster Manager commands. */
+
+static int clusterManagerCommandCreate(int argc, char **argv);
+static int clusterManagerCommandAddNode(int argc, char **argv);
+static int clusterManagerCommandDeleteNode(int argc, char **argv);
+static int clusterManagerCommandInfo(int argc, char **argv);
+static int clusterManagerCommandCheck(int argc, char **argv);
+static int clusterManagerCommandFix(int argc, char **argv);
+static int clusterManagerCommandReshard(int argc, char **argv);
+static int clusterManagerCommandRebalance(int argc, char **argv);
+static int clusterManagerCommandSetTimeout(int argc, char **argv);
+static int clusterManagerCommandImport(int argc, char **argv);
+static int clusterManagerCommandCall(int argc, char **argv);
+static int clusterManagerCommandHelp(int argc, char **argv);
+static int clusterManagerCommandBackup(int argc, char **argv);
+
+typedef struct clusterManagerCommandDef {
+    char *name;
+    clusterManagerCommandProc *proc;
+    int arity;
+    char *args;
+    char *options;
+} clusterManagerCommandDef;
+
+clusterManagerCommandDef clusterManagerCommands[] = {
+    {"create", clusterManagerCommandCreate, -1, "host1:port1 ... hostN:portN", "replicas <arg>"},
+    {"check", clusterManagerCommandCheck, -1, "<host:port> or <host> <port> - separated by either colon or space",
+     "search-multiple-owners"},
+    {"info", clusterManagerCommandInfo, -1, "<host:port> or <host> <port> - separated by either colon or space", NULL},
+    {"fix", clusterManagerCommandFix, -1, "<host:port> or <host> <port> - separated by either colon or space",
+     "search-multiple-owners,fix-with-unreachable-primaries"},
+    {"reshard", clusterManagerCommandReshard, -1, "<host:port> or <host> <port> - separated by either colon or space",
+     "from <arg>,to <arg>,slots <arg>,yes,timeout <arg>,pipeline <arg>,"
+     "replace"},
+    {"rebalance", clusterManagerCommandRebalance, -1,
+     "<host:port> or <host> <port> - separated by either colon or space",
+     "weight <node1=w1...nodeN=wN>,use-empty-primaries,"
+     "timeout <arg>,simulate,pipeline <arg>,threshold <arg>,replace"},
+    {"add-node", clusterManagerCommandAddNode, 2, "new_host:new_port existing_host:existing_port",
+     "replica,primaries-id <arg>"},
+    {"del-node", clusterManagerCommandDeleteNode, 2, "host:port node_id", NULL},
+    {"call", clusterManagerCommandCall, -2, "host:port command arg arg .. arg", "only-primaries,only-replicas"},
+    {"set-timeout", clusterManagerCommandSetTimeout, 2, "host:port milliseconds", NULL},
+    {"import", clusterManagerCommandImport, 1, "host:port",
+     "from <arg>,from-user <arg>,from-pass <arg>,from-askpass,copy,replace"},
+    {"backup", clusterManagerCommandBackup, 2, "host:port backup_directory", NULL},
+    {"help", clusterManagerCommandHelp, 0, NULL, NULL}};
+
+typedef struct clusterManagerOptionDef {
+    char *name;
+    char *desc;
+} clusterManagerOptionDef;
+
+clusterManagerOptionDef clusterManagerOptions[] = {{"--cluster-yes", "Automatic yes to cluster commands prompts"}};
+
+static void getRDB(clusterManagerNode *node);
+
+static int createClusterManagerCommand(char *cmdname, int argc, char **argv) {
+    clusterManagerCommand *cmd = &config.cluster_manager_command;
+    cmd->name = cmdname;
+    cmd->argc = argc;
+    cmd->argv = argc ? argv : NULL;
+    if (isColorTerm()) cmd->flags |= CLUSTER_MANAGER_CMD_FLAG_COLOR;
+
+    if (config.stdin_lastarg) {
+        char **new_argv = zmalloc(sizeof(char *) * (cmd->argc + 1));
+        memcpy(new_argv, cmd->argv, sizeof(char *) * cmd->argc);
+
+        cmd->stdin_arg = readArgFromStdin();
+        new_argv[cmd->argc++] = cmd->stdin_arg;
+        cmd->argv = new_argv;
+    } else if (config.stdin_tag_arg) {
+        int i = 0, tag_match = 0;
+        cmd->stdin_arg = readArgFromStdin();
+
+        for (; i < argc; i++) {
+            if (strcmp(argv[i], config.stdin_tag_name) != 0) continue;
+
+            tag_match = 1;
+            cmd->argv[i] = (char *)cmd->stdin_arg;
+            break;
+        }
+
+        if (!tag_match) {
+            sdsfree(cmd->stdin_arg);
+            fprintf(stderr, "Using -X option but stdin tag not match.\n");
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static clusterManagerCommandProc *validateClusterManagerCommand(void) {
+    int i, commands_count = sizeof(clusterManagerCommands) / sizeof(clusterManagerCommandDef);
+    clusterManagerCommandProc *proc = NULL;
+    char *cmdname = config.cluster_manager_command.name;
+    int argc = config.cluster_manager_command.argc;
+    for (i = 0; i < commands_count; i++) {
+        clusterManagerCommandDef cmddef = clusterManagerCommands[i];
+        if (!strcmp(cmddef.name, cmdname)) {
+            if ((cmddef.arity > 0 && argc != cmddef.arity) || (cmddef.arity < 0 && argc < (cmddef.arity * -1))) {
+                fprintf(stderr, "[ERR] Wrong number of arguments for "
+                                "specified --cluster sub command\n");
+                return NULL;
+            }
+            proc = cmddef.proc;
+        }
+    }
+    if (!proc) fprintf(stderr, "Unknown --cluster subcommand\n");
+    return proc;
+}
+
+static int parseClusterNodeAddress(char *addr, char **ip_ptr, int *port_ptr, int *bus_port_ptr) {
+    /* ip:port[@bus_port] */
+    char *c = strrchr(addr, '@');
+    if (c != NULL) {
+        *c = '\0';
+        if (bus_port_ptr != NULL) *bus_port_ptr = atoi(c + 1);
+    }
+    c = strrchr(addr, ':');
+    if (c != NULL) {
+        *c = '\0';
+        *ip_ptr = addr;
+        *port_ptr = atoi(++c);
+    } else
+        return 0;
+    return 1;
+}
+
+/* Get host ip and port from command arguments. If only one argument has
+ * been provided it must be in the form of 'ip:port', elsewhere
+ * the first argument must be the ip and the second one the port.
+ * If host and port can be detected, it returns 1 and it stores host and
+ * port into variables referenced by 'ip_ptr' and 'port_ptr' pointers,
+ * elsewhere it returns 0. */
+static int getClusterHostFromCmdArgs(int argc, char **argv, char **ip_ptr, int *port_ptr) {
+    int port = 0;
+    char *ip = NULL;
+    if (argc == 1) {
+        char *addr = argv[0];
+        if (!parseClusterNodeAddress(addr, &ip, &port, NULL)) return 0;
+    } else {
+        ip = argv[0];
+        port = atoi(argv[1]);
+    }
+    if (!ip || !port)
+        return 0;
+    else {
+        *ip_ptr = ip;
+        *port_ptr = port;
+    }
+    return 1;
+}
+
+static void freeClusterManagerNodeFlags(list *flags) {
+    listIter li;
+    listNode *ln;
+    listRewind(flags, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        sds flag = ln->value;
+        sdsfree(flag);
+    }
+    listRelease(flags);
+}
+
+static void freeClusterManagerNode(clusterManagerNode *node) {
+    if (node->context != NULL) redisFree(node->context);
+    if (node->friends != NULL) {
+        listIter li;
+        listNode *ln;
+        listRewind(node->friends, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *fn = ln->value;
+            freeClusterManagerNode(fn);
+        }
+        listRelease(node->friends);
+        node->friends = NULL;
+    }
+    if (node->name != NULL) sdsfree(node->name);
+    if (node->replicate != NULL) sdsfree(node->replicate);
+    if ((node->flags & CLUSTER_MANAGER_FLAG_FRIEND) && node->ip) sdsfree(node->ip);
+    int i;
+    if (node->migrating != NULL) {
+        for (i = 0; i < node->migrating_count; i++) sdsfree(node->migrating[i]);
+        zfree(node->migrating);
+    }
+    if (node->importing != NULL) {
+        for (i = 0; i < node->importing_count; i++) sdsfree(node->importing[i]);
+        zfree(node->importing);
+    }
+    if (node->flags_str != NULL) {
+        freeClusterManagerNodeFlags(node->flags_str);
+        node->flags_str = NULL;
+    }
+    zfree(node);
+}
+
+static void freeClusterManager(void) {
+    listIter li;
+    listNode *ln;
+    if (cluster_manager.nodes != NULL) {
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            freeClusterManagerNode(n);
+        }
+        listRelease(cluster_manager.nodes);
+        cluster_manager.nodes = NULL;
+    }
+    if (cluster_manager.errors != NULL) {
+        listRewind(cluster_manager.errors, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            sds err = ln->value;
+            sdsfree(err);
+        }
+        listRelease(cluster_manager.errors);
+        cluster_manager.errors = NULL;
+    }
+    if (clusterManagerUncoveredSlots != NULL) dictRelease(clusterManagerUncoveredSlots);
+}
+
+static clusterManagerNode *clusterManagerNewNode(char *ip, int port, int bus_port) {
+    clusterManagerNode *node = zmalloc(sizeof(*node));
+    node->context = NULL;
+    node->name = NULL;
+    node->ip = ip;
+    node->port = port;
+    /* We don't need to know the bus_port, at this point this value may be wrong.
+     * If it is used, it will be corrected in clusterManagerLoadInfoFromNode. */
+    node->bus_port = bus_port ? bus_port : port + CLUSTER_MANAGER_PORT_INCR;
+    node->current_epoch = 0;
+    node->ping_sent = 0;
+    node->ping_recv = 0;
+    node->flags = 0;
+    node->flags_str = NULL;
+    node->replicate = NULL;
+    node->dirty = 0;
+    node->friends = NULL;
+    node->migrating = NULL;
+    node->importing = NULL;
+    node->migrating_count = 0;
+    node->importing_count = 0;
+    node->replicas_count = 0;
+    node->weight = 1.0f;
+    node->balance = 0;
+    clusterManagerNodeResetSlots(node);
+    return node;
+}
+
+static sds clusterManagerGetNodeRDBFilename(clusterManagerNode *node) {
+    assert(config.cluster_manager_command.backup_dir);
+    sds filename = sdsnew(config.cluster_manager_command.backup_dir);
+    if (filename[sdslen(filename) - 1] != '/') filename = sdscat(filename, "/");
+    filename = sdscatprintf(filename, "valkey-node-%s-%d-%s.rdb", node->ip, node->port, node->name);
+    return filename;
+}
+
+/* Check whether reply is NULL or its type is REDIS_REPLY_ERROR. In the
+ * latest case, if the 'err' arg is not NULL, it gets allocated with a copy
+ * of reply error (it's up to the caller function to free it), elsewhere
+ * the error is directly printed. */
+static int clusterManagerCheckRedisReply(clusterManagerNode *n, redisReply *r, char **err) {
+    int is_err = 0;
+    if (!r || (is_err = (r->type == REDIS_REPLY_ERROR))) {
+        if (is_err) {
+            if (err != NULL) {
+                *err = zmalloc((r->len + 1) * sizeof(char));
+                valkey_strlcpy(*err, r->str, (r->len + 1));
+            } else
+                CLUSTER_MANAGER_PRINT_REPLY_ERROR(n, r->str);
+        }
+        return 0;
+    }
+    return 1;
+}
+
+/* Call MULTI command on a cluster node. */
+static int clusterManagerStartTransaction(clusterManagerNode *node) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "MULTI");
+    int success = clusterManagerCheckRedisReply(node, reply, NULL);
+    if (reply) freeReplyObject(reply);
+    return success;
+}
+
+/* Call EXEC command on a cluster node. */
+static int clusterManagerExecTransaction(clusterManagerNode *node, clusterManagerOnReplyError onerror) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "EXEC");
+    int success = clusterManagerCheckRedisReply(node, reply, NULL);
+    if (success) {
+        if (reply->type != REDIS_REPLY_ARRAY) {
+            success = 0;
+            goto cleanup;
+        }
+        size_t i;
+        for (i = 0; i < reply->elements; i++) {
+            redisReply *r = reply->element[i];
+            char *err = NULL;
+            success = clusterManagerCheckRedisReply(node, r, &err);
+            if (!success && onerror) success = onerror(r, node, i);
+            if (err) {
+                if (!success) CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, err);
+                zfree(err);
+            }
+            if (!success) break;
+        }
+    }
+cleanup:
+    if (reply) freeReplyObject(reply);
+    return success;
+}
+
+static int clusterManagerNodeConnect(clusterManagerNode *node) {
+    if (node->context) redisFree(node->context);
+    node->context = redisConnectWrapper(node->ip, node->port, config.connect_timeout);
+    if (!node->context->err && config.tls) {
+        const char *err = NULL;
+        if (cliSecureConnection(node->context, config.sslconfig, &err) == REDIS_ERR && err) {
+            fprintf(stderr, "TLS Error: %s\n", err);
+            redisFree(node->context);
+            node->context = NULL;
+            return 0;
+        }
+    }
+    if (node->context->err) {
+        fprintf(stderr, "Could not connect to Valkey at ");
+        fprintf(stderr, "%s:%d: %s\n", node->ip, node->port, node->context->errstr);
+        redisFree(node->context);
+        node->context = NULL;
+        return 0;
+    }
+    /* Set aggressive KEEP_ALIVE socket option in the server context socket
+     * in order to prevent timeouts caused by the execution of long
+     * commands. At the same time this improves the detection of real
+     * errors. */
+    anetKeepAlive(NULL, node->context->fd, CLI_KEEPALIVE_INTERVAL);
+    if (config.conn_info.auth) {
+        redisReply *reply;
+        if (config.conn_info.user == NULL)
+            reply = redisCommand(node->context, "AUTH %s", config.conn_info.auth);
+        else
+            reply = redisCommand(node->context, "AUTH %s %s", config.conn_info.user, config.conn_info.auth);
+        int ok = clusterManagerCheckRedisReply(node, reply, NULL);
+        if (reply != NULL) freeReplyObject(reply);
+        if (!ok) return 0;
+    }
+    return 1;
+}
+
+static void clusterManagerRemoveNodeFromList(list *nodelist, clusterManagerNode *node) {
+    listIter li;
+    listNode *ln;
+    listRewind(nodelist, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        if (node == ln->value) {
+            listDelNode(nodelist, ln);
+            break;
+        }
+    }
+}
+
+/* Return the node with the specified name (ID) or NULL. */
+static clusterManagerNode *clusterManagerNodeByName(const char *name) {
+    if (cluster_manager.nodes == NULL) return NULL;
+    clusterManagerNode *found = NULL;
+    sds lcname = sdsempty();
+    lcname = sdscpy(lcname, name);
+    sdstolower(lcname);
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->name && !sdscmp(n->name, lcname)) {
+            found = n;
+            break;
+        }
+    }
+    sdsfree(lcname);
+    return found;
+}
+
+/* Like clusterManagerNodeByName but the specified name can be just the first
+ * part of the node ID as long as the prefix in unique across the
+ * cluster.
+ */
+static clusterManagerNode *clusterManagerNodeByAbbreviatedName(const char *name) {
+    if (cluster_manager.nodes == NULL) return NULL;
+    clusterManagerNode *found = NULL;
+    sds lcname = sdsempty();
+    lcname = sdscpy(lcname, name);
+    sdstolower(lcname);
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->name && strstr(n->name, lcname) == n->name) {
+            found = n;
+            break;
+        }
+    }
+    sdsfree(lcname);
+    return found;
+}
+
+static void clusterManagerNodeResetSlots(clusterManagerNode *node) {
+    memset(node->slots, 0, sizeof(node->slots));
+    node->slots_count = 0;
+}
+
+/* Call "INFO" command on the specified node and return the reply. */
+static redisReply *clusterManagerGetNodeRedisInfo(clusterManagerNode *node, char **err) {
+    redisReply *info = CLUSTER_MANAGER_COMMAND(node, "INFO");
+    if (err != NULL) *err = NULL;
+    if (info == NULL) return NULL;
+    if (info->type == REDIS_REPLY_ERROR) {
+        if (err != NULL) {
+            *err = zmalloc((info->len + 1) * sizeof(char));
+            valkey_strlcpy(*err, info->str, (info->len + 1));
+        }
+        freeReplyObject(info);
+        return NULL;
+    }
+    return info;
+}
+
+static int clusterManagerNodeIsCluster(clusterManagerNode *node, char **err) {
+    redisReply *info = clusterManagerGetNodeRedisInfo(node, err);
+    if (info == NULL) return 0;
+    int is_cluster = (int)getLongInfoField(info->str, "cluster_enabled");
+    freeReplyObject(info);
+    return is_cluster;
+}
+
+/* Checks whether the node is empty. Node is considered not-empty if it has
+ * some key or if it already knows other nodes */
+static int clusterManagerNodeIsEmpty(clusterManagerNode *node, char **err) {
+    redisReply *info = clusterManagerGetNodeRedisInfo(node, err);
+    int is_empty = 1;
+    if (info == NULL) return 0;
+    if (strstr(info->str, "db0:") != NULL) {
+        is_empty = 0;
+        goto result;
+    }
+    freeReplyObject(info);
+    info = CLUSTER_MANAGER_COMMAND(node, "CLUSTER INFO");
+    if (err != NULL) *err = NULL;
+    if (!clusterManagerCheckRedisReply(node, info, err)) {
+        is_empty = 0;
+        goto result;
+    }
+    long known_nodes = getLongInfoField(info->str, "cluster_known_nodes");
+    is_empty = (known_nodes == 1);
+result:
+    freeReplyObject(info);
+    return is_empty;
+}
+
+/* Return the anti-affinity score, which is a measure of the amount of
+ * violations of anti-affinity in the current cluster layout, that is, how
+ * badly the primaries and replicas are distributed in the different IP
+ * addresses so that replicas of the same primary are not in the primary
+ * host and are also in different hosts.
+ *
+ * The score is calculated as follows:
+ *
+ * SAME_AS_PRIMARY = 10000 * each replica in the same IP of its primary.
+ * SAME_AS_REPLICA  = 1 * each replica having the same IP as another replica
+                      of the same primary.
+ * FINAL_SCORE = SAME_AS_PRIMARY + SAME_AS_REPLICA
+ *
+ * So a greater score means a worse anti-affinity level, while zero
+ * means perfect anti-affinity.
+ *
+ * The anti affinity optimization will try to get a score as low as
+ * possible. Since we do not want to sacrifice the fact that replicas should
+ * not be in the same host as the primary, we assign 10000 times the score
+ * to this violation, so that we'll optimize for the second factor only
+ * if it does not impact the first one.
+ *
+ * The ipnodes argument is an array of clusterManagerNodeArray, one for
+ * each IP, while ip_count is the total number of IPs in the configuration.
+ *
+ * The function returns the above score, and the list of
+ * offending replicas can be stored into the 'offending' argument,
+ * so that the optimizer can try changing the configuration of the
+ * replicas violating the anti-affinity goals. */
+static int clusterManagerGetAntiAffinityScore(clusterManagerNodeArray *ipnodes,
+                                              int ip_count,
+                                              clusterManagerNode ***offending,
+                                              int *offending_len) {
+    int score = 0, i, j;
+    int node_len = cluster_manager.nodes->len;
+    clusterManagerNode **offending_p = NULL;
+    if (offending != NULL) {
+        *offending = zcalloc(node_len * sizeof(clusterManagerNode *));
+        offending_p = *offending;
+    }
+    /* For each set of nodes in the same host, split by
+     * related nodes (primaries and replicas which are involved in
+     * replication of each other) */
+    for (i = 0; i < ip_count; i++) {
+        clusterManagerNodeArray *node_array = &(ipnodes[i]);
+        dict *related = dictCreate(&clusterManagerDictType);
+        char *ip = NULL;
+        for (j = 0; j < node_array->len; j++) {
+            clusterManagerNode *node = node_array->nodes[j];
+            if (node == NULL) continue;
+            if (!ip) ip = node->ip;
+            sds types;
+            /* We always use the Primary ID as key. */
+            sds key = (!node->replicate ? node->name : node->replicate);
+            assert(key != NULL);
+            dictEntry *entry = dictFind(related, key);
+            if (entry)
+                types = sdsdup((sds)dictGetVal(entry));
+            else
+                types = sdsempty();
+            /* Primary type 'm' is always set as the first character of the
+             * types string. */
+            if (node->replicate)
+                types = sdscat(types, "s");
+            else {
+                sds s = sdscatsds(sdsnew("m"), types);
+                sdsfree(types);
+                types = s;
+            }
+            dictReplace(related, key, types);
+        }
+        /* Now it's trivial to check, for each related group having the
+         * same host, what is their local score. */
+        dictIterator *iter = dictGetIterator(related);
+        dictEntry *entry;
+        while ((entry = dictNext(iter)) != NULL) {
+            sds types = (sds)dictGetVal(entry);
+            sds name = (sds)dictGetKey(entry);
+            int typeslen = sdslen(types);
+            if (typeslen < 2) continue;
+            if (types[0] == 'm')
+                score += (10000 * (typeslen - 1));
+            else
+                score += (1 * typeslen);
+            if (offending == NULL) continue;
+            /* Populate the list of offending nodes. */
+            listIter li;
+            listNode *ln;
+            listRewind(cluster_manager.nodes, &li);
+            while ((ln = listNext(&li)) != NULL) {
+                clusterManagerNode *n = ln->value;
+                if (n->replicate == NULL) continue;
+                if (!strcmp(n->replicate, name) && !strcmp(n->ip, ip)) {
+                    *(offending_p++) = n;
+                    if (offending_len != NULL) (*offending_len)++;
+                    break;
+                }
+            }
+        }
+        // if (offending_len != NULL) *offending_len = offending_p - *offending;
+        dictReleaseIterator(iter);
+        dictRelease(related);
+    }
+    return score;
+}
+
+static void clusterManagerOptimizeAntiAffinity(clusterManagerNodeArray *ipnodes, int ip_count) {
+    clusterManagerNode **offenders = NULL;
+    int score = clusterManagerGetAntiAffinityScore(ipnodes, ip_count, NULL, NULL);
+    if (score == 0) goto cleanup;
+    clusterManagerLogInfo(">>> Trying to optimize replicas allocation "
+                          "for anti-affinity\n");
+    int node_len = cluster_manager.nodes->len;
+    int maxiter = 500 * node_len; // Effort is proportional to cluster size...
+    srand(time(NULL));
+    while (maxiter > 0) {
+        int offending_len = 0;
+        if (offenders != NULL) {
+            zfree(offenders);
+            offenders = NULL;
+        }
+        score = clusterManagerGetAntiAffinityScore(ipnodes, ip_count, &offenders, &offending_len);
+        if (score == 0 || offending_len == 0) break; // Optimal anti affinity reached
+        /* We'll try to randomly swap a replica's assigned primary causing
+         * an affinity problem with another random replica, to see if we
+         * can improve the affinity. */
+        int rand_idx = rand() % offending_len;
+        clusterManagerNode *first = offenders[rand_idx], *second = NULL;
+        clusterManagerNode **other_replicas = zcalloc((node_len - 1) * sizeof(*other_replicas));
+        int other_replicas_count = 0;
+        listIter li;
+        listNode *ln;
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            if (n != first && n->replicate != NULL) other_replicas[other_replicas_count++] = n;
+        }
+        if (other_replicas_count == 0) {
+            zfree(other_replicas);
+            break;
+        }
+        rand_idx = rand() % other_replicas_count;
+        second = other_replicas[rand_idx];
+        char *first_primary = first->replicate, *second_primary = second->replicate;
+        first->replicate = second_primary, first->dirty = 1;
+        second->replicate = first_primary, second->dirty = 1;
+        int new_score = clusterManagerGetAntiAffinityScore(ipnodes, ip_count, NULL, NULL);
+        /* If the change actually makes thing worse, revert. Otherwise
+         * leave as it is because the best solution may need a few
+         * combined swaps. */
+        if (new_score > score) {
+            first->replicate = first_primary;
+            second->replicate = second_primary;
+        }
+        zfree(other_replicas);
+        maxiter--;
+    }
+    score = clusterManagerGetAntiAffinityScore(ipnodes, ip_count, NULL, NULL);
+    char *msg;
+    int perfect = (score == 0);
+    int log_level = (perfect ? CLUSTER_MANAGER_LOG_LVL_SUCCESS : CLUSTER_MANAGER_LOG_LVL_WARN);
+    if (perfect)
+        msg = "[OK] Perfect anti-affinity obtained!";
+    else if (score >= 10000)
+        msg = ("[WARNING] Some replicas are in the same host as their primary");
+    else
+        msg = ("[WARNING] Some replicas of the same primary are in the same host");
+    clusterManagerLog(log_level, "%s\n", msg);
+cleanup:
+    zfree(offenders);
+}
+
+/* Return a representable string of the node's flags */
+static sds clusterManagerNodeFlagString(clusterManagerNode *node) {
+    sds flags = sdsempty();
+    if (!node->flags_str) return flags;
+    int empty = 1;
+    listIter li;
+    listNode *ln;
+    listRewind(node->flags_str, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        sds flag = ln->value;
+        if (strcmp(flag, "myself") == 0) continue;
+        if (!empty) flags = sdscat(flags, ",");
+        flags = sdscatfmt(flags, "%S", flag);
+        empty = 0;
+    }
+    return flags;
+}
+
+/* Return a representable string of the node's slots */
+static sds clusterManagerNodeSlotsString(clusterManagerNode *node) {
+    sds slots = sdsempty();
+    int first_range_idx = -1, last_slot_idx = -1, i;
+    for (i = 0; i < CLUSTER_MANAGER_SLOTS; i++) {
+        int has_slot = node->slots[i];
+        if (has_slot) {
+            if (first_range_idx == -1) {
+                if (sdslen(slots)) slots = sdscat(slots, ",");
+                first_range_idx = i;
+                slots = sdscatfmt(slots, "[%u", i);
+            }
+            last_slot_idx = i;
+        } else {
+            if (last_slot_idx >= 0) {
+                if (first_range_idx == last_slot_idx)
+                    slots = sdscat(slots, "]");
+                else
+                    slots = sdscatfmt(slots, "-%u]", last_slot_idx);
+            }
+            last_slot_idx = -1;
+            first_range_idx = -1;
+        }
+    }
+    if (last_slot_idx >= 0) {
+        if (first_range_idx == last_slot_idx)
+            slots = sdscat(slots, "]");
+        else
+            slots = sdscatfmt(slots, "-%u]", last_slot_idx);
+    }
+    return slots;
+}
+
+static sds clusterManagerNodeGetJSON(clusterManagerNode *node, unsigned long error_count) {
+    sds json = sdsempty();
+    sds replicate = sdsempty();
+    if (node->replicate)
+        replicate = sdscatprintf(replicate, "\"%s\"", node->replicate);
+    else
+        replicate = sdscat(replicate, "null");
+    sds slots = clusterManagerNodeSlotsString(node);
+    sds flags = clusterManagerNodeFlagString(node);
+    char *p = slots;
+    while ((p = strchr(p, '-')) != NULL) *(p++) = ',';
+    json = sdscatprintf(json,
+                        "  {\n"
+                        "    \"name\": \"%s\",\n"
+                        "    \"host\": \"%s\",\n"
+                        "    \"port\": %d,\n"
+                        "    \"replicate\": %s,\n"
+                        "    \"slots\": [%s],\n"
+                        "    \"slots_count\": %d,\n"
+                        "    \"flags\": \"%s\",\n"
+                        "    \"current_epoch\": %llu",
+                        node->name, node->ip, node->port, replicate, slots, node->slots_count, flags,
+                        (unsigned long long)node->current_epoch);
+    if (error_count > 0) {
+        json = sdscatprintf(json, ",\n    \"cluster_errors\": %lu", error_count);
+    }
+    if (node->migrating_count > 0 && node->migrating != NULL) {
+        int i = 0;
+        sds migrating = sdsempty();
+        for (; i < node->migrating_count; i += 2) {
+            sds slot = node->migrating[i];
+            sds dest = node->migrating[i + 1];
+            if (slot && dest) {
+                if (sdslen(migrating) > 0) migrating = sdscat(migrating, ",");
+                migrating = sdscatfmt(migrating, "\"%S\": \"%S\"", slot, dest);
+            }
+        }
+        if (sdslen(migrating) > 0) json = sdscatfmt(json, ",\n    \"migrating\": {%S}", migrating);
+        sdsfree(migrating);
+    }
+    if (node->importing_count > 0 && node->importing != NULL) {
+        int i = 0;
+        sds importing = sdsempty();
+        for (; i < node->importing_count; i += 2) {
+            sds slot = node->importing[i];
+            sds from = node->importing[i + 1];
+            if (slot && from) {
+                if (sdslen(importing) > 0) importing = sdscat(importing, ",");
+                importing = sdscatfmt(importing, "\"%S\": \"%S\"", slot, from);
+            }
+        }
+        if (sdslen(importing) > 0) json = sdscatfmt(json, ",\n    \"importing\": {%S}", importing);
+        sdsfree(importing);
+    }
+    json = sdscat(json, "\n  }");
+    sdsfree(replicate);
+    sdsfree(slots);
+    sdsfree(flags);
+    return json;
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Key space handling
+ * -------------------------------------------------------------------------- */
+
+/* We have 16384 hash slots. The hash slot of a given key is obtained
+ * as the least significant 14 bits of the crc16 of the key.
+ *
+ * However if the key contains the {...} pattern, only the part between
+ * { and } is hashed. This may be useful in the future to force certain
+ * keys to be in the same node (assuming no resharding is in progress). */
+static unsigned int clusterManagerKeyHashSlot(char *key, int keylen) {
+    int s, e; /* start-end indexes of { and } */
+
+    for (s = 0; s < keylen; s++)
+        if (key[s] == '{') break;
+
+    /* No '{' ? Hash the whole key. This is the base case. */
+    if (s == keylen) return crc16(key, keylen) & 0x3FFF;
+
+    /* '{' found? Check if we have the corresponding '}'. */
+    for (e = s + 1; e < keylen; e++)
+        if (key[e] == '}') break;
+
+    /* No '}' or nothing between {} ? Hash the whole key. */
+    if (e == keylen || e == s + 1) return crc16(key, keylen) & 0x3FFF;
+
+    /* If we are here there is both a { and a } on its right. Hash
+     * what is in the middle between { and }. */
+    return crc16(key + s + 1, e - s - 1) & 0x3FFF;
+}
+
+/* Return a string representation of the cluster node. */
+static sds clusterManagerNodeInfo(clusterManagerNode *node, int indent) {
+    sds info = sdsempty();
+    sds spaces = sdsempty();
+    int i;
+    for (i = 0; i < indent; i++) spaces = sdscat(spaces, " ");
+    if (indent) info = sdscat(info, spaces);
+    int is_primary = !(node->flags & CLUSTER_MANAGER_FLAG_REPLICA);
+    char *role = (is_primary ? "M" : "S");
+    sds slots = NULL;
+    if (node->dirty && node->replicate != NULL)
+        info = sdscatfmt(info, "S: %S %s:%u", node->name, node->ip, node->port);
+    else {
+        slots = clusterManagerNodeSlotsString(node);
+        sds flags = clusterManagerNodeFlagString(node);
+        info = sdscatfmt(info,
+                         "%s: %S %s:%u\n"
+                         "%s   slots:%S (%u slots) "
+                         "%S",
+                         role, node->name, node->ip, node->port, spaces, slots, node->slots_count, flags);
+        sdsfree(slots);
+        sdsfree(flags);
+    }
+    if (node->replicate != NULL)
+        info = sdscatfmt(info, "\n%s   replicates %S", spaces, node->replicate);
+    else if (node->replicas_count)
+        info = sdscatfmt(info, "\n%s   %i additional replica(s)", spaces, node->replicas_count);
+    sdsfree(spaces);
+    return info;
+}
+
+static void clusterManagerShowNodes(void) {
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *node = ln->value;
+        sds info = clusterManagerNodeInfo(node, 0);
+        printf("%s\n", (char *)info);
+        sdsfree(info);
+    }
+}
+
+static void clusterManagerShowClusterInfo(void) {
+    int primaries = 0;
+    long long keys = 0;
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *node = ln->value;
+        if (!(node->flags & CLUSTER_MANAGER_FLAG_REPLICA)) {
+            if (!node->name) continue;
+            int replicas = 0;
+            long long dbsize = -1;
+            char name[9];
+            memcpy(name, node->name, 8);
+            name[8] = '\0';
+            listIter ri;
+            listNode *rn;
+            listRewind(cluster_manager.nodes, &ri);
+            while ((rn = listNext(&ri)) != NULL) {
+                clusterManagerNode *n = rn->value;
+                if (n == node || !(n->flags & CLUSTER_MANAGER_FLAG_REPLICA)) continue;
+                if (n->replicate && !strcmp(n->replicate, node->name)) replicas++;
+            }
+            redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "DBSIZE");
+            if (reply != NULL && reply->type == REDIS_REPLY_INTEGER) dbsize = reply->integer;
+            if (dbsize < 0) {
+                char *err = "";
+                if (reply != NULL && reply->type == REDIS_REPLY_ERROR) err = reply->str;
+                CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, err);
+                if (reply != NULL) freeReplyObject(reply);
+                return;
+            };
+            if (reply != NULL) freeReplyObject(reply);
+            printf("%s:%d (%s...) -> %lld keys | %d slots | %d replicas.\n", node->ip, node->port, name, dbsize,
+                   node->slots_count, replicas);
+            primaries++;
+            keys += dbsize;
+        }
+    }
+    clusterManagerLogOk("[OK] %lld keys in %d primaries.\n", keys, primaries);
+    float keys_per_slot = keys / (float)CLUSTER_MANAGER_SLOTS;
+    printf("%.2f keys per slot on average.\n", keys_per_slot);
+}
+
+/* Flush dirty slots configuration of the node by calling CLUSTER ADDSLOTS */
+static int clusterManagerAddSlots(clusterManagerNode *node, char **err) {
+    redisReply *reply = NULL;
+    void *_reply = NULL;
+    int success = 1;
+    /* First two args are used for the command itself. */
+    int argc = node->slots_count + 2;
+    sds *argv = zmalloc(argc * sizeof(*argv));
+    size_t *argvlen = zmalloc(argc * sizeof(*argvlen));
+    argv[0] = "CLUSTER";
+    argv[1] = "ADDSLOTS";
+    argvlen[0] = 7;
+    argvlen[1] = 8;
+    *err = NULL;
+    int i, argv_idx = 2;
+    for (i = 0; i < CLUSTER_MANAGER_SLOTS; i++) {
+        if (argv_idx >= argc) break;
+        if (node->slots[i]) {
+            argv[argv_idx] = sdsfromlonglong((long long)i);
+            argvlen[argv_idx] = sdslen(argv[argv_idx]);
+            argv_idx++;
+        }
+    }
+    if (argv_idx == 2) {
+        success = 0;
+        goto cleanup;
+    }
+    redisAppendCommandArgv(node->context, argc, (const char **)argv, argvlen);
+    if (redisGetReply(node->context, &_reply) != REDIS_OK) {
+        success = 0;
+        goto cleanup;
+    }
+    reply = (redisReply *)_reply;
+    success = clusterManagerCheckRedisReply(node, reply, err);
+cleanup:
+    zfree(argvlen);
+    if (argv != NULL) {
+        for (i = 2; i < argc; i++) sdsfree(argv[i]);
+        zfree(argv);
+    }
+    if (reply != NULL) freeReplyObject(reply);
+    return success;
+}
+
+/* Get the node the slot is assigned to from the point of view of node *n.
+ * If the slot is unassigned or if the reply is an error, return NULL.
+ * Use the **err argument in order to check whether the slot is unassigned
+ * or the reply resulted in an error. */
+static clusterManagerNode *clusterManagerGetSlotOwner(clusterManagerNode *n, int slot, char **err) {
+    assert(slot >= 0 && slot < CLUSTER_MANAGER_SLOTS);
+    clusterManagerNode *owner = NULL;
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(n, "CLUSTER SLOTS");
+    if (clusterManagerCheckRedisReply(n, reply, err)) {
+        assert(reply->type == REDIS_REPLY_ARRAY);
+        size_t i;
+        for (i = 0; i < reply->elements; i++) {
+            redisReply *r = reply->element[i];
+            assert(r->type == REDIS_REPLY_ARRAY && r->elements >= 3);
+            int from, to;
+            from = r->element[0]->integer;
+            to = r->element[1]->integer;
+            if (slot < from || slot > to) continue;
+            redisReply *nr = r->element[2];
+            assert(nr->type == REDIS_REPLY_ARRAY && nr->elements >= 2);
+            char *name = NULL;
+            if (nr->elements >= 3) name = nr->element[2]->str;
+            if (name != NULL)
+                owner = clusterManagerNodeByName(name);
+            else {
+                char *ip = nr->element[0]->str;
+                assert(ip != NULL);
+                int port = (int)nr->element[1]->integer;
+                listIter li;
+                listNode *ln;
+                listRewind(cluster_manager.nodes, &li);
+                while ((ln = listNext(&li)) != NULL) {
+                    clusterManagerNode *nd = ln->value;
+                    if (strcmp(nd->ip, ip) == 0 && port == nd->port) {
+                        owner = nd;
+                        break;
+                    }
+                }
+            }
+            if (owner) break;
+        }
+    }
+    if (reply) freeReplyObject(reply);
+    return owner;
+}
+
+/* Set slot status to "importing" or "migrating" */
+static int
+clusterManagerSetSlot(clusterManagerNode *node1, clusterManagerNode *node2, int slot, const char *status, char **err) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node1,
+                                                "CLUSTER "
+                                                "SETSLOT %d %s %s",
+                                                slot, status, (char *)node2->name);
+    if (err != NULL) *err = NULL;
+    if (!reply) {
+        if (err) *err = zstrdup("CLUSTER SETSLOT failed to run");
+        return 0;
+    }
+    int success = 1;
+    if (reply->type == REDIS_REPLY_ERROR) {
+        success = 0;
+        if (err != NULL) {
+            *err = zmalloc((reply->len + 1) * sizeof(char));
+            valkey_strlcpy(*err, reply->str, (reply->len + 1));
+        } else
+            CLUSTER_MANAGER_PRINT_REPLY_ERROR(node1, reply->str);
+        goto cleanup;
+    }
+cleanup:
+    freeReplyObject(reply);
+    return success;
+}
+
+static int clusterManagerClearSlotStatus(clusterManagerNode *node, int slot) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER SETSLOT %d %s", slot, "STABLE");
+    int success = clusterManagerCheckRedisReply(node, reply, NULL);
+    if (reply) freeReplyObject(reply);
+    return success;
+}
+
+static int clusterManagerDelSlot(clusterManagerNode *node, int slot, int ignore_unassigned_err) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER DELSLOTS %d", slot);
+    char *err = NULL;
+    int success = clusterManagerCheckRedisReply(node, reply, &err);
+    if (!success && reply && reply->type == REDIS_REPLY_ERROR && ignore_unassigned_err) {
+        char *get_owner_err = NULL;
+        clusterManagerNode *assigned_to = clusterManagerGetSlotOwner(node, slot, &get_owner_err);
+        if (!assigned_to) {
+            if (get_owner_err == NULL)
+                success = 1;
+            else {
+                CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, get_owner_err);
+                zfree(get_owner_err);
+            }
+        }
+    }
+    if (!success && err != NULL) {
+        CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, err);
+        zfree(err);
+    }
+    if (reply) freeReplyObject(reply);
+    return success;
+}
+
+static int clusterManagerAddSlot(clusterManagerNode *node, int slot) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER ADDSLOTS %d", slot);
+    int success = clusterManagerCheckRedisReply(node, reply, NULL);
+    if (reply) freeReplyObject(reply);
+    return success;
+}
+
+static signed int clusterManagerCountKeysInSlot(clusterManagerNode *node, int slot) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER COUNTKEYSINSLOT %d", slot);
+    int count = -1;
+    int success = clusterManagerCheckRedisReply(node, reply, NULL);
+    if (success && reply->type == REDIS_REPLY_INTEGER) count = reply->integer;
+    if (reply) freeReplyObject(reply);
+    return count;
+}
+
+static int clusterManagerBumpEpoch(clusterManagerNode *node) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER BUMPEPOCH");
+    int success = clusterManagerCheckRedisReply(node, reply, NULL);
+    if (reply) freeReplyObject(reply);
+    return success;
+}
+
+/* Callback used by clusterManagerSetSlotOwner transaction. It should ignore
+ * errors except for ADDSLOTS errors.
+ * Return 1 if the error should be ignored. */
+static int clusterManagerOnSetOwnerErr(redisReply *reply, clusterManagerNode *n, int bulk_idx) {
+    UNUSED(reply);
+    UNUSED(n);
+    /* Only raise error when ADDSLOTS fail (bulk_idx == 1). */
+    return (bulk_idx != 1);
+}
+
+static int clusterManagerSetSlotOwner(clusterManagerNode *owner, int slot, int do_clear) {
+    int success = clusterManagerStartTransaction(owner);
+    if (!success) return 0;
+    /* Ensure the slot is not already assigned. */
+    clusterManagerDelSlot(owner, slot, 1);
+    /* Add the slot and bump epoch. */
+    clusterManagerAddSlot(owner, slot);
+    if (do_clear) clusterManagerClearSlotStatus(owner, slot);
+    clusterManagerBumpEpoch(owner);
+    success = clusterManagerExecTransaction(owner, clusterManagerOnSetOwnerErr);
+    return success;
+}
+
+/* Get the hash for the values of the specified keys in *keys_reply for the
+ * specified nodes *n1 and *n2, by calling DEBUG DIGEST-VALUE command
+ * on both nodes. Every key with same name on both nodes but having different
+ * values will be added to the *diffs list.
+ *
+ * DEBUG DIGEST-VALUE currently will only return two errors:
+ * 1. Unknown subcommand. This happened in older server versions.
+ * 2. DEBUG command not allowed. This happened when we disable enable-debug-command.
+ *
+ * Return 0 and set the error message in case of reply error. */
+static int clusterManagerCompareKeysValues(clusterManagerNode *n1,
+                                           clusterManagerNode *n2,
+                                           redisReply *keys_reply,
+                                           list *diffs,
+                                           char **n1_err,
+                                           char **n2_err) {
+    size_t i, argc = keys_reply->elements + 2;
+    static const char *hash_zero = "0000000000000000000000000000000000000000";
+    char **argv = zcalloc(argc * sizeof(char *));
+    size_t *argv_len = zcalloc(argc * sizeof(size_t));
+    argv[0] = "DEBUG";
+    argv_len[0] = 5;
+    argv[1] = "DIGEST-VALUE";
+    argv_len[1] = 12;
+    for (i = 0; i < keys_reply->elements; i++) {
+        redisReply *entry = keys_reply->element[i];
+        int idx = i + 2;
+        argv[idx] = entry->str;
+        argv_len[idx] = entry->len;
+    }
+    int success = 0;
+    void *_reply1 = NULL, *_reply2 = NULL;
+    redisReply *r1 = NULL, *r2 = NULL;
+    redisAppendCommandArgv(n1->context, argc, (const char **)argv, argv_len);
+    success = (redisGetReply(n1->context, &_reply1) == REDIS_OK);
+    if (!success) {
+        fprintf(stderr, "Error getting DIGEST-VALUE from %s:%d, error: %s\n", n1->ip, n1->port, n1->context->errstr);
+        exit(1);
+    }
+    r1 = (redisReply *)_reply1;
+    redisAppendCommandArgv(n2->context, argc, (const char **)argv, argv_len);
+    success = (redisGetReply(n2->context, &_reply2) == REDIS_OK);
+    if (!success) {
+        fprintf(stderr, "Error getting DIGEST-VALUE from %s:%d, error: %s\n", n2->ip, n2->port, n2->context->errstr);
+        exit(1);
+    }
+    r2 = (redisReply *)_reply2;
+    success = (r1->type != REDIS_REPLY_ERROR && r2->type != REDIS_REPLY_ERROR);
+    if (r1->type == REDIS_REPLY_ERROR) {
+        if (n1_err != NULL) {
+            *n1_err = zmalloc((r1->len + 1) * sizeof(char));
+            valkey_strlcpy(*n1_err, r1->str, r1->len + 1);
+        }
+        CLUSTER_MANAGER_PRINT_REPLY_ERROR(n1, r1->str);
+        success = 0;
+    }
+    if (r2->type == REDIS_REPLY_ERROR) {
+        if (n2_err != NULL) {
+            *n2_err = zmalloc((r2->len + 1) * sizeof(char));
+            valkey_strlcpy(*n2_err, r2->str, r2->len + 1);
+        }
+        CLUSTER_MANAGER_PRINT_REPLY_ERROR(n2, r2->str);
+        success = 0;
+    }
+    if (!success) goto cleanup;
+    assert(keys_reply->elements == r1->elements && keys_reply->elements == r2->elements);
+    for (i = 0; i < keys_reply->elements; i++) {
+        char *key = keys_reply->element[i]->str;
+        char *hash1 = r1->element[i]->str;
+        char *hash2 = r2->element[i]->str;
+        /* Ignore keys that don't exist in both nodes. */
+        if (strcmp(hash1, hash_zero) == 0 || strcmp(hash2, hash_zero) == 0) continue;
+        if (strcmp(hash1, hash2) != 0) listAddNodeTail(diffs, key);
+    }
+cleanup:
+    if (r1) freeReplyObject(r1);
+    if (r2) freeReplyObject(r2);
+    zfree(argv);
+    zfree(argv_len);
+    return success;
+}
+
+/* Migrate keys taken from reply->elements. It returns the reply from the
+ * MIGRATE command, or NULL if something goes wrong. If the argument 'dots'
+ * is not NULL, a dot will be printed for every migrated key. */
+static redisReply *clusterManagerMigrateKeysInReply(clusterManagerNode *source,
+                                                    clusterManagerNode *target,
+                                                    redisReply *reply,
+                                                    int replace,
+                                                    int timeout,
+                                                    char *dots) {
+    redisReply *migrate_reply = NULL;
+    char **argv = NULL;
+    size_t *argv_len = NULL;
+    int c = (replace ? 8 : 7);
+    if (config.conn_info.auth) c += 2;
+    if (config.conn_info.user) c += 1;
+    size_t argc = c + reply->elements;
+    size_t i, offset = 6; // Keys Offset
+    argv = zcalloc(argc * sizeof(char *));
+    argv_len = zcalloc(argc * sizeof(size_t));
+    char portstr[255];
+    char timeoutstr[255];
+    snprintf(portstr, 10, "%d", target->port);
+    snprintf(timeoutstr, 10, "%d", timeout);
+    argv[0] = "MIGRATE";
+    argv_len[0] = 7;
+    argv[1] = target->ip;
+    argv_len[1] = strlen(target->ip);
+    argv[2] = portstr;
+    argv_len[2] = strlen(portstr);
+    argv[3] = "";
+    argv_len[3] = 0;
+    argv[4] = "0";
+    argv_len[4] = 1;
+    argv[5] = timeoutstr;
+    argv_len[5] = strlen(timeoutstr);
+    if (replace) {
+        argv[offset] = "REPLACE";
+        argv_len[offset] = 7;
+        offset++;
+    }
+    if (config.conn_info.auth) {
+        if (config.conn_info.user) {
+            argv[offset] = "AUTH2";
+            argv_len[offset] = 5;
+            offset++;
+            argv[offset] = config.conn_info.user;
+            argv_len[offset] = strlen(config.conn_info.user);
+            offset++;
+            argv[offset] = config.conn_info.auth;
+            argv_len[offset] = strlen(config.conn_info.auth);
+            offset++;
+        } else {
+            argv[offset] = "AUTH";
+            argv_len[offset] = 4;
+            offset++;
+            argv[offset] = config.conn_info.auth;
+            argv_len[offset] = strlen(config.conn_info.auth);
+            offset++;
+        }
+    }
+    argv[offset] = "KEYS";
+    argv_len[offset] = 4;
+    offset++;
+    for (i = 0; i < reply->elements; i++) {
+        redisReply *entry = reply->element[i];
+        size_t idx = i + offset;
+        assert(entry->type == REDIS_REPLY_STRING);
+        argv[idx] = (char *)sdsnewlen(entry->str, entry->len);
+        argv_len[idx] = entry->len;
+        if (dots) dots[i] = '.';
+    }
+    if (dots) dots[reply->elements] = '\0';
+    void *_reply = NULL;
+    redisAppendCommandArgv(source->context, argc, (const char **)argv, argv_len);
+    int success = (redisGetReply(source->context, &_reply) == REDIS_OK);
+    for (i = 0; i < reply->elements; i++) sdsfree(argv[i + offset]);
+    if (!success) goto cleanup;
+    migrate_reply = (redisReply *)_reply;
+cleanup:
+    zfree(argv);
+    zfree(argv_len);
+    return migrate_reply;
+}
+
+/* Migrate all keys in the given slot from source to target.*/
+static int clusterManagerMigrateKeysInSlot(clusterManagerNode *source,
+                                           clusterManagerNode *target,
+                                           int slot,
+                                           int timeout,
+                                           int pipeline,
+                                           int verbose,
+                                           char **err) {
+    int success = 1;
+    int do_fix = config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_FIX;
+    int do_replace = config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_REPLACE;
+    while (1) {
+        char *dots = NULL;
+        redisReply *reply = NULL, *migrate_reply = NULL;
+        reply = CLUSTER_MANAGER_COMMAND(source,
+                                        "CLUSTER "
+                                        "GETKEYSINSLOT %d %d",
+                                        slot, pipeline);
+        success = (reply != NULL);
+        if (!success) return 0;
+        if (reply->type == REDIS_REPLY_ERROR) {
+            success = 0;
+            if (err != NULL) {
+                *err = zmalloc((reply->len + 1) * sizeof(char));
+                valkey_strlcpy(*err, reply->str, (reply->len + 1));
+                CLUSTER_MANAGER_PRINT_REPLY_ERROR(source, *err);
+            }
+            goto next;
+        }
+        assert(reply->type == REDIS_REPLY_ARRAY);
+        size_t count = reply->elements;
+        if (count == 0) {
+            freeReplyObject(reply);
+            break;
+        }
+        if (verbose) dots = zmalloc((count + 1) * sizeof(char));
+        /* Calling MIGRATE command. */
+        migrate_reply = clusterManagerMigrateKeysInReply(source, target, reply, 0, timeout, dots);
+        if (migrate_reply == NULL) goto next;
+        if (migrate_reply->type == REDIS_REPLY_ERROR) {
+            int is_busy = strstr(migrate_reply->str, "BUSYKEY") != NULL;
+            int not_served = 0;
+            if (!is_busy) {
+                /* Check if the slot is unassigned (not served) in the
+                 * source node's configuration. */
+                char *get_owner_err = NULL;
+                clusterManagerNode *served_by = clusterManagerGetSlotOwner(source, slot, &get_owner_err);
+                if (!served_by) {
+                    if (get_owner_err == NULL)
+                        not_served = 1;
+                    else {
+                        CLUSTER_MANAGER_PRINT_REPLY_ERROR(source, get_owner_err);
+                        zfree(get_owner_err);
+                    }
+                }
+            }
+            /* Try to handle errors. */
+            if (is_busy || not_served) {
+                /* If the key's slot is not served, try to assign slot
+                 * to the target node. */
+                if (do_fix && not_served) {
+                    clusterManagerLogWarn("*** Slot was not served, setting "
+                                          "owner to node %s:%d.\n",
+                                          target->ip, target->port);
+                    clusterManagerSetSlot(source, target, slot, "node", NULL);
+                }
+                /* If the key already exists in the target node (BUSYKEY),
+                 * check whether its value is the same in both nodes.
+                 * In case of equal values, retry migration with the
+                 * REPLACE option.
+                 *
+                 * In case of different values:
+                 *  - If --cluster-replace option is not provided, stop
+                 *    and warn the user.
+                 *  - If --cluster-replace option is provided, proceed it. */
+                if (is_busy) {
+                    clusterManagerLogWarn("\n*** Target key exists\n");
+                    if (!do_replace) {
+                        clusterManagerLogWarn("*** Checking key values on "
+                                              "both nodes...\n");
+                        char *source_err = NULL;
+                        char *target_err = NULL;
+                        list *diffs = listCreate();
+                        success =
+                            clusterManagerCompareKeysValues(source, target, reply, diffs, &source_err, &target_err);
+                        if (!success) {
+                            clusterManagerLogErr("*** Value check failed!\n");
+                            const char *debug_not_allowed = "ERR DEBUG command not allowed.";
+                            if ((source_err && !strncmp(source_err, debug_not_allowed, 30)) ||
+                                (target_err && !strncmp(target_err, debug_not_allowed, 30))) {
+                                clusterManagerLogErr("DEBUG command is not allowed.\n"
+                                                     "You can turn on the enable-debug-command option.\n"
+                                                     "Or you can relaunch the command with --cluster-replace "
+                                                     "option to force key overriding.\n");
+                            } else if (source_err || target_err) {
+                                clusterManagerLogErr("DEBUG DIGEST-VALUE command is not supported.\n"
+                                                     "You can relaunch the command with --cluster-replace "
+                                                     "option to force key overriding.\n");
+                            }
+                            if (source_err) zfree(source_err);
+                            if (target_err) zfree(target_err);
+                            listRelease(diffs);
+                            goto next;
+                        }
+                        if (listLength(diffs) > 0) {
+                            success = 0;
+                            clusterManagerLogErr("*** Found %d key(s) in both source node and "
+                                                 "target node having different values.\n"
+                                                 "    Source node: %s:%d\n"
+                                                 "    Target node: %s:%d\n"
+                                                 "    Keys(s):\n",
+                                                 listLength(diffs), source->ip, source->port, target->ip, target->port);
+                            listIter dli;
+                            listNode *dln;
+                            listRewind(diffs, &dli);
+                            while ((dln = listNext(&dli)) != NULL) {
+                                char *k = dln->value;
+                                clusterManagerLogErr("    - %s\n", k);
+                            }
+                            clusterManagerLogErr("Please fix the above key(s) "
+                                                 "manually and try again "
+                                                 "or relaunch the command \n"
+                                                 "with --cluster-replace "
+                                                 "option to force key "
+                                                 "overriding.\n");
+                            listRelease(diffs);
+                            goto next;
+                        }
+                        listRelease(diffs);
+                    }
+                    clusterManagerLogWarn("*** Replacing target keys...\n");
+                }
+                freeReplyObject(migrate_reply);
+                migrate_reply = clusterManagerMigrateKeysInReply(source, target, reply, is_busy, timeout, NULL);
+                success = (migrate_reply != NULL && migrate_reply->type != REDIS_REPLY_ERROR);
+            } else
+                success = 0;
+            if (!success) {
+                if (migrate_reply != NULL) {
+                    if (err) {
+                        *err = zmalloc((migrate_reply->len + 1) * sizeof(char));
+                        valkey_strlcpy(*err, migrate_reply->str, (migrate_reply->len + 1));
+                    }
+                    printf("\n");
+                    CLUSTER_MANAGER_PRINT_REPLY_ERROR(source, migrate_reply->str);
+                }
+                goto next;
+            }
+        }
+        if (verbose) {
+            printf("%s", dots);
+            fflush(stdout);
+        }
+    next:
+        if (reply != NULL) freeReplyObject(reply);
+        if (migrate_reply != NULL) freeReplyObject(migrate_reply);
+        if (dots) zfree(dots);
+        if (!success) break;
+    }
+    return success;
+}
+
+/* Move slots between source and target nodes using MIGRATE.
+ *
+ * Options:
+ * CLUSTER_MANAGER_OPT_VERBOSE -- Print a dot for every moved key.
+ * CLUSTER_MANAGER_OPT_COLD    -- Move keys without opening slots /
+ *                                reconfiguring the nodes.
+ * CLUSTER_MANAGER_OPT_UPDATE  -- Update node->slots for source/target nodes.
+ * CLUSTER_MANAGER_OPT_QUIET   -- Don't print info messages.
+ */
+static int
+clusterManagerMoveSlot(clusterManagerNode *source, clusterManagerNode *target, int slot, int opts, char **err) {
+    if (!(opts & CLUSTER_MANAGER_OPT_QUIET)) {
+        printf("Moving slot %d from %s:%d to %s:%d: ", slot, source->ip, source->port, target->ip, target->port);
+        fflush(stdout);
+    }
+    if (err != NULL) *err = NULL;
+    int pipeline = config.cluster_manager_command.pipeline, timeout = config.cluster_manager_command.timeout,
+        print_dots = (opts & CLUSTER_MANAGER_OPT_VERBOSE), option_cold = (opts & CLUSTER_MANAGER_OPT_COLD), success = 1;
+    if (!option_cold) {
+        success = clusterManagerSetSlot(target, source, slot, "importing", err);
+        if (!success) return 0;
+        success = clusterManagerSetSlot(source, target, slot, "migrating", err);
+        if (!success) return 0;
+    }
+    success = clusterManagerMigrateKeysInSlot(source, target, slot, timeout, pipeline, print_dots, err);
+    if (!(opts & CLUSTER_MANAGER_OPT_QUIET)) printf("\n");
+    if (!success) return 0;
+    if (!option_cold) {
+        /* Set the new node as the owner of the slot in all the known nodes.
+         *
+         * We inform the target node first. It will propagate the information to
+         * the rest of the cluster.
+         *
+         * If we inform any other node first, it can happen that the target node
+         * crashes before it is set as the new owner and then the slot is left
+         * without an owner which results in redirect loops. See issue #7116. */
+        success = clusterManagerSetSlot(target, target, slot, "node", err);
+        if (!success) return 0;
+
+        /* Inform the source node. If the source node has just lost its last
+         * slot and the target node has already informed the source node, the
+         * source node has turned itself into a replica. This is not an error in
+         * this scenario so we ignore it. See issue #9223.
+         *
+         * Another acceptable error can arise now that the primary pre-replicates
+         * `cluster setslot` commands to replicas while blocking the client on the
+         * primary. This change enhances the reliability of `cluster setslot` in
+         * the face of primary failures. However, while our client is blocked on
+         * the primary awaiting replication, the primary might become a replica
+         * for the same reason as mentioned above, resulting in the client being
+         * unblocked with the role change error.
+         *
+         * Another acceptable error can arise now that the primary pre-replicates
+         * `cluster setslot` commands to replicas while blocking the client on the
+         * primary. And during the block, the replicas might automatically migrate
+         * to another primary, resulting in the client being unblocked with the
+         * NOREPLICAS error. In this case, since the configuration will eventually
+         * propagate itself, we can safely ignore this error on the source node. */
+        success = clusterManagerSetSlot(source, target, slot, "node", err);
+        if (!success && err) {
+            const char *acceptable[] = {"ERR Please use SETSLOT only with masters.",
+                                        "ERR Please use SETSLOT only with primaries.", "UNBLOCKED", "NOREPLICAS"};
+            for (size_t i = 0; i < sizeof(acceptable) / sizeof(acceptable[0]); i++) {
+                if (!strncmp(*err, acceptable[i], strlen(acceptable[i]))) {
+                    zfree(*err);
+                    *err = NULL;
+                    success = 1;
+                    break;
+                }
+            }
+        }
+        if (!success && err) {
+            return 0;
+        }
+
+        /* We also inform the other nodes to avoid redirects in case the target
+         * node is slow to propagate the change to the entire cluster. */
+        listIter li;
+        listNode *ln;
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            if (n == target || n == source) continue; /* already done */
+            if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+            success = clusterManagerSetSlot(n, target, slot, "node", err);
+            if (!success) return 0;
+        }
+    }
+    /* Update the node logical config */
+    if (opts & CLUSTER_MANAGER_OPT_UPDATE) {
+        source->slots[slot] = 0;
+        target->slots[slot] = 1;
+    }
+    return 1;
+}
+
+/* Flush the dirty node configuration by calling replicate for replicas or
+ * adding the slots defined in the primaries. */
+static int clusterManagerFlushNodeConfig(clusterManagerNode *node, char **err) {
+    if (!node->dirty) return 0;
+    redisReply *reply = NULL;
+    int is_err = 0, success = 1;
+    if (err != NULL) *err = NULL;
+    if (node->replicate != NULL) {
+        reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER REPLICATE %s", node->replicate);
+        if (reply == NULL || (is_err = (reply->type == REDIS_REPLY_ERROR))) {
+            if (is_err && err != NULL) {
+                *err = zmalloc((reply->len + 1) * sizeof(char));
+                valkey_strlcpy(*err, reply->str, (reply->len + 1));
+            }
+            success = 0;
+            /* If the cluster did not already joined it is possible that
+             * the replica does not know the primary node yet. So on errors
+             * we return ASAP leaving the dirty flag set, to flush the
+             * config later. */
+            goto cleanup;
+        }
+    } else {
+        int added = clusterManagerAddSlots(node, err);
+        if (!added || *err != NULL) success = 0;
+    }
+    node->dirty = 0;
+cleanup:
+    if (reply != NULL) freeReplyObject(reply);
+    return success;
+}
+
+/* Wait until the cluster configuration is consistent. */
+static void clusterManagerWaitForClusterJoin(void) {
+    printf("Waiting for the cluster to join\n");
+    int counter = 0, check_after = CLUSTER_JOIN_CHECK_AFTER + (int)(listLength(cluster_manager.nodes) * 0.15f);
+    while (!clusterManagerIsConfigConsistent()) {
+        printf(".");
+        fflush(stdout);
+        sleep(1);
+        if (++counter > check_after) {
+            dict *status = clusterManagerGetLinkStatus();
+            dictIterator *iter = NULL;
+            if (status != NULL && dictSize(status) > 0) {
+                printf("\n");
+                clusterManagerLogErr("Warning: %d node(s) may "
+                                     "be unreachable\n",
+                                     dictSize(status));
+                iter = dictGetIterator(status);
+                dictEntry *entry;
+                while ((entry = dictNext(iter)) != NULL) {
+                    sds nodeaddr = (sds)dictGetKey(entry);
+                    char *node_ip = NULL;
+                    int node_port = 0, node_bus_port = 0;
+                    list *from = (list *)dictGetVal(entry);
+                    if (parseClusterNodeAddress(nodeaddr, &node_ip, &node_port, &node_bus_port) && node_bus_port) {
+                        clusterManagerLogErr(" - The port %d of node %s may "
+                                             "be unreachable from:\n",
+                                             node_bus_port, node_ip);
+                    } else {
+                        clusterManagerLogErr(" - Node %s may be unreachable "
+                                             "from:\n",
+                                             nodeaddr);
+                    }
+                    listIter li;
+                    listNode *ln;
+                    listRewind(from, &li);
+                    while ((ln = listNext(&li)) != NULL) {
+                        sds from_addr = ln->value;
+                        clusterManagerLogErr("   %s\n", from_addr);
+                        sdsfree(from_addr);
+                    }
+                    clusterManagerLogErr("Cluster bus ports must be reachable "
+                                         "by every node.\nRemember that "
+                                         "cluster bus ports are different "
+                                         "from standard instance ports.\n");
+                    listEmpty(from);
+                }
+            }
+            if (iter != NULL) dictReleaseIterator(iter);
+            if (status != NULL) dictRelease(status);
+            counter = 0;
+        }
+    }
+    printf("\n");
+}
+
+/* Load node's cluster configuration by calling "CLUSTER NODES" command.
+ * Node's configuration (name, replicate, slots, ...) is then updated.
+ * If CLUSTER_MANAGER_OPT_GETFRIENDS flag is set into 'opts' argument,
+ * and node already knows other nodes, the node's friends list is populated
+ * with the other nodes info. */
+static int clusterManagerNodeLoadInfo(clusterManagerNode *node, int opts, char **err) {
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER NODES");
+    int success = 1;
+    *err = NULL;
+    if (!clusterManagerCheckRedisReply(node, reply, err)) {
+        success = 0;
+        goto cleanup;
+    }
+    int getfriends = (opts & CLUSTER_MANAGER_OPT_GETFRIENDS);
+    char *lines = reply->str, *p, *line;
+    while ((p = strstr(lines, "\n")) != NULL) {
+        *p = '\0';
+        line = lines;
+        lines = p + 1;
+        char *name = NULL, *addr = NULL, *flags = NULL, *primary_id = NULL, *ping_sent = NULL, *ping_recv = NULL,
+             *config_epoch = NULL, *link_status = NULL;
+        UNUSED(link_status);
+        int i = 0;
+        while ((p = strchr(line, ' ')) != NULL) {
+            *p = '\0';
+            char *token = line;
+            line = p + 1;
+            switch (i++) {
+            case 0: name = token; break;
+            case 1: addr = token; break;
+            case 2: flags = token; break;
+            case 3: primary_id = token; break;
+            case 4: ping_sent = token; break;
+            case 5: ping_recv = token; break;
+            case 6: config_epoch = token; break;
+            case 7: link_status = token; break;
+            }
+            if (i == 8) break; // Slots
+        }
+        if (!flags) {
+            success = 0;
+            goto cleanup;
+        }
+
+        char *ip = NULL;
+        int port = 0, bus_port = 0;
+        if (addr == NULL || !parseClusterNodeAddress(addr, &ip, &port, &bus_port)) {
+            fprintf(stderr, "Error: invalid CLUSTER NODES reply\n");
+            success = 0;
+            goto cleanup;
+        }
+
+        int myself = (strstr(flags, "myself") != NULL);
+        clusterManagerNode *currentNode = NULL;
+        if (myself) {
+            /* bus-port could be wrong, correct it here, see clusterManagerNewNode. */
+            node->bus_port = bus_port;
+            node->flags |= CLUSTER_MANAGER_FLAG_MYSELF;
+            currentNode = node;
+            clusterManagerNodeResetSlots(node);
+            if (i == 8) {
+                int remaining = strlen(line);
+                while (remaining > 0) {
+                    p = strchr(line, ' ');
+                    if (p == NULL) p = line + remaining;
+                    remaining -= (p - line);
+
+                    char *slotsdef = line;
+                    *p = '\0';
+                    if (remaining) {
+                        line = p + 1;
+                        remaining--;
+                    } else
+                        line = p;
+                    char *dash = NULL;
+                    if (slotsdef[0] == '[') {
+                        slotsdef++;
+                        if ((p = strstr(slotsdef, "->-"))) { // Migrating
+                            *p = '\0';
+                            p += 3;
+                            char *closing_bracket = strchr(p, ']');
+                            if (closing_bracket) *closing_bracket = '\0';
+                            sds slot = sdsnew(slotsdef);
+                            sds dst = sdsnew(p);
+                            node->migrating_count += 2;
+                            node->migrating = zrealloc(node->migrating, (node->migrating_count * sizeof(sds)));
+                            node->migrating[node->migrating_count - 2] = slot;
+                            node->migrating[node->migrating_count - 1] = dst;
+                        } else if ((p = strstr(slotsdef, "-<-"))) { // Importing
+                            *p = '\0';
+                            p += 3;
+                            char *closing_bracket = strchr(p, ']');
+                            if (closing_bracket) *closing_bracket = '\0';
+                            sds slot = sdsnew(slotsdef);
+                            sds src = sdsnew(p);
+                            node->importing_count += 2;
+                            node->importing = zrealloc(node->importing, (node->importing_count * sizeof(sds)));
+                            node->importing[node->importing_count - 2] = slot;
+                            node->importing[node->importing_count - 1] = src;
+                        }
+                    } else if ((dash = strchr(slotsdef, '-')) != NULL) {
+                        p = dash;
+                        int start, stop;
+                        *p = '\0';
+                        start = atoi(slotsdef);
+                        stop = atoi(p + 1);
+                        node->slots_count += (stop - (start - 1));
+                        while (start <= stop) node->slots[start++] = 1;
+                    } else if (p > slotsdef) {
+                        node->slots[atoi(slotsdef)] = 1;
+                        node->slots_count++;
+                    }
+                }
+            }
+            node->dirty = 0;
+        } else if (!getfriends) {
+            if (!(node->flags & CLUSTER_MANAGER_FLAG_MYSELF))
+                continue;
+            else
+                break;
+        } else {
+            currentNode = clusterManagerNewNode(sdsnew(ip), port, bus_port);
+            currentNode->flags |= CLUSTER_MANAGER_FLAG_FRIEND;
+            if (node->friends == NULL) node->friends = listCreate();
+            listAddNodeTail(node->friends, currentNode);
+        }
+        if (name != NULL) {
+            if (currentNode->name) sdsfree(currentNode->name);
+            currentNode->name = sdsnew(name);
+        }
+        if (currentNode->flags_str != NULL) freeClusterManagerNodeFlags(currentNode->flags_str);
+        currentNode->flags_str = listCreate();
+        int flag_len;
+        while ((flag_len = strlen(flags)) > 0) {
+            sds flag = NULL;
+            char *fp = strchr(flags, ',');
+            if (fp) {
+                *fp = '\0';
+                flag = sdsnew(flags);
+                flags = fp + 1;
+            } else {
+                flag = sdsnew(flags);
+                flags += flag_len;
+            }
+            if (strcmp(flag, "noaddr") == 0)
+                currentNode->flags |= CLUSTER_MANAGER_FLAG_NOADDR;
+            else if (strcmp(flag, "disconnected") == 0)
+                currentNode->flags |= CLUSTER_MANAGER_FLAG_DISCONNECT;
+            else if (strcmp(flag, "fail") == 0)
+                currentNode->flags |= CLUSTER_MANAGER_FLAG_FAIL;
+            else if ((strcmp(flag, "slave") == 0) || (strcmp(flag, "replica") == 0)) {
+                currentNode->flags |= CLUSTER_MANAGER_FLAG_REPLICA;
+                if (primary_id != NULL) {
+                    if (currentNode->replicate) sdsfree(currentNode->replicate);
+                    currentNode->replicate = sdsnew(primary_id);
+                }
+            }
+            listAddNodeTail(currentNode->flags_str, flag);
+        }
+        if (config_epoch != NULL) currentNode->current_epoch = atoll(config_epoch);
+        if (ping_sent != NULL) currentNode->ping_sent = atoll(ping_sent);
+        if (ping_recv != NULL) currentNode->ping_recv = atoll(ping_recv);
+        if (!getfriends && myself) break;
+    }
+cleanup:
+    if (reply) freeReplyObject(reply);
+    return success;
+}
+
+/* Retrieves info about the cluster using argument 'node' as the starting
+ * point. All nodes will be loaded inside the cluster_manager.nodes list.
+ * Warning: if something goes wrong, it will free the starting node before
+ * returning 0. */
+static int clusterManagerLoadInfoFromNode(clusterManagerNode *node) {
+    if (node->context == NULL && !clusterManagerNodeConnect(node)) {
+        freeClusterManagerNode(node);
+        return 0;
+    }
+    char *e = NULL;
+    if (!clusterManagerNodeIsCluster(node, &e)) {
+        clusterManagerPrintNotClusterNodeError(node, e);
+        if (e) zfree(e);
+        freeClusterManagerNode(node);
+        return 0;
+    }
+    e = NULL;
+    if (!clusterManagerNodeLoadInfo(node, CLUSTER_MANAGER_OPT_GETFRIENDS, &e)) {
+        if (e) {
+            CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, e);
+            zfree(e);
+        }
+        freeClusterManagerNode(node);
+        return 0;
+    }
+    listIter li;
+    listNode *ln;
+    if (cluster_manager.nodes != NULL) {
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) freeClusterManagerNode((clusterManagerNode *)ln->value);
+        listRelease(cluster_manager.nodes);
+    }
+    cluster_manager.nodes = listCreate();
+    listAddNodeTail(cluster_manager.nodes, node);
+    if (node->friends != NULL) {
+        listRewind(node->friends, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *friend = ln->value;
+            if (!friend->ip || !friend->port) goto invalid_friend;
+            if (!friend->context && !clusterManagerNodeConnect(friend)) goto invalid_friend;
+            e = NULL;
+            if (clusterManagerNodeLoadInfo(friend, 0, &e)) {
+                if (friend->flags &
+                    (CLUSTER_MANAGER_FLAG_NOADDR | CLUSTER_MANAGER_FLAG_DISCONNECT | CLUSTER_MANAGER_FLAG_FAIL)) {
+                    goto invalid_friend;
+                }
+                listAddNodeTail(cluster_manager.nodes, friend);
+            } else {
+                clusterManagerLogErr("[ERR] Unable to load info for "
+                                     "node %s:%d\n",
+                                     friend->ip, friend->port);
+                goto invalid_friend;
+            }
+            continue;
+        invalid_friend:
+            if (!(friend->flags & CLUSTER_MANAGER_FLAG_REPLICA)) cluster_manager.unreachable_primaries++;
+            freeClusterManagerNode(friend);
+        }
+        listRelease(node->friends);
+        node->friends = NULL;
+    }
+    // Count replicas for each node
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->replicate != NULL) {
+            clusterManagerNode *primary = clusterManagerNodeByName(n->replicate);
+            if (primary == NULL) {
+                clusterManagerLogWarn("*** WARNING: %s:%d claims to be "
+                                      "replica of unknown node ID %s.\n",
+                                      n->ip, n->port, n->replicate);
+            } else
+                primary->replicas_count++;
+        }
+    }
+    return 1;
+}
+
+/* Compare functions used by various sorting operations. */
+int clusterManagerSlotCompare(const void *slot1, const void *slot2) {
+    const char **i1 = (const char **)slot1;
+    const char **i2 = (const char **)slot2;
+    return strcmp(*i1, *i2);
+}
+
+int clusterManagerSlotCountCompareDesc(const void *n1, const void *n2) {
+    clusterManagerNode *node1 = *((clusterManagerNode **)n1);
+    clusterManagerNode *node2 = *((clusterManagerNode **)n2);
+    return node2->slots_count - node1->slots_count;
+}
+
+int clusterManagerCompareNodeBalance(const void *n1, const void *n2) {
+    clusterManagerNode *node1 = *((clusterManagerNode **)n1);
+    clusterManagerNode *node2 = *((clusterManagerNode **)n2);
+    return node1->balance - node2->balance;
+}
+
+static sds clusterManagerGetConfigSignature(clusterManagerNode *node) {
+    sds signature = NULL;
+    int node_count = 0, i = 0, name_len = 0;
+    char **node_configs = NULL;
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER NODES");
+    if (reply == NULL || reply->type == REDIS_REPLY_ERROR) goto cleanup;
+    char *lines = reply->str, *p, *line;
+    while ((p = strstr(lines, "\n")) != NULL) {
+        i = 0;
+        *p = '\0';
+        line = lines;
+        lines = p + 1;
+        char *nodename = NULL;
+        int tot_size = 0;
+        while ((p = strchr(line, ' ')) != NULL) {
+            *p = '\0';
+            char *token = line;
+            line = p + 1;
+            if (i == 0) {
+                nodename = token;
+                tot_size = (p - token);
+                name_len = tot_size++; // Make room for ':' in tot_size
+            }
+            if (++i == 8) break;
+        }
+        if (i != 8) continue;
+        if (nodename == NULL) continue;
+        int remaining = strlen(line);
+        if (remaining == 0) continue;
+        char **slots = NULL;
+        int c = 0;
+        while (remaining > 0) {
+            p = strchr(line, ' ');
+            if (p == NULL) p = line + remaining;
+            int size = (p - line);
+            remaining -= size;
+            tot_size += size;
+            char *slotsdef = line;
+            *p = '\0';
+            if (remaining) {
+                line = p + 1;
+                remaining--;
+            } else
+                line = p;
+            if (slotsdef[0] != '[') {
+                c++;
+                slots = zrealloc(slots, (c * sizeof(char *)));
+                slots[c - 1] = slotsdef;
+            }
+        }
+        if (c > 0) {
+            if (c > 1) qsort(slots, c, sizeof(char *), clusterManagerSlotCompare);
+            node_count++;
+            node_configs = zrealloc(node_configs, (node_count * sizeof(char *)));
+            /* Make room for '|' separators. */
+            tot_size += (sizeof(char) * (c - 1));
+            char *cfg = zmalloc((sizeof(char) * tot_size) + 1);
+            memcpy(cfg, nodename, name_len);
+            char *sp = cfg + name_len;
+            *(sp++) = ':';
+            for (i = 0; i < c; i++) {
+                if (i > 0) *(sp++) = ',';
+                int slen = strlen(slots[i]);
+                memcpy(sp, slots[i], slen);
+                sp += slen;
+            }
+            *(sp++) = '\0';
+            node_configs[node_count - 1] = cfg;
+        }
+        zfree(slots);
+    }
+    if (node_count > 0) {
+        if (node_count > 1) {
+            qsort(node_configs, node_count, sizeof(char *), clusterManagerSlotCompare);
+        }
+        signature = sdsempty();
+        for (i = 0; i < node_count; i++) {
+            if (i > 0) signature = sdscatprintf(signature, "%c", '|');
+            signature = sdscatfmt(signature, "%s", node_configs[i]);
+        }
+    }
+cleanup:
+    if (reply != NULL) freeReplyObject(reply);
+    if (node_configs != NULL) {
+        for (i = 0; i < node_count; i++) zfree(node_configs[i]);
+        zfree(node_configs);
+    }
+    return signature;
+}
+
+static int clusterManagerIsConfigConsistent(void) {
+    if (cluster_manager.nodes == NULL) return 0;
+    int consistent = (listLength(cluster_manager.nodes) <= 1);
+    // If the Cluster has only one node, it's always consistent
+    if (consistent) return 1;
+    sds first_cfg = NULL;
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *node = ln->value;
+        sds cfg = clusterManagerGetConfigSignature(node);
+        if (cfg == NULL) {
+            consistent = 0;
+            break;
+        }
+        if (first_cfg == NULL)
+            first_cfg = cfg;
+        else {
+            consistent = !sdscmp(first_cfg, cfg);
+            sdsfree(cfg);
+            if (!consistent) break;
+        }
+    }
+    if (first_cfg != NULL) sdsfree(first_cfg);
+    return consistent;
+}
+
+static list *clusterManagerGetDisconnectedLinks(clusterManagerNode *node) {
+    list *links = NULL;
+    redisReply *reply = CLUSTER_MANAGER_COMMAND(node, "CLUSTER NODES");
+    if (!clusterManagerCheckRedisReply(node, reply, NULL)) goto cleanup;
+    links = listCreate();
+    char *lines = reply->str, *p, *line;
+    while ((p = strstr(lines, "\n")) != NULL) {
+        int i = 0;
+        *p = '\0';
+        line = lines;
+        lines = p + 1;
+        char *nodename = NULL, *addr = NULL, *flags = NULL, *link_status = NULL;
+        while ((p = strchr(line, ' ')) != NULL) {
+            *p = '\0';
+            char *token = line;
+            line = p + 1;
+            if (i == 0)
+                nodename = token;
+            else if (i == 1)
+                addr = token;
+            else if (i == 2)
+                flags = token;
+            else if (i == 7)
+                link_status = token;
+            else if (i == 8)
+                break;
+            i++;
+        }
+        if (i == 7) link_status = line;
+        if (nodename == NULL || addr == NULL || flags == NULL || link_status == NULL) continue;
+        if (strstr(flags, "myself") != NULL) continue;
+        int disconnected = ((strstr(flags, "disconnected") != NULL) || (strstr(link_status, "disconnected")));
+        int handshaking = (strstr(flags, "handshake") != NULL);
+        if (disconnected || handshaking) {
+            clusterManagerLink *link = zmalloc(sizeof(*link));
+            link->node_name = sdsnew(nodename);
+            link->node_addr = sdsnew(addr);
+            link->connected = 0;
+            link->handshaking = handshaking;
+            listAddNodeTail(links, link);
+        }
+    }
+cleanup:
+    if (reply != NULL) freeReplyObject(reply);
+    return links;
+}
+
+/* Check for disconnected cluster links. It returns a dict whose keys
+ * are the unreachable node addresses and the values are lists of
+ * node addresses that cannot reach the unreachable node. */
+static dict *clusterManagerGetLinkStatus(void) {
+    if (cluster_manager.nodes == NULL) return NULL;
+    dict *status = dictCreate(&clusterManagerLinkDictType);
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *node = ln->value;
+        list *links = clusterManagerGetDisconnectedLinks(node);
+        if (links) {
+            listIter lli;
+            listNode *lln;
+            listRewind(links, &lli);
+            while ((lln = listNext(&lli)) != NULL) {
+                clusterManagerLink *link = lln->value;
+                list *from = NULL;
+                dictEntry *entry = dictFind(status, link->node_addr);
+                if (entry)
+                    from = dictGetVal(entry);
+                else {
+                    from = listCreate();
+                    dictAdd(status, sdsdup(link->node_addr), from);
+                }
+                sds myaddr = sdsempty();
+                myaddr = sdscatfmt(myaddr, "%s:%u", node->ip, node->port);
+                listAddNodeTail(from, myaddr);
+                sdsfree(link->node_name);
+                sdsfree(link->node_addr);
+                zfree(link);
+            }
+            listRelease(links);
+        }
+    }
+    return status;
+}
+
+/* Add the error string to cluster_manager.errors and print it. */
+static void clusterManagerOnError(sds err) {
+    if (cluster_manager.errors == NULL) cluster_manager.errors = listCreate();
+    listAddNodeTail(cluster_manager.errors, err);
+    clusterManagerLogErr("%s\n", (char *)err);
+}
+
+/* Check the slots coverage of the cluster. The 'all_slots' argument must be
+ * and array of 16384 bytes. Every covered slot will be set to 1 in the
+ * 'all_slots' array. The function returns the total number if covered slots.*/
+static int clusterManagerGetCoveredSlots(char *all_slots) {
+    if (cluster_manager.nodes == NULL) return 0;
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    int totslots = 0, i;
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *node = ln->value;
+        for (i = 0; i < CLUSTER_MANAGER_SLOTS; i++) {
+            if (node->slots[i] && !all_slots[i]) {
+                all_slots[i] = 1;
+                totslots++;
+            }
+        }
+    }
+    return totslots;
+}
+
+static void clusterManagerPrintSlotsList(list *slots) {
+    clusterManagerNode n = {0};
+    listIter li;
+    listNode *ln;
+    listRewind(slots, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        int slot = atoi(ln->value);
+        if (slot >= 0 && slot < CLUSTER_MANAGER_SLOTS) n.slots[slot] = 1;
+    }
+    sds nodeslist = clusterManagerNodeSlotsString(&n);
+    printf("%s\n", nodeslist);
+    sdsfree(nodeslist);
+}
+
+/* Return the node, among 'nodes' with the greatest number of keys
+ * in the specified slot. */
+static clusterManagerNode *clusterManagerGetNodeWithMostKeysInSlot(list *nodes, int slot, char **err) {
+    clusterManagerNode *node = NULL;
+    int numkeys = 0;
+    listIter li;
+    listNode *ln;
+    listRewind(nodes, &li);
+    if (err) *err = NULL;
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA || n->replicate) continue;
+        redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER COUNTKEYSINSLOT %d", slot);
+        int success = clusterManagerCheckRedisReply(n, r, err);
+        if (success) {
+            if (r->integer > numkeys || node == NULL) {
+                numkeys = r->integer;
+                node = n;
+            }
+        }
+        if (r != NULL) freeReplyObject(r);
+        /* If the reply contains errors */
+        if (!success) {
+            if (err != NULL && *err != NULL) CLUSTER_MANAGER_PRINT_REPLY_ERROR(n, err);
+            node = NULL;
+            break;
+        }
+    }
+    return node;
+}
+
+/* This function returns the primary that has the least number of replicas
+ * in the cluster. If there are multiple primaries with the same smaller
+ * number of replicas, one at random is returned. */
+
+static clusterManagerNode *clusterManagerNodeWithLeastReplicas(void) {
+    clusterManagerNode *node = NULL;
+    int lowest_count = 0;
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+        if (node == NULL || n->replicas_count < lowest_count) {
+            node = n;
+            lowest_count = n->replicas_count;
+        }
+    }
+    return node;
+}
+
+/* This function returns a random primary node, return NULL if none */
+
+static clusterManagerNode *clusterManagerNodePrimaryRandom(void) {
+    int primary_count = 0;
+    int idx;
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+        primary_count++;
+    }
+
+    assert(primary_count > 0);
+    srand(time(NULL));
+    idx = rand() % primary_count;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+        if (!idx--) {
+            return n;
+        }
+    }
+    /* Can not be reached */
+    assert(0);
+    /* Make compiler happy */
+    return 0;
+}
+
+static int clusterManagerFixSlotsCoverage(char *all_slots) {
+    int force_fix = config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_FIX_WITH_UNREACHABLE_PRIMARIES;
+
+    if (cluster_manager.unreachable_primaries > 0 && !force_fix) {
+        clusterManagerLogWarn(
+            "*** Fixing slots coverage with %d unreachable primaries is dangerous: valkey-cli will assume that slots "
+            "about primaries that are not reachable are not covered, and will try to reassign them to the reachable "
+            "nodes. This can cause data loss and is rarely what you want to do. If you really want to proceed use the "
+            "--cluster-fix-with-unreachable-primaries option.\n",
+            cluster_manager.unreachable_primaries);
+        exit(1);
+    }
+
+    int i, fixed = 0;
+    list *none = NULL, *single = NULL, *multi = NULL;
+    clusterManagerLogInfo(">>> Fixing slots coverage...\n");
+    for (i = 0; i < CLUSTER_MANAGER_SLOTS; i++) {
+        int covered = all_slots[i];
+        if (!covered) {
+            sds slot = sdsfromlonglong((long long)i);
+            list *slot_nodes = listCreate();
+            sds slot_nodes_str = sdsempty();
+            listIter li;
+            listNode *ln;
+            listRewind(cluster_manager.nodes, &li);
+            while ((ln = listNext(&li)) != NULL) {
+                clusterManagerNode *n = ln->value;
+                if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA || n->replicate) continue;
+                redisReply *reply = CLUSTER_MANAGER_COMMAND(n, "CLUSTER GETKEYSINSLOT %d %d", i, 1);
+                if (!clusterManagerCheckRedisReply(n, reply, NULL)) {
+                    fixed = -1;
+                    if (reply) freeReplyObject(reply);
+                    goto cleanup;
+                }
+                assert(reply->type == REDIS_REPLY_ARRAY);
+                if (reply->elements > 0) {
+                    listAddNodeTail(slot_nodes, n);
+                    if (listLength(slot_nodes) > 1) slot_nodes_str = sdscat(slot_nodes_str, ", ");
+                    slot_nodes_str = sdscatfmt(slot_nodes_str, "%s:%u", n->ip, n->port);
+                }
+                freeReplyObject(reply);
+            }
+            sdsfree(slot_nodes_str);
+            dictAdd(clusterManagerUncoveredSlots, slot, slot_nodes);
+        }
+    }
+
+    /* For every slot, take action depending on the actual condition:
+     * 1) No node has keys for this slot.
+     * 2) A single node has keys for this slot.
+     * 3) Multiple nodes have keys for this slot. */
+    none = listCreate();
+    single = listCreate();
+    multi = listCreate();
+    dictIterator *iter = dictGetIterator(clusterManagerUncoveredSlots);
+    dictEntry *entry;
+    while ((entry = dictNext(iter)) != NULL) {
+        sds slot = (sds)dictGetKey(entry);
+        list *nodes = (list *)dictGetVal(entry);
+        switch (listLength(nodes)) {
+        case 0: listAddNodeTail(none, slot); break;
+        case 1: listAddNodeTail(single, slot); break;
+        default: listAddNodeTail(multi, slot); break;
+        }
+    }
+    dictReleaseIterator(iter);
+
+    /* we want explicit manual confirmation from users for all the fix cases */
+    int ignore_force = 1;
+
+    /*  Handle case "1": keys in no node. */
+    if (listLength(none) > 0) {
+        printf("The following uncovered slots have no keys "
+               "across the cluster:\n");
+        clusterManagerPrintSlotsList(none);
+        if (confirmWithYes("Fix these slots by covering with a random node?", ignore_force)) {
+            listIter li;
+            listNode *ln;
+            listRewind(none, &li);
+            while ((ln = listNext(&li)) != NULL) {
+                sds slot = ln->value;
+                int s = atoi(slot);
+                clusterManagerNode *n = clusterManagerNodePrimaryRandom();
+                clusterManagerLogInfo(">>> Covering slot %s with %s:%d\n", slot, n->ip, n->port);
+                if (!clusterManagerSetSlotOwner(n, s, 0)) {
+                    fixed = -1;
+                    goto cleanup;
+                }
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot
+                 * info into the node struct, in order to keep it synced */
+                n->slots[s] = 1;
+                fixed++;
+            }
+        }
+    }
+
+    /*  Handle case "2": keys only in one node. */
+    if (listLength(single) > 0) {
+        printf("The following uncovered slots have keys in just one node:\n");
+        clusterManagerPrintSlotsList(single);
+        if (confirmWithYes("Fix these slots by covering with those nodes?", ignore_force)) {
+            listIter li;
+            listNode *ln;
+            listRewind(single, &li);
+            while ((ln = listNext(&li)) != NULL) {
+                sds slot = ln->value;
+                int s = atoi(slot);
+                dictEntry *entry = dictFind(clusterManagerUncoveredSlots, slot);
+                assert(entry != NULL);
+                list *nodes = (list *)dictGetVal(entry);
+                listNode *fn = listFirst(nodes);
+                assert(fn != NULL);
+                clusterManagerNode *n = fn->value;
+                clusterManagerLogInfo(">>> Covering slot %s with %s:%d\n", slot, n->ip, n->port);
+                if (!clusterManagerSetSlotOwner(n, s, 0)) {
+                    fixed = -1;
+                    goto cleanup;
+                }
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot
+                 * info into the node struct, in order to keep it synced */
+                n->slots[atoi(slot)] = 1;
+                fixed++;
+            }
+        }
+    }
+
+    /* Handle case "3": keys in multiple nodes. */
+    if (listLength(multi) > 0) {
+        printf("The following uncovered slots have keys in multiple nodes:\n");
+        clusterManagerPrintSlotsList(multi);
+        if (confirmWithYes("Fix these slots by moving keys "
+                           "into a single node?",
+                           ignore_force)) {
+            listIter li;
+            listNode *ln;
+            listRewind(multi, &li);
+            while ((ln = listNext(&li)) != NULL) {
+                sds slot = ln->value;
+                dictEntry *entry = dictFind(clusterManagerUncoveredSlots, slot);
+                assert(entry != NULL);
+                list *nodes = (list *)dictGetVal(entry);
+                int s = atoi(slot);
+                clusterManagerNode *target = clusterManagerGetNodeWithMostKeysInSlot(nodes, s, NULL);
+                if (target == NULL) {
+                    fixed = -1;
+                    goto cleanup;
+                }
+                clusterManagerLogInfo(">>> Covering slot %s moving keys "
+                                      "to %s:%d\n",
+                                      slot, target->ip, target->port);
+                if (!clusterManagerSetSlotOwner(target, s, 1)) {
+                    fixed = -1;
+                    goto cleanup;
+                }
+                /* Since CLUSTER ADDSLOTS succeeded, we also update the slot
+                 * info into the node struct, in order to keep it synced */
+                target->slots[atoi(slot)] = 1;
+                listIter nli;
+                listNode *nln;
+                listRewind(nodes, &nli);
+                while ((nln = listNext(&nli)) != NULL) {
+                    clusterManagerNode *src = nln->value;
+                    if (src == target) continue;
+                    /* Assign the slot to target node in the source node. */
+                    if (!clusterManagerSetSlot(src, target, s, "NODE", NULL)) fixed = -1;
+                    if (fixed < 0) goto cleanup;
+                    /* Set the source node in 'importing' state
+                     * (even if we will actually migrate keys away)
+                     * in order to avoid receiving redirections
+                     * for MIGRATE. */
+                    if (!clusterManagerSetSlot(src, target, s, "IMPORTING", NULL)) fixed = -1;
+                    if (fixed < 0) goto cleanup;
+                    int opts = CLUSTER_MANAGER_OPT_VERBOSE | CLUSTER_MANAGER_OPT_COLD;
+                    if (!clusterManagerMoveSlot(src, target, s, opts, NULL)) {
+                        fixed = -1;
+                        goto cleanup;
+                    }
+                    if (!clusterManagerClearSlotStatus(src, s)) fixed = -1;
+                    if (fixed < 0) goto cleanup;
+                }
+                fixed++;
+            }
+        }
+    }
+cleanup:
+    if (none) listRelease(none);
+    if (single) listRelease(single);
+    if (multi) listRelease(multi);
+    return fixed;
+}
+
+/* Slot 'slot' was found to be in importing or migrating state in one or
+ * more nodes. This function fixes this condition by migrating keys where
+ * it seems more sensible. */
+static int clusterManagerFixOpenSlot(int slot) {
+    int force_fix = config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_FIX_WITH_UNREACHABLE_PRIMARIES;
+
+    if (cluster_manager.unreachable_primaries > 0 && !force_fix) {
+        clusterManagerLogWarn(
+            "*** Fixing open slots with %d unreachable primaries is dangerous: valkey-cli will assume that slots about "
+            "primaries that are not reachable are not covered, and will try to reassign them to the reachable nodes. "
+            "This can cause data loss and is rarely what you want to do. If you really want to proceed use the "
+            "--cluster-fix-with-unreachable-primaries option.\n",
+            cluster_manager.unreachable_primaries);
+        exit(1);
+    }
+
+    clusterManagerLogInfo(">>> Fixing open slot %d\n", slot);
+    /* Try to obtain the current slot owner, according to the current
+     * nodes configuration. */
+    int success = 1;
+    list *owners = listCreate(); /* List of nodes claiming some ownership.
+                                    it could be stating in the configuration
+                                    to have the node ownership, or just
+                                    holding keys for such slot. */
+    list *migrating = listCreate();
+    list *importing = listCreate();
+    sds migrating_str = sdsempty();
+    sds importing_str = sdsempty();
+    clusterManagerNode *owner = NULL; /* The obvious slot owner if any. */
+
+    /* Iterate all the nodes, looking for potential owners of this slot. */
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+        if (n->slots[slot]) {
+            listAddNodeTail(owners, n);
+        } else {
+            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER COUNTKEYSINSLOT %d", slot);
+            success = clusterManagerCheckRedisReply(n, r, NULL);
+            if (success && r->integer > 0) {
+                clusterManagerLogWarn("*** Found keys about slot %d "
+                                      "in non-owner node %s:%d!\n",
+                                      slot, n->ip, n->port);
+                listAddNodeTail(owners, n);
+            }
+            if (r) freeReplyObject(r);
+            if (!success) goto cleanup;
+        }
+    }
+
+    /* If we have only a single potential owner for this slot,
+     * set it as "owner". */
+    if (listLength(owners) == 1) owner = listFirst(owners)->value;
+
+    /* Scan the list of nodes again, in order to populate the
+     * list of nodes in importing or migrating state for
+     * this slot. */
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+        int is_migrating = 0, is_importing = 0;
+        if (n->migrating) {
+            for (int i = 0; i < n->migrating_count; i += 2) {
+                sds migrating_slot = n->migrating[i];
+                if (atoi(migrating_slot) == slot) {
+                    char *sep = (listLength(migrating) == 0 ? "" : ",");
+                    migrating_str = sdscatfmt(migrating_str, "%s%s:%u", sep, n->ip, n->port);
+                    listAddNodeTail(migrating, n);
+                    is_migrating = 1;
+                    break;
+                }
+            }
+        }
+        if (!is_migrating && n->importing) {
+            for (int i = 0; i < n->importing_count; i += 2) {
+                sds importing_slot = n->importing[i];
+                if (atoi(importing_slot) == slot) {
+                    char *sep = (listLength(importing) == 0 ? "" : ",");
+                    importing_str = sdscatfmt(importing_str, "%s%s:%u", sep, n->ip, n->port);
+                    listAddNodeTail(importing, n);
+                    is_importing = 1;
+                    break;
+                }
+            }
+        }
+
+        /* If the node is neither migrating nor importing and it's not
+         * the owner, then is added to the importing list in case
+         * it has keys in the slot. */
+        if (!is_migrating && !is_importing && n != owner) {
+            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER COUNTKEYSINSLOT %d", slot);
+            success = clusterManagerCheckRedisReply(n, r, NULL);
+            if (success && r->integer > 0) {
+                clusterManagerLogWarn("*** Found keys about slot %d "
+                                      "in node %s:%d!\n",
+                                      slot, n->ip, n->port);
+                char *sep = (listLength(importing) == 0 ? "" : ",");
+                importing_str = sdscatfmt(importing_str, "%s%s:%u", sep, n->ip, n->port);
+                listAddNodeTail(importing, n);
+            }
+            if (r) freeReplyObject(r);
+            if (!success) goto cleanup;
+        }
+    }
+    if (sdslen(migrating_str) > 0) printf("Set as migrating in: %s\n", migrating_str);
+    if (sdslen(importing_str) > 0) printf("Set as importing in: %s\n", importing_str);
+
+    /* If there is no slot owner, set as owner the node with the biggest
+     * number of keys, among the set of migrating / importing nodes. */
+    if (owner == NULL) {
+        clusterManagerLogInfo(">>> No single clear owner for the slot, "
+                              "selecting an owner by # of keys...\n");
+        owner = clusterManagerGetNodeWithMostKeysInSlot(cluster_manager.nodes, slot, NULL);
+        // If we still don't have an owner, we can't fix it.
+        if (owner == NULL) {
+            clusterManagerLogErr("[ERR] Can't select a slot owner. "
+                                 "Impossible to fix.\n");
+            success = 0;
+            goto cleanup;
+        }
+
+        // Use ADDSLOTS to assign the slot.
+        clusterManagerLogWarn("*** Configuring %s:%d as the slot owner\n", owner->ip, owner->port);
+        success = clusterManagerClearSlotStatus(owner, slot);
+        if (!success) goto cleanup;
+        success = clusterManagerSetSlotOwner(owner, slot, 0);
+        if (!success) goto cleanup;
+        /* Since CLUSTER ADDSLOTS succeeded, we also update the slot
+         * info into the node struct, in order to keep it synced */
+        owner->slots[slot] = 1;
+        /* Remove the owner from the list of migrating/importing
+         * nodes. */
+        clusterManagerRemoveNodeFromList(migrating, owner);
+        clusterManagerRemoveNodeFromList(importing, owner);
+    }
+
+    /* If there are multiple owners of the slot, we need to fix it
+     * so that a single node is the owner and all the other nodes
+     * are in importing state. Later the fix can be handled by one
+     * of the base cases above.
+     *
+     * Note that this case also covers multiple nodes having the slot
+     * in migrating state, since migrating is a valid state only for
+     * slot owners. */
+    if (listLength(owners) > 1) {
+        /* Owner cannot be NULL at this point, since if there are more owners,
+         * the owner has been set in the previous condition (owner == NULL). */
+        assert(owner != NULL);
+        listRewind(owners, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            if (n == owner) continue;
+            success = clusterManagerDelSlot(n, slot, 1);
+            if (!success) goto cleanup;
+            n->slots[slot] = 0;
+            /* Assign the slot to the owner in the node 'n' configuration.' */
+            success = clusterManagerSetSlot(n, owner, slot, "node", NULL);
+            if (!success) goto cleanup;
+            success = clusterManagerSetSlot(n, owner, slot, "importing", NULL);
+            if (!success) goto cleanup;
+            /* Avoid duplicates. */
+            clusterManagerRemoveNodeFromList(importing, n);
+            listAddNodeTail(importing, n);
+            /* Ensure that the node is not in the migrating list. */
+            clusterManagerRemoveNodeFromList(migrating, n);
+        }
+    }
+    int move_opts = CLUSTER_MANAGER_OPT_VERBOSE;
+
+    /* Case 1: The slot is in migrating state in one node, and in
+     *         importing state in 1 node. That's trivial to address. */
+    if (listLength(migrating) == 1 && listLength(importing) == 1) {
+        clusterManagerNode *src = listFirst(migrating)->value;
+        clusterManagerNode *dst = listFirst(importing)->value;
+        clusterManagerLogInfo(">>> Case 1: Moving slot %d from "
+                              "%s:%d to %s:%d\n",
+                              slot, src->ip, src->port, dst->ip, dst->port);
+        move_opts |= CLUSTER_MANAGER_OPT_UPDATE;
+        success = clusterManagerMoveSlot(src, dst, slot, move_opts, NULL);
+    }
+
+    /* Case 2: There are multiple nodes that claim the slot as importing,
+     * they probably got keys about the slot after a restart so opened
+     * the slot. In this case we just move all the keys to the owner
+     * according to the configuration. */
+    else if (listLength(migrating) == 0 && listLength(importing) > 0) {
+        clusterManagerLogInfo(">>> Case 2: Moving all the %d slot keys to its "
+                              "owner %s:%d\n",
+                              slot, owner->ip, owner->port);
+        move_opts |= CLUSTER_MANAGER_OPT_COLD;
+        listRewind(importing, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            if (n == owner) continue;
+            success = clusterManagerMoveSlot(n, owner, slot, move_opts, NULL);
+            if (!success) goto cleanup;
+            clusterManagerLogInfo(">>> Setting %d as STABLE in "
+                                  "%s:%d\n",
+                                  slot, n->ip, n->port);
+            success = clusterManagerClearSlotStatus(n, slot);
+            if (!success) goto cleanup;
+        }
+        /* Since the slot has been moved in "cold" mode, ensure that all the
+         * other nodes update their own configuration about the slot itself. */
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            if (n == owner) continue;
+            if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+            success = clusterManagerSetSlot(n, owner, slot, "NODE", NULL);
+            if (!success) goto cleanup;
+        }
+    }
+
+    /* Case 3: The slot is in migrating state in one node but multiple
+     * other nodes claim to be in importing state and don't have any key in
+     * the slot. We search for the importing node having the same ID as
+     * the destination node of the migrating node.
+     * In that case we move the slot from the migrating node to this node and
+     * we close the importing states on all the other importing nodes.
+     * If no importing node has the same ID as the destination node of the
+     * migrating node, the slot's state is closed on both the migrating node
+     * and the importing nodes. */
+    else if (listLength(migrating) == 1 && listLength(importing) > 1) {
+        int try_to_fix = 1;
+        clusterManagerNode *src = listFirst(migrating)->value;
+        clusterManagerNode *dst = NULL;
+        sds target_id = NULL;
+        for (int i = 0; i < src->migrating_count; i += 2) {
+            sds migrating_slot = src->migrating[i];
+            if (atoi(migrating_slot) == slot) {
+                target_id = src->migrating[i + 1];
+                break;
+            }
+        }
+        assert(target_id != NULL);
+        listIter li;
+        listNode *ln;
+        listRewind(importing, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            int count = clusterManagerCountKeysInSlot(n, slot);
+            if (count > 0) {
+                try_to_fix = 0;
+                break;
+            }
+            if (strcmp(n->name, target_id) == 0) dst = n;
+        }
+        if (!try_to_fix) goto unhandled_case;
+        if (dst != NULL) {
+            clusterManagerLogInfo(">>> Case 3: Moving slot %d from %s:%d to "
+                                  "%s:%d and closing it on all the other "
+                                  "importing nodes.\n",
+                                  slot, src->ip, src->port, dst->ip, dst->port);
+            /* Move the slot to the destination node. */
+            success = clusterManagerMoveSlot(src, dst, slot, move_opts, NULL);
+            if (!success) goto cleanup;
+            /* Close slot on all the other importing nodes. */
+            listRewind(importing, &li);
+            while ((ln = listNext(&li)) != NULL) {
+                clusterManagerNode *n = ln->value;
+                if (dst == n) continue;
+                success = clusterManagerClearSlotStatus(n, slot);
+                if (!success) goto cleanup;
+            }
+        } else {
+            clusterManagerLogInfo(">>> Case 3: Closing slot %d on both "
+                                  "migrating and importing nodes.\n",
+                                  slot);
+            /* Close the slot on both the migrating node and the importing
+             * nodes. */
+            success = clusterManagerClearSlotStatus(src, slot);
+            if (!success) goto cleanup;
+            listRewind(importing, &li);
+            while ((ln = listNext(&li)) != NULL) {
+                clusterManagerNode *n = ln->value;
+                success = clusterManagerClearSlotStatus(n, slot);
+                if (!success) goto cleanup;
+            }
+        }
+    } else {
+        int try_to_close_slot = (listLength(importing) == 0 && listLength(migrating) == 1);
+        if (try_to_close_slot) {
+            clusterManagerNode *n = listFirst(migrating)->value;
+            if (!owner || owner != n) {
+                redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER GETKEYSINSLOT %d %d", slot, 10);
+                success = clusterManagerCheckRedisReply(n, r, NULL);
+                if (r) {
+                    if (success) try_to_close_slot = (r->elements == 0);
+                    freeReplyObject(r);
+                }
+                if (!success) goto cleanup;
+            }
+        }
+        /* Case 4: There are no slots claiming to be in importing state, but
+         * there is a migrating node that actually don't have any key or is the
+         * slot owner. We can just close the slot, probably a reshard
+         * interrupted in the middle. */
+        if (try_to_close_slot) {
+            clusterManagerNode *n = listFirst(migrating)->value;
+            clusterManagerLogInfo(">>> Case 4: Closing slot %d on %s:%d\n", slot, n->ip, n->port);
+            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER SETSLOT %d %s", slot, "STABLE");
+            success = clusterManagerCheckRedisReply(n, r, NULL);
+            if (r) freeReplyObject(r);
+            if (!success) goto cleanup;
+        } else {
+        unhandled_case:
+            success = 0;
+            clusterManagerLogErr("[ERR] Sorry, valkey-cli can't fix this slot "
+                                 "yet (work in progress). Slot is set as "
+                                 "migrating in %s, as importing in %s, "
+                                 "owner is %s:%d\n",
+                                 migrating_str, importing_str, owner->ip, owner->port);
+        }
+    }
+cleanup:
+    listRelease(owners);
+    listRelease(migrating);
+    listRelease(importing);
+    sdsfree(migrating_str);
+    sdsfree(importing_str);
+    return success;
+}
+
+static int clusterManagerFixMultipleSlotOwners(int slot, list *owners) {
+    clusterManagerLogInfo(">>> Fixing multiple owners for slot %d...\n", slot);
+    int success = 0;
+    assert(listLength(owners) > 1);
+    clusterManagerNode *owner = clusterManagerGetNodeWithMostKeysInSlot(owners, slot, NULL);
+    if (!owner) owner = listFirst(owners)->value;
+    clusterManagerLogInfo(">>> Setting slot %d owner: %s:%d\n", slot, owner->ip, owner->port);
+    /* Set the slot owner. */
+    if (!clusterManagerSetSlotOwner(owner, slot, 0)) return 0;
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    /* Update configuration in all the other primary nodes by assigning the slot
+     * itself to the new owner, and by eventually migrating keys if the node
+     * has keys for the slot. */
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n == owner) continue;
+        if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+        int count = clusterManagerCountKeysInSlot(n, slot);
+        success = (count >= 0);
+        if (!success) break;
+        clusterManagerDelSlot(n, slot, 1);
+        if (!clusterManagerSetSlot(n, owner, slot, "node", NULL)) return 0;
+        if (count > 0) {
+            int opts = CLUSTER_MANAGER_OPT_VERBOSE | CLUSTER_MANAGER_OPT_COLD;
+            success = clusterManagerMoveSlot(n, owner, slot, opts, NULL);
+            if (!success) break;
+        }
+    }
+    return success;
+}
+
+static int clusterManagerCheckCluster(int quiet) {
+    listNode *ln = listFirst(cluster_manager.nodes);
+    if (!ln) return 0;
+    clusterManagerNode *node = ln->value;
+    clusterManagerLogInfo(">>> Performing Cluster Check (using node %s:%d)\n", node->ip, node->port);
+    int result = 1, consistent = 0;
+    int do_fix = config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_FIX;
+    if (!quiet) clusterManagerShowNodes();
+    consistent = clusterManagerIsConfigConsistent();
+    if (!consistent) {
+        sds err = sdsnew("[ERR] Nodes don't agree about configuration!");
+        clusterManagerOnError(err);
+        result = 0;
+    } else {
+        clusterManagerLogOk("[OK] All nodes agree about slots "
+                            "configuration.\n");
+    }
+    /* Check open slots */
+    clusterManagerLogInfo(">>> Check for open slots...\n");
+    listIter li;
+    listRewind(cluster_manager.nodes, &li);
+    int i;
+    dict *open_slots = NULL;
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->migrating != NULL) {
+            if (open_slots == NULL) open_slots = dictCreate(&clusterManagerDictType);
+            sds errstr = sdsempty();
+            errstr = sdscatprintf(errstr,
+                                  "[WARNING] Node %s:%d has slots in "
+                                  "migrating state ",
+                                  n->ip, n->port);
+            for (i = 0; i < n->migrating_count; i += 2) {
+                sds slot = n->migrating[i];
+                dictReplace(open_slots, slot, sdsdup(n->migrating[i + 1]));
+                char *fmt = (i > 0 ? ",%S" : "%S");
+                errstr = sdscatfmt(errstr, fmt, slot);
+            }
+            errstr = sdscat(errstr, ".");
+            clusterManagerOnError(errstr);
+        }
+        if (n->importing != NULL) {
+            if (open_slots == NULL) open_slots = dictCreate(&clusterManagerDictType);
+            sds errstr = sdsempty();
+            errstr = sdscatprintf(errstr,
+                                  "[WARNING] Node %s:%d has slots in "
+                                  "importing state ",
+                                  n->ip, n->port);
+            for (i = 0; i < n->importing_count; i += 2) {
+                sds slot = n->importing[i];
+                dictReplace(open_slots, slot, sdsdup(n->importing[i + 1]));
+                char *fmt = (i > 0 ? ",%S" : "%S");
+                errstr = sdscatfmt(errstr, fmt, slot);
+            }
+            errstr = sdscat(errstr, ".");
+            clusterManagerOnError(errstr);
+        }
+    }
+    if (open_slots != NULL) {
+        result = 0;
+        dictIterator *iter = dictGetIterator(open_slots);
+        dictEntry *entry;
+        sds errstr = sdsnew("[WARNING] The following slots are open: ");
+        i = 0;
+        while ((entry = dictNext(iter)) != NULL) {
+            sds slot = (sds)dictGetKey(entry);
+            char *fmt = (i++ > 0 ? ",%S" : "%S");
+            errstr = sdscatfmt(errstr, fmt, slot);
+        }
+        clusterManagerLogErr("%s.\n", (char *)errstr);
+        sdsfree(errstr);
+        if (do_fix) {
+            /* Fix open slots. */
+            dictReleaseIterator(iter);
+            iter = dictGetIterator(open_slots);
+            while ((entry = dictNext(iter)) != NULL) {
+                sds slot = (sds)dictGetKey(entry);
+                result = clusterManagerFixOpenSlot(atoi(slot));
+                if (!result) break;
+            }
+        }
+        dictReleaseIterator(iter);
+        dictRelease(open_slots);
+    }
+    clusterManagerLogInfo(">>> Check slots coverage...\n");
+    char slots[CLUSTER_MANAGER_SLOTS];
+    memset(slots, 0, CLUSTER_MANAGER_SLOTS);
+    int coverage = clusterManagerGetCoveredSlots(slots);
+    if (coverage == CLUSTER_MANAGER_SLOTS) {
+        clusterManagerLogOk("[OK] All %d slots covered.\n", CLUSTER_MANAGER_SLOTS);
+    } else {
+        sds err = sdsempty();
+        err = sdscatprintf(err,
+                           "[ERR] Not all %d slots are "
+                           "covered by nodes.\n",
+                           CLUSTER_MANAGER_SLOTS);
+        clusterManagerOnError(err);
+        result = 0;
+        if (do_fix /* && result*/) {
+            clusterManagerUncoveredSlots = dictCreate(&clusterManagerLinkDictType);
+            int fixed = clusterManagerFixSlotsCoverage(slots);
+            if (fixed > 0) result = 1;
+        }
+    }
+    int search_multiple_owners = config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_CHECK_OWNERS;
+    if (search_multiple_owners) {
+        /* Check whether there are multiple owners, even when slots are
+         * fully covered and there are no open slots. */
+        clusterManagerLogInfo(">>> Check for multiple slot owners...\n");
+        int slot = 0, slots_with_multiple_owners = 0;
+        for (; slot < CLUSTER_MANAGER_SLOTS; slot++) {
+            listIter li;
+            listNode *ln;
+            listRewind(cluster_manager.nodes, &li);
+            list *owners = listCreate();
+            while ((ln = listNext(&li)) != NULL) {
+                clusterManagerNode *n = ln->value;
+                if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+                if (n->slots[slot])
+                    listAddNodeTail(owners, n);
+                else {
+                    /* Nodes having keys for the slot will be considered
+                     * owners too. */
+                    int count = clusterManagerCountKeysInSlot(n, slot);
+                    if (count > 0) listAddNodeTail(owners, n);
+                }
+            }
+            if (listLength(owners) > 1) {
+                result = 0;
+                clusterManagerLogErr("[WARNING] Slot %d has %d owners:\n", slot, listLength(owners));
+                listRewind(owners, &li);
+                while ((ln = listNext(&li)) != NULL) {
+                    clusterManagerNode *n = ln->value;
+                    clusterManagerLogErr("    %s:%d\n", n->ip, n->port);
+                }
+                slots_with_multiple_owners++;
+                if (do_fix) {
+                    result = clusterManagerFixMultipleSlotOwners(slot, owners);
+                    if (!result) {
+                        clusterManagerLogErr("Failed to fix multiple owners "
+                                             "for slot %d\n",
+                                             slot);
+                        listRelease(owners);
+                        break;
+                    } else
+                        slots_with_multiple_owners--;
+                }
+            }
+            listRelease(owners);
+        }
+        if (slots_with_multiple_owners == 0) clusterManagerLogOk("[OK] No multiple owners found.\n");
+    }
+    return result;
+}
+
+static clusterManagerNode *clusterNodeForResharding(char *id, clusterManagerNode *target, int *raise_err) {
+    clusterManagerNode *node = NULL;
+    const char *invalid_node_msg = "*** The specified node (%s) is not known "
+                                   "or not a primary, please retry.\n";
+    node = clusterManagerNodeByName(id);
+    *raise_err = 0;
+    if (!node || node->flags & CLUSTER_MANAGER_FLAG_REPLICA) {
+        clusterManagerLogErr(invalid_node_msg, id);
+        *raise_err = 1;
+        return NULL;
+    } else if (target != NULL) {
+        if (!strcmp(node->name, target->name)) {
+            clusterManagerLogErr("*** It is not possible to use "
+                                 "the target node as "
+                                 "source node.\n");
+            return NULL;
+        }
+    }
+    return node;
+}
+
+static list *clusterManagerComputeReshardTable(list *sources, int numslots) {
+    list *moved = listCreate();
+    int src_count = listLength(sources), i = 0, tot_slots = 0, j;
+    clusterManagerNode **sorted = zmalloc(src_count * sizeof(*sorted));
+    listIter li;
+    listNode *ln;
+    listRewind(sources, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *node = ln->value;
+        tot_slots += node->slots_count;
+        sorted[i++] = node;
+    }
+    qsort(sorted, src_count, sizeof(clusterManagerNode *), clusterManagerSlotCountCompareDesc);
+    for (i = 0; i < src_count; i++) {
+        clusterManagerNode *node = sorted[i];
+        float n = ((float)numslots / tot_slots * node->slots_count);
+        if (i == 0)
+            n = ceil(n);
+        else
+            n = floor(n);
+        int max = (int)n, count = 0;
+        for (j = 0; j < CLUSTER_MANAGER_SLOTS; j++) {
+            int slot = node->slots[j];
+            if (!slot) continue;
+            if (count >= max || (int)listLength(moved) >= numslots) break;
+            clusterManagerReshardTableItem *item = zmalloc(sizeof(*item));
+            item->source = node;
+            item->slot = j;
+            listAddNodeTail(moved, item);
+            count++;
+        }
+    }
+    zfree(sorted);
+    return moved;
+}
+
+static void clusterManagerShowReshardTable(list *table) {
+    listIter li;
+    listNode *ln;
+    listRewind(table, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerReshardTableItem *item = ln->value;
+        clusterManagerNode *n = item->source;
+        printf("    Moving slot %d from %s\n", item->slot, (char *)n->name);
+    }
+}
+
+static void clusterManagerReleaseReshardTable(list *table) {
+    if (table != NULL) {
+        listIter li;
+        listNode *ln;
+        listRewind(table, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerReshardTableItem *item = ln->value;
+            zfree(item);
+        }
+        listRelease(table);
+    }
+}
+
+static void clusterManagerLog(int level, const char *fmt, ...) {
+    int use_colors = (config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_COLOR);
+    if (use_colors) {
+        printf("\033[");
+        switch (level) {
+        case CLUSTER_MANAGER_LOG_LVL_INFO: printf(LOG_COLOR_BOLD); break;
+        case CLUSTER_MANAGER_LOG_LVL_WARN: printf(LOG_COLOR_YELLOW); break;
+        case CLUSTER_MANAGER_LOG_LVL_ERR: printf(LOG_COLOR_RED); break;
+        case CLUSTER_MANAGER_LOG_LVL_SUCCESS: printf(LOG_COLOR_GREEN); break;
+        default: printf(LOG_COLOR_RESET); break;
+        }
+    }
+    va_list ap;
+    va_start(ap, fmt);
+    vprintf(fmt, ap);
+    va_end(ap);
+    if (use_colors) printf("\033[" LOG_COLOR_RESET);
+}
+
+static void clusterManagerNodeArrayInit(clusterManagerNodeArray *array, int alloc_len) {
+    array->nodes = zcalloc(alloc_len * sizeof(clusterManagerNode *));
+    array->alloc = array->nodes;
+    array->len = alloc_len;
+    array->count = 0;
+}
+
+/* Reset array->nodes to the original array allocation and re-count non-NULL
+ * nodes. */
+static void clusterManagerNodeArrayReset(clusterManagerNodeArray *array) {
+    if (array->nodes > array->alloc) {
+        array->len = array->nodes - array->alloc;
+        array->nodes = array->alloc;
+        array->count = 0;
+        int i = 0;
+        for (; i < array->len; i++) {
+            if (array->nodes[i] != NULL) array->count++;
+        }
+    }
+}
+
+/* Shift array->nodes and store the shifted node into 'nodeptr'. */
+static void clusterManagerNodeArrayShift(clusterManagerNodeArray *array, clusterManagerNode **nodeptr) {
+    assert(array->len > 0);
+    /* If the first node to be shifted is not NULL, decrement count. */
+    if (*array->nodes != NULL) array->count--;
+    /* Store the first node to be shifted into 'nodeptr'. */
+    *nodeptr = *array->nodes;
+    /* Shift the nodes array and decrement length. */
+    array->nodes++;
+    array->len--;
+}
+
+static void clusterManagerNodeArrayAdd(clusterManagerNodeArray *array, clusterManagerNode *node) {
+    assert(array->len > 0);
+    assert(node != NULL);
+    assert(array->count < array->len);
+    array->nodes[array->count++] = node;
+}
+
+static void clusterManagerPrintNotEmptyNodeError(clusterManagerNode *node, char *err) {
+    char *msg;
+    if (err)
+        msg = err;
+    else {
+        msg = "is not empty. Either the node already knows other "
+              "nodes (check with CLUSTER NODES) or contains some "
+              "key in database 0.";
+    }
+    clusterManagerLogErr("[ERR] Node %s:%d %s\n", node->ip, node->port, msg);
+}
+
+static void clusterManagerPrintNotClusterNodeError(clusterManagerNode *node, char *err) {
+    char *msg = (err ? err : "is not configured as a cluster node.");
+    clusterManagerLogErr("[ERR] Node %s:%d %s\n", node->ip, node->port, msg);
+}
+
+/* Execute valkey-cli in Cluster Manager mode */
+static void clusterManagerMode(clusterManagerCommandProc *proc) {
+    int argc = config.cluster_manager_command.argc;
+    char **argv = config.cluster_manager_command.argv;
+    cluster_manager.nodes = NULL;
+    int success = proc(argc, argv);
+
+    /* Initialized in createClusterManagerCommand. */
+    if (config.stdin_lastarg) {
+        zfree(config.cluster_manager_command.argv);
+        sdsfree(config.cluster_manager_command.stdin_arg);
+    } else if (config.stdin_tag_arg) {
+        sdsfree(config.cluster_manager_command.stdin_arg);
+    }
+    freeClusterManager();
+
+    exit(success ? 0 : 1);
+}
+
+/* Cluster Manager Commands */
+
+static int clusterManagerCommandCreate(int argc, char **argv) {
+    int i, j, success = 1;
+    cluster_manager.nodes = listCreate();
+    for (i = 0; i < argc; i++) {
+        char *addr = argv[i];
+        char *ip = NULL;
+        int port = 0;
+        if (!parseClusterNodeAddress(addr, &ip, &port, NULL)) {
+            fprintf(stderr, "Invalid address format: %s\n", addr);
+            return 0;
+        }
+
+        clusterManagerNode *node = clusterManagerNewNode(ip, port, 0);
+        if (!clusterManagerNodeConnect(node)) {
+            freeClusterManagerNode(node);
+            return 0;
+        }
+        char *err = NULL;
+        if (!clusterManagerNodeIsCluster(node, &err)) {
+            clusterManagerPrintNotClusterNodeError(node, err);
+            if (err) zfree(err);
+            freeClusterManagerNode(node);
+            return 0;
+        }
+        err = NULL;
+        if (!clusterManagerNodeLoadInfo(node, 0, &err)) {
+            if (err) {
+                CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, err);
+                zfree(err);
+            }
+            freeClusterManagerNode(node);
+            return 0;
+        }
+        err = NULL;
+        if (!clusterManagerNodeIsEmpty(node, &err)) {
+            clusterManagerPrintNotEmptyNodeError(node, err);
+            if (err) zfree(err);
+            freeClusterManagerNode(node);
+            return 0;
+        }
+        listAddNodeTail(cluster_manager.nodes, node);
+    }
+    int node_len = cluster_manager.nodes->len;
+    int replicas = config.cluster_manager_command.replicas;
+    int primaries_count = CLUSTER_MANAGER_PRIMARIES_COUNT(node_len, replicas);
+    if (primaries_count < 3) {
+        int ignore_force = 0;
+        clusterManagerLogInfo("Requested to create a cluster with %d primaries and "
+                              "%d replicas per primary.\n",
+                              primaries_count, replicas);
+        if (!confirmWithYes("Valkey cluster requires at least 3 primary nodes for "
+                            "automatic failover. Are you sure?",
+                            ignore_force))
+            return 0;
+    }
+    clusterManagerLogInfo(">>> Performing hash slots allocation "
+                          "on %d node(s)...\n",
+                          node_len);
+    int interleaved_len = 0, ip_count = 0;
+    clusterManagerNode **interleaved = zcalloc(node_len * sizeof(**interleaved));
+    char **ips = zcalloc(node_len * sizeof(char *));
+    clusterManagerNodeArray *ip_nodes = zcalloc(node_len * sizeof(*ip_nodes));
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        int found = 0;
+        for (i = 0; i < ip_count; i++) {
+            char *ip = ips[i];
+            if (!strcmp(ip, n->ip)) {
+                found = 1;
+                break;
+            }
+        }
+        if (!found) {
+            ips[ip_count++] = n->ip;
+        }
+        clusterManagerNodeArray *node_array = &(ip_nodes[i]);
+        if (node_array->nodes == NULL) clusterManagerNodeArrayInit(node_array, node_len);
+        clusterManagerNodeArrayAdd(node_array, n);
+    }
+    while (interleaved_len < node_len) {
+        for (i = 0; i < ip_count; i++) {
+            clusterManagerNodeArray *node_array = &(ip_nodes[i]);
+            if (node_array->count > 0) {
+                clusterManagerNode *n = NULL;
+                clusterManagerNodeArrayShift(node_array, &n);
+                interleaved[interleaved_len++] = n;
+            }
+        }
+    }
+    clusterManagerNode **primaries = interleaved;
+    interleaved += primaries_count;
+    interleaved_len -= primaries_count;
+    float slots_per_node = CLUSTER_MANAGER_SLOTS / (float)primaries_count;
+    long first = 0;
+    float cursor = 0.0f;
+    for (i = 0; i < primaries_count; i++) {
+        clusterManagerNode *primary = primaries[i];
+        long last = lround(cursor + slots_per_node - 1);
+        if (last > CLUSTER_MANAGER_SLOTS || i == (primaries_count - 1)) last = CLUSTER_MANAGER_SLOTS - 1;
+        if (last < first) last = first;
+        printf("Primary[%d] -> Slots %ld - %ld\n", i, first, last);
+        primary->slots_count = 0;
+        for (j = first; j <= last; j++) {
+            primary->slots[j] = 1;
+            primary->slots_count++;
+        }
+        primary->dirty = 1;
+        first = last + 1;
+        cursor += slots_per_node;
+    }
+
+    /* Rotating the list sometimes helps to get better initial
+     * anti-affinity before the optimizer runs. */
+    clusterManagerNode *first_node = interleaved[0];
+    for (i = 0; i < (interleaved_len - 1); i++) interleaved[i] = interleaved[i + 1];
+    interleaved[interleaved_len - 1] = first_node;
+    int assign_unused = 0, available_count = interleaved_len;
+assign_replicas:
+    for (i = 0; i < primaries_count; i++) {
+        clusterManagerNode *primary = primaries[i];
+        int assigned_replicas = 0;
+        while (assigned_replicas < replicas) {
+            if (available_count == 0) break;
+            clusterManagerNode *found = NULL, *replica = NULL;
+            int firstNodeIdx = -1;
+            for (j = 0; j < interleaved_len; j++) {
+                clusterManagerNode *n = interleaved[j];
+                if (n == NULL) continue;
+                if (strcmp(n->ip, primary->ip)) {
+                    found = n;
+                    interleaved[j] = NULL;
+                    break;
+                }
+                if (firstNodeIdx < 0) firstNodeIdx = j;
+            }
+            if (found)
+                replica = found;
+            else if (firstNodeIdx >= 0) {
+                replica = interleaved[firstNodeIdx];
+                interleaved_len -= (firstNodeIdx + 1);
+                interleaved += (firstNodeIdx + 1);
+            }
+            if (replica != NULL) {
+                assigned_replicas++;
+                available_count--;
+                if (replica->replicate) sdsfree(replica->replicate);
+                replica->replicate = sdsnew(primary->name);
+                replica->dirty = 1;
+            } else
+                break;
+            printf("Adding replica %s:%d to %s:%d\n", replica->ip, replica->port, primary->ip, primary->port);
+            if (assign_unused) break;
+        }
+    }
+    if (!assign_unused && available_count > 0) {
+        assign_unused = 1;
+        printf("Adding extra replicas...\n");
+        goto assign_replicas;
+    }
+    for (i = 0; i < ip_count; i++) {
+        clusterManagerNodeArray *node_array = ip_nodes + i;
+        clusterManagerNodeArrayReset(node_array);
+    }
+    clusterManagerOptimizeAntiAffinity(ip_nodes, ip_count);
+    clusterManagerShowNodes();
+    int ignore_force = 0;
+    if (confirmWithYes("Can I set the above configuration?", ignore_force)) {
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *node = ln->value;
+            char *err = NULL;
+            int flushed = clusterManagerFlushNodeConfig(node, &err);
+            if (!flushed && node->dirty && !node->replicate) {
+                if (err != NULL) {
+                    CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, err);
+                    zfree(err);
+                }
+                success = 0;
+                goto cleanup;
+            } else if (err != NULL)
+                zfree(err);
+        }
+        clusterManagerLogInfo(">>> Nodes configuration updated\n");
+        clusterManagerLogInfo(">>> Assign a different config epoch to "
+                              "each node\n");
+        int config_epoch = 1;
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *node = ln->value;
+            redisReply *reply = NULL;
+            reply = CLUSTER_MANAGER_COMMAND(node, "cluster set-config-epoch %d", config_epoch++);
+            if (reply != NULL) freeReplyObject(reply);
+        }
+        clusterManagerLogInfo(">>> Sending CLUSTER MEET messages to join "
+                              "the cluster\n");
+        clusterManagerNode *first = NULL;
+        char first_ip[NET_IP_STR_LEN]; /* first->ip may be a hostname */
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *node = ln->value;
+            if (first == NULL) {
+                first = node;
+                /* Although hiredis supports connecting to a hostname, CLUSTER
+                 * MEET requires an IP address, so we do a DNS lookup here. */
+                int anet_flags = ANET_NONE;
+                if (config.prefer_ipv4) anet_flags |= ANET_PREFER_IPV4;
+                if (config.prefer_ipv6) anet_flags |= ANET_PREFER_IPV6;
+                if (anetResolve(NULL, first->ip, first_ip, sizeof(first_ip), anet_flags) == ANET_ERR) {
+                    fprintf(stderr, "Invalid IP address or hostname specified: %s\n", first->ip);
+                    success = 0;
+                    goto cleanup;
+                }
+                continue;
+            }
+            redisReply *reply = NULL;
+            if (first->bus_port == 0 || (first->bus_port == first->port + CLUSTER_MANAGER_PORT_INCR)) {
+                /* CLUSTER MEET bus-port parameter was added in 4.0.
+                 * So if (bus_port == 0) or (bus_port == port + CLUSTER_MANAGER_PORT_INCR),
+                 * we just call CLUSTER MEET with 2 arguments, using the old form. */
+                reply = CLUSTER_MANAGER_COMMAND(node, "cluster meet %s %d", first_ip, first->port);
+            } else {
+                reply = CLUSTER_MANAGER_COMMAND(node, "cluster meet %s %d %d", first_ip, first->port, first->bus_port);
+            }
+            int is_err = 0;
+            if (reply != NULL) {
+                if ((is_err = reply->type == REDIS_REPLY_ERROR)) CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, reply->str);
+                freeReplyObject(reply);
+            } else {
+                is_err = 1;
+                fprintf(stderr, "Failed to send CLUSTER MEET command.\n");
+            }
+            if (is_err) {
+                success = 0;
+                goto cleanup;
+            }
+        }
+        /* Give one second for the join to start, in order to avoid that
+         * waiting for cluster join will find all the nodes agree about
+         * the config as they are still empty with unassigned slots. */
+        sleep(1);
+        clusterManagerWaitForClusterJoin();
+        /* Useful for the replicas */
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *node = ln->value;
+            if (!node->dirty) continue;
+            char *err = NULL;
+            int flushed = clusterManagerFlushNodeConfig(node, &err);
+            if (!flushed && !node->replicate) {
+                if (err != NULL) {
+                    CLUSTER_MANAGER_PRINT_REPLY_ERROR(node, err);
+                    zfree(err);
+                }
+                success = 0;
+                goto cleanup;
+            } else if (err != NULL) {
+                zfree(err);
+            }
+        }
+        // Reset Nodes
+        listRewind(cluster_manager.nodes, &li);
+        clusterManagerNode *first_node = NULL;
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *node = ln->value;
+            if (!first_node)
+                first_node = node;
+            else
+                freeClusterManagerNode(node);
+        }
+        listEmpty(cluster_manager.nodes);
+        if (!clusterManagerLoadInfoFromNode(first_node)) {
+            success = 0;
+            goto cleanup;
+        }
+        clusterManagerCheckCluster(0);
+    }
+cleanup:
+    /* Free everything */
+    zfree(primaries);
+    zfree(ips);
+    for (i = 0; i < node_len; i++) {
+        clusterManagerNodeArray *node_array = ip_nodes + i;
+        CLUSTER_MANAGER_NODE_ARRAY_FREE(node_array);
+    }
+    zfree(ip_nodes);
+    return success;
+}
+
+static int clusterManagerCommandAddNode(int argc, char **argv) {
+    int success = 1;
+    redisReply *reply = NULL;
+    redisReply *function_restore_reply = NULL;
+    redisReply *function_list_reply = NULL;
+    char *ref_ip = NULL, *ip = NULL;
+    int ref_port = 0, port = 0;
+    if (!getClusterHostFromCmdArgs(argc - 1, argv + 1, &ref_ip, &ref_port)) goto invalid_args;
+    if (!getClusterHostFromCmdArgs(1, argv, &ip, &port)) goto invalid_args;
+    clusterManagerLogInfo(">>> Adding node %s:%d to cluster %s:%d\n", ip, port, ref_ip, ref_port);
+    // Check the existing cluster
+    clusterManagerNode *refnode = clusterManagerNewNode(ref_ip, ref_port, 0);
+    if (!clusterManagerLoadInfoFromNode(refnode)) return 0;
+    if (!clusterManagerCheckCluster(0)) return 0;
+
+    /* If --cluster-primary-id was specified, try to resolve it now so that we
+     * abort before starting with the node configuration. */
+    clusterManagerNode *primary_node = NULL;
+    if (config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_REPLICA) {
+        char *primary_id = config.cluster_manager_command.primary_id;
+        if (primary_id != NULL) {
+            primary_node = clusterManagerNodeByName(primary_id);
+            if (primary_node == NULL) {
+                clusterManagerLogErr("[ERR] No such primary ID %s\n", primary_id);
+                return 0;
+            }
+        } else {
+            primary_node = clusterManagerNodeWithLeastReplicas();
+            assert(primary_node != NULL);
+            printf("Automatically selected primary %s:%d\n", primary_node->ip, primary_node->port);
+        }
+    }
+
+    // Add the new node
+    clusterManagerNode *new_node = clusterManagerNewNode(ip, port, 0);
+    int added = 0;
+    if (!clusterManagerNodeConnect(new_node)) {
+        clusterManagerLogErr("[ERR] Sorry, can't connect to node %s:%d\n", ip, port);
+        success = 0;
+        goto cleanup;
+    }
+    char *err = NULL;
+    if (!(success = clusterManagerNodeIsCluster(new_node, &err))) {
+        clusterManagerPrintNotClusterNodeError(new_node, err);
+        if (err) zfree(err);
+        goto cleanup;
+    }
+    if (!clusterManagerNodeLoadInfo(new_node, 0, &err)) {
+        if (err) {
+            CLUSTER_MANAGER_PRINT_REPLY_ERROR(new_node, err);
+            zfree(err);
+        }
+        success = 0;
+        goto cleanup;
+    }
+    if (!(success = clusterManagerNodeIsEmpty(new_node, &err))) {
+        clusterManagerPrintNotEmptyNodeError(new_node, err);
+        if (err) zfree(err);
+        goto cleanup;
+    }
+    clusterManagerNode *first = listFirst(cluster_manager.nodes)->value;
+    listAddNodeTail(cluster_manager.nodes, new_node);
+    added = 1;
+
+    if (!primary_node) {
+        /* Send functions to the new node, if new node is a replica it will get the functions from its primary. */
+        clusterManagerLogInfo(">>> Getting functions from cluster\n");
+        reply = CLUSTER_MANAGER_COMMAND(refnode, "FUNCTION DUMP");
+        if (!clusterManagerCheckRedisReply(refnode, reply, &err)) {
+            clusterManagerLogInfo(">>> Failed retrieving Functions from the cluster, "
+                                  "skip this step as Valkey version do not support function command (error = '%s')\n",
+                                  err ? err : "NULL reply");
+            if (err) zfree(err);
+        } else {
+            assert(reply->type == REDIS_REPLY_STRING);
+            clusterManagerLogInfo(">>> Send FUNCTION LIST to %s:%d to verify there is no functions in it\n", ip, port);
+            function_list_reply = CLUSTER_MANAGER_COMMAND(new_node, "FUNCTION LIST");
+            if (!clusterManagerCheckRedisReply(new_node, function_list_reply, &err)) {
+                clusterManagerLogErr(">>> Failed on CLUSTER LIST (error = '%s')\r\n", err ? err : "NULL reply");
+                if (err) zfree(err);
+                success = 0;
+                goto cleanup;
+            }
+            assert(function_list_reply->type == REDIS_REPLY_ARRAY);
+            if (function_list_reply->elements > 0) {
+                clusterManagerLogErr(">>> New node already contains functions and can not be added to the cluster. Use "
+                                     "FUNCTION FLUSH and try again.\r\n");
+                success = 0;
+                goto cleanup;
+            }
+            clusterManagerLogInfo(">>> Send FUNCTION RESTORE to %s:%d\n", ip, port);
+            function_restore_reply = CLUSTER_MANAGER_COMMAND(new_node, "FUNCTION RESTORE %b", reply->str, reply->len);
+            if (!clusterManagerCheckRedisReply(new_node, function_restore_reply, &err)) {
+                clusterManagerLogErr(">>> Failed loading functions to the new node (error = '%s')\r\n",
+                                     err ? err : "NULL reply");
+                if (err) zfree(err);
+                success = 0;
+                goto cleanup;
+            }
+        }
+    }
+
+    if (reply) freeReplyObject(reply);
+
+    // Send CLUSTER MEET command to the new node
+    clusterManagerLogInfo(">>> Send CLUSTER MEET to node %s:%d to make it "
+                          "join the cluster.\n",
+                          ip, port);
+    /* CLUSTER MEET requires an IP address, so we do a DNS lookup here. */
+    char first_ip[NET_IP_STR_LEN];
+    int anet_flags = ANET_NONE;
+    if (config.prefer_ipv4) anet_flags |= ANET_PREFER_IPV4;
+    if (config.prefer_ipv6) anet_flags |= ANET_PREFER_IPV6;
+    if (anetResolve(NULL, first->ip, first_ip, sizeof(first_ip), anet_flags) == ANET_ERR) {
+        fprintf(stderr, "Invalid IP address or hostname specified: %s\n", first->ip);
+        success = 0;
+        goto cleanup;
+    }
+
+    if (first->bus_port == 0 || (first->bus_port == first->port + CLUSTER_MANAGER_PORT_INCR)) {
+        /* CLUSTER MEET bus-port parameter was added in 4.0.
+         * So if (bus_port == 0) or (bus_port == port + CLUSTER_MANAGER_PORT_INCR),
+         * we just call CLUSTER MEET with 2 arguments, using the old form. */
+        reply = CLUSTER_MANAGER_COMMAND(new_node, "CLUSTER MEET %s %d", first_ip, first->port);
+    } else {
+        reply = CLUSTER_MANAGER_COMMAND(new_node, "CLUSTER MEET %s %d %d", first_ip, first->port, first->bus_port);
+    }
+
+    if (!(success = clusterManagerCheckRedisReply(new_node, reply, NULL))) goto cleanup;
+
+    /* Additional configuration is needed if the node is added as a replica. */
+    if (primary_node) {
+        sleep(1);
+        clusterManagerWaitForClusterJoin();
+        clusterManagerLogInfo(">>> Configure node as replica of %s:%d.\n", primary_node->ip, primary_node->port);
+        freeReplyObject(reply);
+        reply = CLUSTER_MANAGER_COMMAND(new_node, "CLUSTER REPLICATE %s", primary_node->name);
+        if (!(success = clusterManagerCheckRedisReply(new_node, reply, NULL))) goto cleanup;
+    }
+    clusterManagerLogOk("[OK] New node added correctly.\n");
+cleanup:
+    if (!added && new_node) freeClusterManagerNode(new_node);
+    if (reply) freeReplyObject(reply);
+    if (function_restore_reply) freeReplyObject(function_restore_reply);
+    if (function_list_reply) freeReplyObject(function_list_reply);
+    return success;
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandDeleteNode(int argc, char **argv) {
+    UNUSED(argc);
+    int success = 1;
+    int port = 0;
+    char *ip = NULL;
+    if (!getClusterHostFromCmdArgs(1, argv, &ip, &port)) goto invalid_args;
+    char *node_id = argv[1];
+    clusterManagerLogInfo(">>> Removing node %s from cluster %s:%d\n", node_id, ip, port);
+    clusterManagerNode *ref_node = clusterManagerNewNode(ip, port, 0);
+    clusterManagerNode *node = NULL;
+
+    // Load cluster information
+    if (!clusterManagerLoadInfoFromNode(ref_node)) return 0;
+
+    // Check if the node exists and is not empty
+    node = clusterManagerNodeByName(node_id);
+    if (node == NULL) {
+        clusterManagerLogErr("[ERR] No such node ID %s\n", node_id);
+        return 0;
+    }
+    if (node->slots_count != 0) {
+        clusterManagerLogErr("[ERR] Node %s:%d is not empty! Reshard data "
+                             "away and try again.\n",
+                             node->ip, node->port);
+        return 0;
+    }
+
+    // Send CLUSTER FORGET to all the nodes but the node to remove
+    clusterManagerLogInfo(">>> Sending CLUSTER FORGET messages to the "
+                          "cluster...\n");
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n == node) continue;
+        if (n->replicate && !strcasecmp(n->replicate, node_id)) {
+            // Reconfigure the replica to replicate with some other node
+            clusterManagerNode *primary = clusterManagerNodeWithLeastReplicas();
+            assert(primary != NULL);
+            clusterManagerLogInfo(">>> %s:%d as replica of %s:%d\n", n->ip, n->port, primary->ip, primary->port);
+            redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER REPLICATE %s", primary->name);
+            success = clusterManagerCheckRedisReply(n, r, NULL);
+            if (r) freeReplyObject(r);
+            if (!success) return 0;
+        }
+        redisReply *r = CLUSTER_MANAGER_COMMAND(n, "CLUSTER FORGET %s", node_id);
+        success = clusterManagerCheckRedisReply(n, r, NULL);
+        if (r) freeReplyObject(r);
+        if (!success) return 0;
+    }
+
+    /* Finally send CLUSTER RESET to the node. */
+    clusterManagerLogInfo(">>> Sending CLUSTER RESET SOFT to the "
+                          "deleted node.\n");
+    redisReply *r = redisCommand(node->context, "CLUSTER RESET %s", "SOFT");
+    success = clusterManagerCheckRedisReply(node, r, NULL);
+    if (r) freeReplyObject(r);
+    return success;
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandInfo(int argc, char **argv) {
+    int port = 0;
+    char *ip = NULL;
+    if (!getClusterHostFromCmdArgs(argc, argv, &ip, &port)) goto invalid_args;
+    clusterManagerNode *node = clusterManagerNewNode(ip, port, 0);
+    if (!clusterManagerLoadInfoFromNode(node)) return 0;
+    clusterManagerShowClusterInfo();
+    return 1;
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandCheck(int argc, char **argv) {
+    int port = 0;
+    char *ip = NULL;
+    if (!getClusterHostFromCmdArgs(argc, argv, &ip, &port)) goto invalid_args;
+    clusterManagerNode *node = clusterManagerNewNode(ip, port, 0);
+    if (!clusterManagerLoadInfoFromNode(node)) return 0;
+    clusterManagerShowClusterInfo();
+    return clusterManagerCheckCluster(0);
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandFix(int argc, char **argv) {
+    config.cluster_manager_command.flags |= CLUSTER_MANAGER_CMD_FLAG_FIX;
+    return clusterManagerCommandCheck(argc, argv);
+}
+
+static int clusterManagerCommandReshard(int argc, char **argv) {
+    int port = 0;
+    char *ip = NULL;
+    if (!getClusterHostFromCmdArgs(argc, argv, &ip, &port)) goto invalid_args;
+    clusterManagerNode *node = clusterManagerNewNode(ip, port, 0);
+    if (!clusterManagerLoadInfoFromNode(node)) return 0;
+    clusterManagerCheckCluster(0);
+    if (cluster_manager.errors && listLength(cluster_manager.errors) > 0) {
+        fflush(stdout);
+        fprintf(stderr, "*** Please fix your cluster problems before resharding\n");
+        return 0;
+    }
+    int slots = config.cluster_manager_command.slots;
+    if (!slots) {
+        while (slots <= 0 || slots > CLUSTER_MANAGER_SLOTS) {
+            printf("How many slots do you want to move (from 1 to %d)? ", CLUSTER_MANAGER_SLOTS);
+            fflush(stdout);
+            char buf[6];
+            int nread = read(fileno(stdin), buf, 6);
+            if (nread <= 0) continue;
+            int last_idx = nread - 1;
+            if (buf[last_idx] != '\n') {
+                int ch;
+                while ((ch = getchar()) != '\n' && ch != EOF) {
+                }
+            }
+            buf[last_idx] = '\0';
+            slots = atoi(buf);
+        }
+    }
+    char buf[255];
+    char *to = config.cluster_manager_command.to, *from = config.cluster_manager_command.from;
+    while (to == NULL) {
+        printf("What is the receiving node ID? ");
+        fflush(stdout);
+        int nread = read(fileno(stdin), buf, 255);
+        if (nread <= 0) continue;
+        int last_idx = nread - 1;
+        if (buf[last_idx] != '\n') {
+            int ch;
+            while ((ch = getchar()) != '\n' && ch != EOF) {
+            }
+        }
+        buf[last_idx] = '\0';
+        if (strlen(buf) > 0) to = buf;
+    }
+    int raise_err = 0;
+    clusterManagerNode *target = clusterNodeForResharding(to, NULL, &raise_err);
+    if (target == NULL) return 0;
+    list *sources = listCreate();
+    list *table = NULL;
+    int all = 0, result = 1;
+    if (from == NULL) {
+        printf("Please enter all the source node IDs.\n");
+        printf("  Type 'all' to use all the nodes as source nodes for "
+               "the hash slots.\n");
+        printf("  Type 'done' once you entered all the source nodes IDs.\n");
+        while (1) {
+            printf("Source node #%lu: ", listLength(sources) + 1);
+            fflush(stdout);
+            int nread = read(fileno(stdin), buf, 255);
+            if (nread <= 0) continue;
+            int last_idx = nread - 1;
+            if (buf[last_idx] != '\n') {
+                int ch;
+                while ((ch = getchar()) != '\n' && ch != EOF) {
+                }
+            }
+            buf[last_idx] = '\0';
+            if (!strcmp(buf, "done"))
+                break;
+            else if (!strcmp(buf, "all")) {
+                all = 1;
+                break;
+            } else {
+                clusterManagerNode *src = clusterNodeForResharding(buf, target, &raise_err);
+                if (src != NULL)
+                    listAddNodeTail(sources, src);
+                else if (raise_err) {
+                    result = 0;
+                    goto cleanup;
+                }
+            }
+        }
+    } else {
+        char *p;
+        while ((p = strchr(from, ',')) != NULL) {
+            *p = '\0';
+            if (!strcmp(from, "all")) {
+                all = 1;
+                break;
+            } else {
+                clusterManagerNode *src = clusterNodeForResharding(from, target, &raise_err);
+                if (src != NULL)
+                    listAddNodeTail(sources, src);
+                else if (raise_err) {
+                    result = 0;
+                    goto cleanup;
+                }
+            }
+            from = p + 1;
+        }
+        /* Check if there's still another source to process. */
+        if (!all && strlen(from) > 0) {
+            if (!strcmp(from, "all")) all = 1;
+            if (!all) {
+                clusterManagerNode *src = clusterNodeForResharding(from, target, &raise_err);
+                if (src != NULL)
+                    listAddNodeTail(sources, src);
+                else if (raise_err) {
+                    result = 0;
+                    goto cleanup;
+                }
+            }
+        }
+    }
+    listIter li;
+    listNode *ln;
+    if (all) {
+        listEmpty(sources);
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA || n->replicate) continue;
+            if (!sdscmp(n->name, target->name)) continue;
+            listAddNodeTail(sources, n);
+        }
+    }
+    if (listLength(sources) == 0) {
+        fprintf(stderr, "*** No source nodes given, operation aborted.\n");
+        result = 0;
+        goto cleanup;
+    }
+    printf("\nReady to move %d slots.\n", slots);
+    printf("  Source nodes:\n");
+    listRewind(sources, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *src = ln->value;
+        sds info = clusterManagerNodeInfo(src, 4);
+        printf("%s\n", info);
+        sdsfree(info);
+    }
+    printf("  Destination node:\n");
+    sds info = clusterManagerNodeInfo(target, 4);
+    printf("%s\n", info);
+    sdsfree(info);
+    table = clusterManagerComputeReshardTable(sources, slots);
+    printf("  Resharding plan:\n");
+    clusterManagerShowReshardTable(table);
+    if (!(config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_YES)) {
+        printf("Do you want to proceed with the proposed "
+               "reshard plan (yes/no)? ");
+        fflush(stdout);
+        char buf[4];
+        int nread = read(fileno(stdin), buf, 4);
+        buf[3] = '\0';
+        if (nread <= 0 || strcmp("yes", buf) != 0) {
+            result = 0;
+            goto cleanup;
+        }
+    }
+    int opts = CLUSTER_MANAGER_OPT_VERBOSE;
+    listRewind(table, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerReshardTableItem *item = ln->value;
+        char *err = NULL;
+        result = clusterManagerMoveSlot(item->source, target, item->slot, opts, &err);
+        if (!result) {
+            if (err != NULL) {
+                clusterManagerLogErr("clusterManagerMoveSlot failed: %s\n", err);
+                zfree(err);
+            }
+            goto cleanup;
+        }
+    }
+cleanup:
+    listRelease(sources);
+    clusterManagerReleaseReshardTable(table);
+    return result;
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandRebalance(int argc, char **argv) {
+    int port = 0;
+    char *ip = NULL;
+    clusterManagerNode **weightedNodes = NULL;
+    list *involved = NULL;
+    if (!getClusterHostFromCmdArgs(argc, argv, &ip, &port)) goto invalid_args;
+    clusterManagerNode *node = clusterManagerNewNode(ip, port, 0);
+    if (!clusterManagerLoadInfoFromNode(node)) return 0;
+    int result = 1, i;
+    if (config.cluster_manager_command.weight != NULL) {
+        for (i = 0; i < config.cluster_manager_command.weight_argc; i++) {
+            char *name = config.cluster_manager_command.weight[i];
+            char *p = strchr(name, '=');
+            if (p == NULL) {
+                clusterManagerLogErr("*** invalid input %s\n", name);
+                result = 0;
+                goto cleanup;
+            }
+            *p = '\0';
+            float w = atof(++p);
+            clusterManagerNode *n = clusterManagerNodeByAbbreviatedName(name);
+            if (n == NULL) {
+                clusterManagerLogErr("*** No such primary node %s\n", name);
+                result = 0;
+                goto cleanup;
+            }
+            n->weight = w;
+        }
+    }
+    float total_weight = 0;
+    int nodes_involved = 0;
+    int use_empty = config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_EMPTY_PRIMARY;
+    involved = listCreate();
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    /* Compute the total cluster weight. */
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA || n->replicate) continue;
+        if (!use_empty && n->slots_count == 0) {
+            n->weight = 0;
+            continue;
+        }
+        total_weight += n->weight;
+        nodes_involved++;
+        listAddNodeTail(involved, n);
+    }
+    weightedNodes = zmalloc(nodes_involved * sizeof(clusterManagerNode *));
+    if (weightedNodes == NULL) goto cleanup;
+    /* Check cluster, only proceed if it looks sane. */
+    clusterManagerCheckCluster(1);
+    if (cluster_manager.errors && listLength(cluster_manager.errors) > 0) {
+        clusterManagerLogErr("*** Please fix your cluster problems "
+                             "before rebalancing\n");
+        result = 0;
+        goto cleanup;
+    }
+    /* Calculate the slots balance for each node. It's the number of
+     * slots the node should lose (if positive) or gain (if negative)
+     * in order to be balanced. */
+    int threshold_reached = 0, total_balance = 0;
+    float threshold = config.cluster_manager_command.threshold;
+    i = 0;
+    listRewind(involved, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        weightedNodes[i++] = n;
+        int expected = (int)(((float)CLUSTER_MANAGER_SLOTS / total_weight) * n->weight);
+        n->balance = n->slots_count - expected;
+        total_balance += n->balance;
+        /* Compute the percentage of difference between the
+         * expected number of slots and the real one, to see
+         * if it's over the threshold specified by the user. */
+        int over_threshold = 0;
+        if (threshold > 0) {
+            if (n->slots_count > 0) {
+                float err_perc = fabs((100 - (100.0 * expected / n->slots_count)));
+                if (err_perc > threshold) over_threshold = 1;
+            } else if (expected > 1) {
+                over_threshold = 1;
+            }
+        }
+        if (over_threshold) threshold_reached = 1;
+    }
+    if (!threshold_reached) {
+        clusterManagerLogWarn("*** No rebalancing needed! "
+                              "All nodes are within the %.2f%% threshold.\n",
+                              config.cluster_manager_command.threshold);
+        goto cleanup;
+    }
+    /* Because of rounding, it is possible that the balance of all nodes
+     * summed does not give 0. Make sure that nodes that have to provide
+     * slots are always matched by nodes receiving slots. */
+    while (total_balance > 0) {
+        listRewind(involved, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            if (n->balance <= 0 && total_balance > 0) {
+                n->balance--;
+                total_balance--;
+            }
+        }
+    }
+    /* Sort nodes by their slots balance. */
+    qsort(weightedNodes, nodes_involved, sizeof(clusterManagerNode *), clusterManagerCompareNodeBalance);
+    clusterManagerLogInfo(">>> Rebalancing across %d nodes. "
+                          "Total weight = %.2f\n",
+                          nodes_involved, total_weight);
+    if (config.verbose) {
+        for (i = 0; i < nodes_involved; i++) {
+            clusterManagerNode *n = weightedNodes[i];
+            printf("%s:%d balance is %d slots\n", n->ip, n->port, n->balance);
+        }
+    }
+    /* Now we have at the start of the 'sn' array nodes that should get
+     * slots, at the end nodes that must give slots.
+     * We take two indexes, one at the start, and one at the end,
+     * incrementing or decrementing the indexes accordingly til we
+     * find nodes that need to get/provide slots. */
+    int dst_idx = 0;
+    int src_idx = nodes_involved - 1;
+    int simulate = config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_SIMULATE;
+    while (dst_idx < src_idx) {
+        clusterManagerNode *dst = weightedNodes[dst_idx];
+        clusterManagerNode *src = weightedNodes[src_idx];
+        int db = abs(dst->balance);
+        int sb = abs(src->balance);
+        int numslots = (db < sb ? db : sb);
+        if (numslots > 0) {
+            printf("Moving %d slots from %s:%d to %s:%d\n", numslots, src->ip, src->port, dst->ip, dst->port);
+            /* Actually move the slots. */
+            list *lsrc = listCreate(), *table = NULL;
+            listAddNodeTail(lsrc, src);
+            table = clusterManagerComputeReshardTable(lsrc, numslots);
+            listRelease(lsrc);
+            int table_len = (int)listLength(table);
+            if (!table || table_len != numslots) {
+                clusterManagerLogErr("*** Assertion failed: Reshard table "
+                                     "!= number of slots");
+                result = 0;
+                goto end_move;
+            }
+            if (simulate) {
+                for (i = 0; i < table_len; i++) printf("#");
+            } else {
+                int opts = CLUSTER_MANAGER_OPT_QUIET | CLUSTER_MANAGER_OPT_UPDATE;
+                listRewind(table, &li);
+                while ((ln = listNext(&li)) != NULL) {
+                    clusterManagerReshardTableItem *item = ln->value;
+                    char *err;
+                    result = clusterManagerMoveSlot(item->source, dst, item->slot, opts, &err);
+                    if (!result) {
+                        clusterManagerLogErr("*** clusterManagerMoveSlot: %s\n", err);
+                        zfree(err);
+                        goto end_move;
+                    }
+                    printf("#");
+                    fflush(stdout);
+                }
+            }
+            printf("\n");
+        end_move:
+            clusterManagerReleaseReshardTable(table);
+            if (!result) goto cleanup;
+        }
+        /* Update nodes balance. */
+        dst->balance += numslots;
+        src->balance -= numslots;
+        if (dst->balance == 0) dst_idx++;
+        if (src->balance == 0) src_idx--;
+    }
+cleanup:
+    if (involved != NULL) listRelease(involved);
+    if (weightedNodes != NULL) zfree(weightedNodes);
+    return result;
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandSetTimeout(int argc, char **argv) {
+    UNUSED(argc);
+    int port = 0;
+    char *ip = NULL;
+    if (!getClusterHostFromCmdArgs(1, argv, &ip, &port)) goto invalid_args;
+    int timeout = atoi(argv[1]);
+    if (timeout < 100) {
+        fprintf(stderr, "Setting a node timeout of less than 100 "
+                        "milliseconds is a bad idea.\n");
+        return 0;
+    }
+    // Load cluster information
+    clusterManagerNode *node = clusterManagerNewNode(ip, port, 0);
+    if (!clusterManagerLoadInfoFromNode(node)) return 0;
+    int ok_count = 0, err_count = 0;
+
+    clusterManagerLogInfo(">>> Reconfiguring node timeout in every "
+                          "cluster node...\n");
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        char *err = NULL;
+        redisReply *reply = CLUSTER_MANAGER_COMMAND(n, "CONFIG %s %s %d", "SET", "cluster-node-timeout", timeout);
+        if (reply == NULL) goto reply_err;
+        int ok = clusterManagerCheckRedisReply(n, reply, &err);
+        freeReplyObject(reply);
+        if (!ok) goto reply_err;
+        reply = CLUSTER_MANAGER_COMMAND(n, "CONFIG %s", "REWRITE");
+        if (reply == NULL) goto reply_err;
+        ok = clusterManagerCheckRedisReply(n, reply, &err);
+        freeReplyObject(reply);
+        if (!ok) goto reply_err;
+        clusterManagerLogWarn("*** New timeout set for %s:%d\n", n->ip, n->port);
+        ok_count++;
+        continue;
+    reply_err:;
+        int need_free = 0;
+        if (err == NULL)
+            err = "";
+        else
+            need_free = 1;
+        clusterManagerLogErr("ERR setting node-timeout for %s:%d: %s\n", n->ip, n->port, err);
+        if (need_free) zfree(err);
+        err_count++;
+    }
+    clusterManagerLogInfo(">>> New node timeout set. %d OK, %d ERR.\n", ok_count, err_count);
+    return 1;
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandImport(int argc, char **argv) {
+    int success = 1;
+    int port = 0, src_port = 0;
+    char *ip = NULL, *src_ip = NULL;
+    char *invalid_args_msg = NULL;
+    sds cmdfmt = NULL;
+    if (!getClusterHostFromCmdArgs(argc, argv, &ip, &port)) {
+        invalid_args_msg = CLUSTER_MANAGER_INVALID_HOST_ARG;
+        goto invalid_args;
+    }
+    if (config.cluster_manager_command.from == NULL) {
+        invalid_args_msg = "[ERR] Option '--cluster-from' is required for "
+                           "subcommand 'import'.\n";
+        goto invalid_args;
+    }
+    char *src_host[] = {config.cluster_manager_command.from};
+    if (!getClusterHostFromCmdArgs(1, src_host, &src_ip, &src_port)) {
+        invalid_args_msg = "[ERR] Invalid --cluster-from host. You need to "
+                           "pass a valid address (ie. 120.0.0.1:7000).\n";
+        goto invalid_args;
+    }
+    clusterManagerLogInfo(">>> Importing data from %s:%d to cluster %s:%d\n", src_ip, src_port, ip, port);
+
+    clusterManagerNode *refnode = clusterManagerNewNode(ip, port, 0);
+    if (!clusterManagerLoadInfoFromNode(refnode)) return 0;
+    if (!clusterManagerCheckCluster(0)) return 0;
+    char *reply_err = NULL;
+    redisReply *src_reply = NULL;
+    // Connect to the source node.
+    redisContext *src_ctx = redisConnectWrapper(src_ip, src_port, config.connect_timeout);
+    if (src_ctx->err) {
+        success = 0;
+        fprintf(stderr, "Could not connect to Valkey at %s:%d: %s.\n", src_ip, src_port, src_ctx->errstr);
+        goto cleanup;
+    }
+    // Auth for the source node.
+    char *from_user = config.cluster_manager_command.from_user;
+    char *from_pass = config.cluster_manager_command.from_pass;
+    if (cliAuth(src_ctx, from_user, from_pass) == REDIS_ERR) {
+        success = 0;
+        goto cleanup;
+    }
+
+    src_reply = reconnectingRedisCommand(src_ctx, "INFO");
+    if (!src_reply || src_reply->type == REDIS_REPLY_ERROR) {
+        if (src_reply && src_reply->str) reply_err = src_reply->str;
+        success = 0;
+        goto cleanup;
+    }
+    if (getLongInfoField(src_reply->str, "cluster_enabled")) {
+        clusterManagerLogErr("[ERR] The source node should not be a "
+                             "cluster node.\n");
+        success = 0;
+        goto cleanup;
+    }
+    freeReplyObject(src_reply);
+    src_reply = reconnectingRedisCommand(src_ctx, "DBSIZE");
+    if (!src_reply || src_reply->type == REDIS_REPLY_ERROR) {
+        if (src_reply && src_reply->str) reply_err = src_reply->str;
+        success = 0;
+        goto cleanup;
+    }
+    int size = src_reply->integer, i;
+    clusterManagerLogWarn("*** Importing %d keys from DB 0\n", size);
+
+    // Build a slot -> node map
+    clusterManagerNode *slots_map[CLUSTER_MANAGER_SLOTS];
+    memset(slots_map, 0, sizeof(slots_map));
+    listIter li;
+    listNode *ln;
+    for (i = 0; i < CLUSTER_MANAGER_SLOTS; i++) {
+        listRewind(cluster_manager.nodes, &li);
+        while ((ln = listNext(&li)) != NULL) {
+            clusterManagerNode *n = ln->value;
+            if (n->flags & CLUSTER_MANAGER_FLAG_REPLICA) continue;
+            if (n->slots_count == 0) continue;
+            if (n->slots[i]) {
+                slots_map[i] = n;
+                break;
+            }
+        }
+    }
+    cmdfmt = sdsnew("MIGRATE %s %d %s %d %d");
+    if (config.conn_info.auth) {
+        if (config.conn_info.user) {
+            cmdfmt = sdscatfmt(cmdfmt, " AUTH2 %s %s", config.conn_info.user, config.conn_info.auth);
+        } else {
+            cmdfmt = sdscatfmt(cmdfmt, " AUTH %s", config.conn_info.auth);
+        }
+    }
+
+    if (config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_COPY) cmdfmt = sdscat(cmdfmt, " COPY");
+    if (config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_REPLACE) cmdfmt = sdscat(cmdfmt, " REPLACE");
+
+    /* Use SCAN to iterate over the keys, migrating to the
+     * right node as needed. */
+    int cursor = -999, timeout = config.cluster_manager_command.timeout;
+    while (cursor != 0) {
+        if (cursor < 0) cursor = 0;
+        freeReplyObject(src_reply);
+        src_reply = reconnectingRedisCommand(src_ctx, "SCAN %d COUNT %d", cursor, 1000);
+        if (!src_reply || src_reply->type == REDIS_REPLY_ERROR) {
+            if (src_reply && src_reply->str) reply_err = src_reply->str;
+            success = 0;
+            goto cleanup;
+        }
+        assert(src_reply->type == REDIS_REPLY_ARRAY);
+        assert(src_reply->elements >= 2);
+        assert(src_reply->element[1]->type == REDIS_REPLY_ARRAY);
+        if (src_reply->element[0]->type == REDIS_REPLY_STRING)
+            cursor = atoi(src_reply->element[0]->str);
+        else if (src_reply->element[0]->type == REDIS_REPLY_INTEGER)
+            cursor = src_reply->element[0]->integer;
+        int keycount = src_reply->element[1]->elements;
+        for (i = 0; i < keycount; i++) {
+            redisReply *kr = src_reply->element[1]->element[i];
+            assert(kr->type == REDIS_REPLY_STRING);
+            char *key = kr->str;
+            uint16_t slot = clusterManagerKeyHashSlot(key, kr->len);
+            clusterManagerNode *target = slots_map[slot];
+            printf("Migrating %s to %s:%d: ", key, target->ip, target->port);
+            redisReply *r = reconnectingRedisCommand(src_ctx, cmdfmt, target->ip, target->port, key, 0, timeout);
+            if (!r || r->type == REDIS_REPLY_ERROR) {
+                if (r && r->str) {
+                    clusterManagerLogErr("Source %s:%d replied with "
+                                         "error:\n%s\n",
+                                         src_ip, src_port, r->str);
+                }
+                success = 0;
+            }
+            freeReplyObject(r);
+            if (!success) goto cleanup;
+            clusterManagerLogOk("OK\n");
+        }
+    }
+cleanup:
+    if (reply_err) clusterManagerLogErr("Source %s:%d replied with error:\n%s\n", src_ip, src_port, reply_err);
+    if (src_ctx) redisFree(src_ctx);
+    if (src_reply) freeReplyObject(src_reply);
+    if (cmdfmt) sdsfree(cmdfmt);
+    return success;
+invalid_args:
+    fprintf(stderr, "%s", invalid_args_msg);
+    return 0;
+}
+
+static int clusterManagerCommandCall(int argc, char **argv) {
+    int port = 0, i;
+    char *ip = NULL;
+    if (!getClusterHostFromCmdArgs(1, argv, &ip, &port)) goto invalid_args;
+    clusterManagerNode *refnode = clusterManagerNewNode(ip, port, 0);
+    if (!clusterManagerLoadInfoFromNode(refnode)) return 0;
+    argc--;
+    argv++;
+    size_t *argvlen = zmalloc(argc * sizeof(size_t));
+    clusterManagerLogInfo(">>> Calling");
+    for (i = 0; i < argc; i++) {
+        argvlen[i] = strlen(argv[i]);
+        printf(" %s", argv[i]);
+    }
+    printf("\n");
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        clusterManagerNode *n = ln->value;
+        if ((config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_PRIMARIES_ONLY) && (n->replicate != NULL))
+            continue; // continue if node is replica
+        if ((config.cluster_manager_command.flags & CLUSTER_MANAGER_CMD_FLAG_REPLICAS_ONLY) && (n->replicate == NULL))
+            continue; // continue if node is primary
+        if (!n->context && !clusterManagerNodeConnect(n)) continue;
+        redisReply *reply = NULL;
+        redisAppendCommandArgv(n->context, argc, (const char **)argv, argvlen);
+        int status = redisGetReply(n->context, (void **)(&reply));
+        if (status != REDIS_OK || reply == NULL)
+            printf("%s:%d: Failed!\n", n->ip, n->port);
+        else {
+            sds formatted_reply = cliFormatReplyRaw(reply);
+            printf("%s:%d: %s\n", n->ip, n->port, (char *)formatted_reply);
+            sdsfree(formatted_reply);
+        }
+        if (reply != NULL) freeReplyObject(reply);
+    }
+    zfree(argvlen);
+    return 1;
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandBackup(int argc, char **argv) {
+    UNUSED(argc);
+    int success = 1, port = 0;
+    char *ip = NULL;
+    if (!getClusterHostFromCmdArgs(1, argv, &ip, &port)) goto invalid_args;
+    clusterManagerNode *refnode = clusterManagerNewNode(ip, port, 0);
+    if (!clusterManagerLoadInfoFromNode(refnode)) return 0;
+    int no_issues = clusterManagerCheckCluster(0);
+    int cluster_errors_count = (no_issues ? 0 : listLength(cluster_manager.errors));
+    config.cluster_manager_command.backup_dir = argv[1];
+    /* TODO: check if backup_dir is a valid directory. */
+    sds json = sdsnew("[\n");
+    int first_node = 0;
+    listIter li;
+    listNode *ln;
+    listRewind(cluster_manager.nodes, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        if (!first_node)
+            first_node = 1;
+        else
+            json = sdscat(json, ",\n");
+        clusterManagerNode *node = ln->value;
+        sds node_json = clusterManagerNodeGetJSON(node, cluster_errors_count);
+        json = sdscat(json, node_json);
+        sdsfree(node_json);
+        if (node->replicate) continue;
+        clusterManagerLogInfo(">>> Node %s:%d -> Saving RDB...\n", node->ip, node->port);
+        fflush(stdout);
+        getRDB(node);
+    }
+    json = sdscat(json, "\n]");
+    sds jsonpath = sdsnew(config.cluster_manager_command.backup_dir);
+    if (jsonpath[sdslen(jsonpath) - 1] != '/') jsonpath = sdscat(jsonpath, "/");
+    jsonpath = sdscat(jsonpath, "nodes.json");
+    fflush(stdout);
+    clusterManagerLogInfo("Saving cluster configuration to: %s\n", jsonpath);
+    FILE *out = fopen(jsonpath, "w+");
+    if (!out) {
+        clusterManagerLogErr("Could not save nodes to: %s\n", jsonpath);
+        success = 0;
+        goto cleanup;
+    }
+    fputs(json, out);
+    fclose(out);
+cleanup:
+    sdsfree(json);
+    sdsfree(jsonpath);
+    if (success) {
+        if (!no_issues) {
+            clusterManagerLogWarn("*** Cluster seems to have some problems, "
+                                  "please be aware of it if you're going "
+                                  "to restore this backup.\n");
+        }
+        clusterManagerLogOk("[OK] Backup created into: %s\n", config.cluster_manager_command.backup_dir);
+    } else
+        clusterManagerLogOk("[ERR] Failed to back cluster!\n");
+    return success;
+invalid_args:
+    fprintf(stderr, CLUSTER_MANAGER_INVALID_HOST_ARG);
+    return 0;
+}
+
+static int clusterManagerCommandHelp(int argc, char **argv) {
+    UNUSED(argc);
+    UNUSED(argv);
+    int commands_count = sizeof(clusterManagerCommands) / sizeof(clusterManagerCommandDef);
+    int i = 0, j;
+    fprintf(stdout, "Cluster Manager Commands:\n");
+    int padding = 15;
+    for (; i < commands_count; i++) {
+        clusterManagerCommandDef *def = &(clusterManagerCommands[i]);
+        int namelen = strlen(def->name), padlen = padding - namelen;
+        fprintf(stdout, "  %s", def->name);
+        for (j = 0; j < padlen; j++) fprintf(stdout, " ");
+        fprintf(stdout, "%s\n", (def->args ? def->args : ""));
+        if (def->options != NULL) {
+            int optslen = strlen(def->options);
+            char *p = def->options, *eos = p + optslen;
+            char *comma = NULL;
+            while ((comma = strchr(p, ',')) != NULL) {
+                int deflen = (int)(comma - p);
+                char buf[255];
+                memcpy(buf, p, deflen);
+                buf[deflen] = '\0';
+                for (j = 0; j < padding; j++) fprintf(stdout, " ");
+                fprintf(stdout, "  --cluster-%s\n", buf);
+                p = comma + 1;
+                if (p >= eos) break;
+            }
+            if (p < eos) {
+                for (j = 0; j < padding; j++) fprintf(stdout, " ");
+                fprintf(stdout, "  --cluster-%s\n", p);
+            }
+        }
+    }
+    fprintf(stdout, "\nFor check, fix, reshard, del-node, set-timeout, "
+                    "info, rebalance, call, import, backup you "
+                    "can specify the host and port of any working node in "
+                    "the cluster.\n");
+
+    int options_count = sizeof(clusterManagerOptions) / sizeof(clusterManagerOptionDef);
+    i = 0;
+    fprintf(stdout, "\nCluster Manager Options:\n");
+    for (; i < options_count; i++) {
+        clusterManagerOptionDef *def = &(clusterManagerOptions[i]);
+        int namelen = strlen(def->name), padlen = padding - namelen;
+        fprintf(stdout, "  %s", def->name);
+        for (j = 0; j < padlen; j++) fprintf(stdout, " ");
+        fprintf(stdout, "%s\n", def->desc);
+    }
+
+    fprintf(stdout, "\n");
+    return 0;
+}
+
+/*------------------------------------------------------------------------------
+ * Latency and latency history modes
+ *--------------------------------------------------------------------------- */
+
+static void latencyModePrint(long long min, long long max, double avg, long long count) {
+    if (config.output == OUTPUT_STANDARD) {
+        printf("min: %lld, max: %lld, avg: %.2f (%lld samples)", min, max, avg, count);
+        fflush(stdout);
+    } else if (config.output == OUTPUT_CSV) {
+        printf("%lld,%lld,%.2f,%lld\n", min, max, avg, count);
+    } else if (config.output == OUTPUT_RAW) {
+        printf("%lld %lld %.2f %lld\n", min, max, avg, count);
+    } else if (config.output == OUTPUT_JSON) {
+        printf("{\"min\": %lld, \"max\": %lld, \"avg\": %.2f, \"count\": %lld}\n", min, max, avg, count);
+    }
+}
+
+#define LATENCY_SAMPLE_RATE 10                 /* milliseconds. */
+#define LATENCY_HISTORY_DEFAULT_INTERVAL 15000 /* milliseconds. */
+static void latencyMode(void) {
+    redisReply *reply;
+    long long start, latency, min = 0, max = 0, tot = 0, count = 0;
+    long long history_interval = config.interval ? config.interval / 1000 : LATENCY_HISTORY_DEFAULT_INTERVAL;
+    double avg;
+    long long history_start = mstime();
+
+    /* Set a default for the interval in case of --latency option
+     * with --raw, --csv or when it is redirected to non tty. */
+    if (config.interval == 0) {
+        config.interval = 1000;
+    } else {
+        config.interval /= 1000; /* We need to convert to milliseconds. */
+    }
+
+    if (!context) exit(1);
+    while (1) {
+        start = mstime();
+        reply = reconnectingRedisCommand(context, "PING");
+        if (reply == NULL) {
+            fprintf(stderr, "\nI/O error\n");
+            exit(1);
+        }
+        latency = mstime() - start;
+        freeReplyObject(reply);
+        count++;
+        if (count == 1) {
+            min = max = tot = latency;
+            avg = (double)latency;
+        } else {
+            if (latency < min) min = latency;
+            if (latency > max) max = latency;
+            tot += latency;
+            avg = (double)tot / count;
+        }
+
+        if (config.output == OUTPUT_STANDARD) {
+            printf("\x1b[0G\x1b[2K"); /* Clear the line. */
+            latencyModePrint(min, max, avg, count);
+        } else {
+            if (config.latency_history) {
+                latencyModePrint(min, max, avg, count);
+            } else if (mstime() - history_start > config.interval) {
+                latencyModePrint(min, max, avg, count);
+                exit(0);
+            }
+        }
+
+        if (config.latency_history && mstime() - history_start > history_interval) {
+            printf(" -- %.2f seconds range\n", (float)(mstime() - history_start) / 1000);
+            history_start = mstime();
+            min = max = tot = count = 0;
+        }
+        usleep(LATENCY_SAMPLE_RATE * 1000);
+    }
+}
+
+/*------------------------------------------------------------------------------
+ * Latency distribution mode -- requires 256 colors xterm
+ *--------------------------------------------------------------------------- */
+
+#define LATENCY_DIST_DEFAULT_INTERVAL 1000 /* milliseconds. */
+
+/* Structure to store samples distribution. */
+struct distsamples {
+    long long max;   /* Max latency to fit into this interval (usec). */
+    long long count; /* Number of samples in this interval. */
+    int character;   /* Associated character in visualization. */
+};
+
+/* Helper function for latencyDistMode(). Performs the spectrum visualization
+ * of the collected samples targeting an xterm 256 terminal.
+ *
+ * Takes an array of distsamples structures, ordered from smaller to bigger
+ * 'max' value. Last sample max must be 0, to mean that it holds all the
+ * samples greater than the previous one, and is also the stop sentinel.
+ *
+ * "tot' is the total number of samples in the different buckets, so it
+ * is the SUM(samples[i].count) for i to 0 up to the max sample.
+ *
+ * As a side effect the function sets all the buckets count to 0. */
+void showLatencyDistSamples(struct distsamples *samples, long long tot) {
+    int j;
+
+    /* We convert samples into an index inside the palette
+     * proportional to the percentage a given bucket represents.
+     * This way intensity of the different parts of the spectrum
+     * don't change relative to the number of requests, which avoids to
+     * pollute the visualization with non-latency related info. */
+    printf("\033[38;5;0m"); /* Set foreground color to black. */
+    for (j = 0;; j++) {
+        int coloridx = ceil((double)samples[j].count / tot * (spectrum_palette_size - 1));
+        int color = spectrum_palette[coloridx];
+        printf("\033[48;5;%dm%c", (int)color, samples[j].character);
+        samples[j].count = 0;
+        if (samples[j].max == 0) break; /* Last sample. */
+    }
+    printf("\033[0m\n");
+    fflush(stdout);
+}
+
+/* Show the legend: different buckets values and colors meaning, so
+ * that the spectrum is more easily readable. */
+void showLatencyDistLegend(void) {
+    int j;
+
+    printf("---------------------------------------------\n");
+    printf(". - * #          .01 .125 .25 .5 milliseconds\n");
+    printf("1,2,3,...,9      from 1 to 9     milliseconds\n");
+    printf("A,B,C,D,E        10,20,30,40,50  milliseconds\n");
+    printf("F,G,H,I,J        .1,.2,.3,.4,.5       seconds\n");
+    printf("K,L,M,N,O,P,Q,?  1,2,4,8,16,30,60,>60 seconds\n");
+    printf("From 0 to 100%%: ");
+    for (j = 0; j < spectrum_palette_size; j++) {
+        printf("\033[48;5;%dm ", spectrum_palette[j]);
+    }
+    printf("\033[0m\n");
+    printf("---------------------------------------------\n");
+}
+
+static void latencyDistMode(void) {
+    redisReply *reply;
+    long long start, latency, count = 0;
+    long long history_interval = config.interval ? config.interval / 1000 : LATENCY_DIST_DEFAULT_INTERVAL;
+    long long history_start = ustime();
+    int j, outputs = 0;
+
+    struct distsamples samples[] = {
+        /* We use a mostly logarithmic scale, with certain linear intervals
+         * which are more interesting than others, like 1-10 milliseconds
+         * range. */
+        {10, 0, '.'},       /* 0.01 ms */
+        {125, 0, '-'},      /* 0.125 ms */
+        {250, 0, '*'},      /* 0.25 ms */
+        {500, 0, '#'},      /* 0.5 ms */
+        {1000, 0, '1'},     /* 1 ms */
+        {2000, 0, '2'},     /* 2 ms */
+        {3000, 0, '3'},     /* 3 ms */
+        {4000, 0, '4'},     /* 4 ms */
+        {5000, 0, '5'},     /* 5 ms */
+        {6000, 0, '6'},     /* 6 ms */
+        {7000, 0, '7'},     /* 7 ms */
+        {8000, 0, '8'},     /* 8 ms */
+        {9000, 0, '9'},     /* 9 ms */
+        {10000, 0, 'A'},    /* 10 ms */
+        {20000, 0, 'B'},    /* 20 ms */
+        {30000, 0, 'C'},    /* 30 ms */
+        {40000, 0, 'D'},    /* 40 ms */
+        {50000, 0, 'E'},    /* 50 ms */
+        {100000, 0, 'F'},   /* 0.1 s */
+        {200000, 0, 'G'},   /* 0.2 s */
+        {300000, 0, 'H'},   /* 0.3 s */
+        {400000, 0, 'I'},   /* 0.4 s */
+        {500000, 0, 'J'},   /* 0.5 s */
+        {1000000, 0, 'K'},  /* 1 s */
+        {2000000, 0, 'L'},  /* 2 s */
+        {4000000, 0, 'M'},  /* 4 s */
+        {8000000, 0, 'N'},  /* 8 s */
+        {16000000, 0, 'O'}, /* 16 s */
+        {30000000, 0, 'P'}, /* 30 s */
+        {60000000, 0, 'Q'}, /* 1 minute */
+        {0, 0, '?'},        /* > 1 minute */
+    };
+
+    if (!context) exit(1);
+    while (1) {
+        start = ustime();
+        reply = reconnectingRedisCommand(context, "PING");
+        if (reply == NULL) {
+            fprintf(stderr, "\nI/O error\n");
+            exit(1);
+        }
+        latency = ustime() - start;
+        freeReplyObject(reply);
+        count++;
+
+        /* Populate the relevant bucket. */
+        for (j = 0;; j++) {
+            if (samples[j].max == 0 || latency <= samples[j].max) {
+                samples[j].count++;
+                break;
+            }
+        }
+
+        /* From time to time show the spectrum. */
+        if (count && (ustime() - history_start) / 1000 > history_interval) {
+            if ((outputs++ % 20) == 0) showLatencyDistLegend();
+            showLatencyDistSamples(samples, count);
+            history_start = ustime();
+            count = 0;
+        }
+        usleep(LATENCY_SAMPLE_RATE * 1000);
+    }
+}
+
+/*------------------------------------------------------------------------------
+ * Replica mode
+ *--------------------------------------------------------------------------- */
+
+#define RDB_EOF_MARK_SIZE 40
+
+int sendReplconf(const char *arg1, const char *arg2) {
+    int res = 1;
+    fprintf(stderr, "sending REPLCONF %s %s\n", arg1, arg2);
+    redisReply *reply = redisCommand(context, "REPLCONF %s %s", arg1, arg2);
+
+    /* Handle any error conditions */
+    if (reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        exit(1);
+    } else if (reply->type == REDIS_REPLY_ERROR) {
+        /* non fatal, old versions may not support it */
+        fprintf(stderr, "REPLCONF %s error: %s\n", arg1, reply->str);
+        res = 0;
+    }
+    freeReplyObject(reply);
+    return res;
+}
+
+void sendCapa(void) {
+    sendReplconf("capa", "eof");
+}
+
+void sendRdbOnly(void) {
+    sendReplconf("rdb-only", "1");
+}
+
+/* Read raw bytes through a redisContext. The read operation is not greedy
+ * and may not fill the buffer entirely.
+ */
+static ssize_t readConn(redisContext *c, char *buf, size_t len) {
+    return c->funcs->read(c, buf, len);
+}
+
+/* Sends SYNC and reads the number of bytes in the payload. Used both by
+ * replicaMode() and getRDB().
+ *
+ * send_sync if 1 means we will explicitly send SYNC command. If 0 means
+ * we will not send SYNC command, will send the command that in c->obuf.
+ *
+ * Returns the size of the RDB payload to read, or 0 in case an EOF marker is used and the size
+ * is unknown, also returns 0 in case a PSYNC +CONTINUE was found (no RDB payload).
+ *
+ * The out_full_mode parameter if 1 means this is a full sync, if 0 means this is partial mode. */
+unsigned long long sendSync(redisContext *c, int send_sync, char *out_eof, int *out_full_mode) {
+    /* To start we need to send the SYNC command and return the payload.
+     * The hiredis client lib does not understand this part of the protocol
+     * and we don't want to mess with its buffers, so everything is performed
+     * using direct low-level I/O. */
+    char buf[4096], *p;
+    ssize_t nread;
+
+    if (out_full_mode) *out_full_mode = 1;
+
+    if (send_sync) {
+        /* Send the SYNC command. */
+        if (cliWriteConn(c, "SYNC\r\n", 6) != 6) {
+            fprintf(stderr, "Error writing to primary\n");
+            exit(1);
+        }
+    } else {
+        /* We have written the command into c->obuf before. */
+        if (cliWriteConn(c, "", 0) != 0) {
+            fprintf(stderr, "Error writing to primary\n");
+            exit(1);
+        }
+    }
+
+    /* Read $<payload>\r\n, making sure to read just up to "\n" */
+    p = buf;
+    while (1) {
+        nread = readConn(c, p, 1);
+        if (nread <= 0) {
+            fprintf(stderr, "Error reading bulk length while SYNCing\n");
+            exit(1);
+        }
+        if (*p == '\n' && p != buf) break;
+        if (*p != '\n') p++;
+        if (p >= buf + sizeof(buf) - 1) break; /* Go back one more char for null-term. */
+    }
+    *p = '\0';
+    if (buf[0] == '-') {
+        fprintf(stderr, "SYNC with primary failed: %s\n", buf);
+        exit(1);
+    }
+
+    /* Handling PSYNC responses.
+     * Read +FULLRESYNC <replid> <offset>\r\n, after that is the $<payload> or the $EOF:<40 bytes delimiter>
+     * Read +CONTINUE <replid>\r\n or +CONTINUE\r\n, after that is the command stream */
+    if (!strncmp(buf, "+FULLRESYNC", 11) || !strncmp(buf, "+CONTINUE", 9)) {
+        int sync_partial = !strncmp(buf, "+CONTINUE", 9);
+        fprintf(stderr, "PSYNC replied %s\n", buf);
+        p = buf;
+        while (1) {
+            nread = readConn(c, p, 1);
+            if (nread <= 0) {
+                fprintf(stderr, "Error reading bulk length while PSYNCing\n");
+                exit(1);
+            }
+            if (*p == '\n' && p != buf) break;
+            if (*p != '\n') p++;
+            if (p >= buf + sizeof(buf) - 1) break; /* Go back one more char for null-term. */
+        }
+        *p = '\0';
+
+        if (sync_partial) {
+            if (out_full_mode) *out_full_mode = 0;
+            return 0;
+        }
+    }
+
+    if (strncmp(buf + 1, "EOF:", 4) == 0 && strlen(buf + 5) >= RDB_EOF_MARK_SIZE) {
+        memcpy(out_eof, buf + 5, RDB_EOF_MARK_SIZE);
+        return 0;
+    }
+    return strtoull(buf + 1, NULL, 10);
+}
+
+static void replicaMode(int send_sync) {
+    static char eofmark[RDB_EOF_MARK_SIZE];
+    static char lastbytes[RDB_EOF_MARK_SIZE];
+    static int usemark = 0;
+    static int out_full_mode;
+    unsigned long long payload = sendSync(context, send_sync, eofmark, &out_full_mode);
+    char buf[1024];
+    int original_output = config.output;
+    char *info = out_full_mode ? "Full resync" : "Partial resync";
+
+    if (out_full_mode == 1 && payload == 0) {
+        /* SYNC with EOF marker or PSYNC +FULLRESYNC with EOF marker. */
+        payload = ULLONG_MAX;
+        memset(lastbytes, 0, RDB_EOF_MARK_SIZE);
+        usemark = 1;
+        fprintf(stderr,
+                "%s with primary, discarding "
+                "bytes of bulk transfer until EOF marker...\n",
+                info);
+    } else if (out_full_mode == 1 && payload != 0) {
+        /* SYNC without EOF marker or PSYNC +FULLRESYNC. */
+        fprintf(stderr,
+                "%s with primary, discarding %llu "
+                "bytes of bulk transfer...\n",
+                info, payload);
+    } else if (out_full_mode == 0 && payload == 0) {
+        /* PSYNC +CONTINUE (no RDB payload). */
+        fprintf(stderr, "%s with primary...\n", info);
+    }
+
+    /* Discard the payload. */
+    while (payload) {
+        ssize_t nread;
+
+        nread = readConn(context, buf, (payload > sizeof(buf)) ? sizeof(buf) : payload);
+        if (nread <= 0) {
+            fprintf(stderr, "Error reading RDB payload while %sing\n", info);
+            exit(1);
+        }
+        payload -= nread;
+
+        if (usemark) {
+            /* Update the last bytes array, and check if it matches our delimiter.*/
+            if (nread >= RDB_EOF_MARK_SIZE) {
+                memcpy(lastbytes, buf + nread - RDB_EOF_MARK_SIZE, RDB_EOF_MARK_SIZE);
+            } else {
+                int rem = RDB_EOF_MARK_SIZE - nread;
+                memmove(lastbytes, lastbytes + nread, rem);
+                memcpy(lastbytes + rem, buf, nread);
+            }
+            if (memcmp(lastbytes, eofmark, RDB_EOF_MARK_SIZE) == 0) break;
+        }
+    }
+
+    if (usemark) {
+        unsigned long long offset = ULLONG_MAX - payload;
+        fprintf(stderr, "%s done after %llu bytes. Logging commands from primary.\n", info, offset);
+        /* put the replica online */
+        sleep(1);
+        sendReplconf("ACK", "0");
+    } else
+        fprintf(stderr, "%s done. Logging commands from primary.\n", info);
+
+    /* Now we can use hiredis to read the incoming protocol. */
+    config.output = OUTPUT_CSV;
+    while (cliReadReply(0) == REDIS_OK);
+    config.output = original_output;
+}
+
+/*------------------------------------------------------------------------------
+ * RDB transfer mode
+ *--------------------------------------------------------------------------- */
+
+/* This function implements --rdb, so it uses the replication protocol in order
+ * to fetch the RDB file from a remote server. */
+static void getRDB(clusterManagerNode *node) {
+    int fd;
+    redisContext *s;
+    char *filename;
+    if (node != NULL) {
+        assert(node->context);
+        s = node->context;
+        filename = clusterManagerGetNodeRDBFilename(node);
+    } else {
+        s = context;
+        filename = config.rdb_filename;
+    }
+    static char eofmark[RDB_EOF_MARK_SIZE];
+    static char lastbytes[RDB_EOF_MARK_SIZE];
+    static int usemark = 0;
+    unsigned long long payload = sendSync(s, 1, eofmark, NULL);
+    char buf[4096];
+
+    if (payload == 0) {
+        payload = ULLONG_MAX;
+        memset(lastbytes, 0, RDB_EOF_MARK_SIZE);
+        usemark = 1;
+        fprintf(stderr,
+                "SYNC sent to primary, writing bytes of bulk transfer "
+                "until EOF marker to '%s'\n",
+                filename);
+    } else {
+        fprintf(stderr, "SYNC sent to primary, writing %llu bytes to '%s'\n", payload, filename);
+    }
+
+    int write_to_stdout = !strcmp(filename, "-");
+    /* Write to file. */
+    if (write_to_stdout) {
+        fd = STDOUT_FILENO;
+    } else {
+        fd = open(filename, O_CREAT | O_WRONLY, 0644);
+        if (fd == -1) {
+            fprintf(stderr, "Error opening '%s': %s\n", filename, strerror(errno));
+            exit(1);
+        }
+    }
+
+    while (payload) {
+        ssize_t nread, nwritten;
+
+        nread = readConn(s, buf, (payload > sizeof(buf)) ? sizeof(buf) : payload);
+        if (nread <= 0) {
+            fprintf(stderr, "I/O Error reading RDB payload from socket\n");
+            exit(1);
+        }
+        nwritten = write(fd, buf, nread);
+        if (nwritten != nread) {
+            fprintf(stderr, "Error writing data to file: %s\n", (nwritten == -1) ? strerror(errno) : "short write");
+            exit(1);
+        }
+        payload -= nread;
+
+        if (usemark) {
+            /* Update the last bytes array, and check if it matches our delimiter.*/
+            if (nread >= RDB_EOF_MARK_SIZE) {
+                memcpy(lastbytes, buf + nread - RDB_EOF_MARK_SIZE, RDB_EOF_MARK_SIZE);
+            } else {
+                int rem = RDB_EOF_MARK_SIZE - nread;
+                memmove(lastbytes, lastbytes + nread, rem);
+                memcpy(lastbytes + rem, buf, nread);
+            }
+            if (memcmp(lastbytes, eofmark, RDB_EOF_MARK_SIZE) == 0) break;
+        }
+    }
+    if (usemark) {
+        payload = ULLONG_MAX - payload - RDB_EOF_MARK_SIZE;
+        if (!write_to_stdout && ftruncate(fd, payload) == -1)
+            fprintf(stderr, "ftruncate failed: %s.\n", strerror(errno));
+        fprintf(stderr, "Transfer finished with success after %llu bytes\n", payload);
+    } else {
+        fprintf(stderr, "Transfer finished with success.\n");
+    }
+    redisFree(s); /* Close the connection ASAP as fsync() may take time. */
+    if (node) node->context = NULL;
+    if (!write_to_stdout && fsync(fd) == -1) {
+        fprintf(stderr, "Fail to fsync '%s': %s\n", filename, strerror(errno));
+        exit(1);
+    }
+    close(fd);
+    if (node) {
+        sdsfree(filename);
+        return;
+    }
+    exit(0);
+}
+
+/*------------------------------------------------------------------------------
+ * Bulk import (pipe) mode
+ *--------------------------------------------------------------------------- */
+
+#define PIPEMODE_WRITE_LOOP_MAX_BYTES (128 * 1024)
+static void pipeMode(void) {
+    long long errors = 0, replies = 0, obuf_len = 0, obuf_pos = 0;
+    char obuf[1024 * 16]; /* Output buffer */
+    char aneterr[ANET_ERR_LEN];
+    redisReply *reply;
+    int eof = 0; /* True once we consumed all the standard input. */
+    int done = 0;
+    char magic[20]; /* Special reply we recognize. */
+    time_t last_read_time = time(NULL);
+
+    srand(time(NULL));
+
+    /* Use non blocking I/O. */
+    if (anetNonBlock(aneterr, context->fd) == ANET_ERR) {
+        fprintf(stderr, "Can't set the socket in non blocking mode: %s\n", aneterr);
+        exit(1);
+    }
+
+    context->flags &= ~REDIS_BLOCK;
+
+    /* Transfer raw protocol and read replies from the server at the same
+     * time. */
+    while (!done) {
+        int mask = AE_READABLE;
+
+        if (!eof || obuf_len != 0) mask |= AE_WRITABLE;
+        mask = aeWait(context->fd, mask, 1000);
+
+        /* Handle the readable state: we can read replies from the server. */
+        if (mask & AE_READABLE) {
+            int read_error = 0;
+
+            do {
+                if (!read_error && redisBufferRead(context) == REDIS_ERR) {
+                    read_error = 1;
+                }
+
+                reply = NULL;
+                if (redisGetReply(context, (void **)&reply) == REDIS_ERR) {
+                    fprintf(stderr, "Error reading replies from server\n");
+                    exit(1);
+                }
+                if (reply) {
+                    last_read_time = time(NULL);
+                    if (reply->type == REDIS_REPLY_ERROR) {
+                        fprintf(stderr, "%s\n", reply->str);
+                        errors++;
+                    } else if (eof && reply->type == REDIS_REPLY_STRING && reply->len == 20) {
+                        /* Check if this is the reply to our final ECHO
+                         * command. If so everything was received
+                         * from the server. */
+                        if (memcmp(reply->str, magic, 20) == 0) {
+                            printf("Last reply received from server.\n");
+                            done = 1;
+                            replies--;
+                        }
+                    }
+                    replies++;
+                    freeReplyObject(reply);
+                }
+            } while (reply);
+
+            /* Abort on read errors. We abort here because it is important
+             * to consume replies even after a read error: this way we can
+             * show a potential problem to the user. */
+            if (read_error) exit(1);
+        }
+
+        /* Handle the writable state: we can send protocol to the server. */
+        if (mask & AE_WRITABLE) {
+            ssize_t loop_nwritten = 0;
+
+            while (1) {
+                /* Transfer current buffer to server. */
+                if (obuf_len != 0) {
+                    ssize_t nwritten = cliWriteConn(context, obuf + obuf_pos, obuf_len);
+
+                    if (nwritten == -1) {
+                        if (errno != EAGAIN && errno != EINTR) {
+                            fprintf(stderr, "Error writing to the server: %s\n", strerror(errno));
+                            exit(1);
+                        } else {
+                            nwritten = 0;
+                        }
+                    }
+                    obuf_len -= nwritten;
+                    obuf_pos += nwritten;
+                    loop_nwritten += nwritten;
+                    if (obuf_len != 0) break; /* Can't accept more data. */
+                }
+                if (context->err) {
+                    fprintf(stderr, "Server I/O Error: %s\n", context->errstr);
+                    exit(1);
+                }
+                /* If buffer is empty, load from stdin. */
+                if (obuf_len == 0 && !eof) {
+                    ssize_t nread = read(STDIN_FILENO, obuf, sizeof(obuf));
+
+                    if (nread == 0) {
+                        /* The ECHO sequence starts with a "\r\n" so that if there
+                         * is garbage in the protocol we read from stdin, the ECHO
+                         * will likely still be properly formatted.
+                         * CRLF is ignored by the server, so it has no effects. */
+                        char echo[] = "\r\n*2\r\n$4\r\nECHO\r\n$20\r\n01234567890123456789\r\n";
+                        int j;
+
+                        eof = 1;
+                        /* Everything transferred, so we queue a special
+                         * ECHO command that we can match in the replies
+                         * to make sure everything was read from the server. */
+                        for (j = 0; j < 20; j++) magic[j] = rand() & 0xff;
+                        memcpy(echo + 21, magic, 20);
+                        memcpy(obuf, echo, sizeof(echo) - 1);
+                        obuf_len = sizeof(echo) - 1;
+                        obuf_pos = 0;
+                        printf("All data transferred. Waiting for the last reply...\n");
+                    } else if (nread == -1) {
+                        fprintf(stderr, "Error reading from stdin: %s\n", strerror(errno));
+                        exit(1);
+                    } else {
+                        obuf_len = nread;
+                        obuf_pos = 0;
+                    }
+                }
+                if ((obuf_len == 0 && eof) || loop_nwritten > PIPEMODE_WRITE_LOOP_MAX_BYTES) break;
+            }
+        }
+
+        /* Handle timeout, that is, we reached EOF, and we are not getting
+         * replies from the server for a few seconds, nor the final ECHO is
+         * received. */
+        if (eof && config.pipe_timeout > 0 && time(NULL) - last_read_time > config.pipe_timeout) {
+            fprintf(stderr, "No replies for %d seconds: exiting.\n", config.pipe_timeout);
+            errors++;
+            break;
+        }
+    }
+    printf("errors: %lld, replies: %lld\n", errors, replies);
+    if (errors)
+        exit(1);
+    else
+        exit(0);
+}
+
+/*------------------------------------------------------------------------------
+ * Find big keys
+ *--------------------------------------------------------------------------- */
+
+static redisReply *sendScan(unsigned long long *it) {
+    redisReply *reply;
+
+    if (config.pattern)
+        reply = redisCommand(context, "SCAN %llu MATCH %b COUNT %d", *it, config.pattern, sdslen(config.pattern),
+                             config.count);
+    else
+        reply = redisCommand(context, "SCAN %llu COUNT %d", *it, config.count);
+
+    /* Handle any error conditions */
+    if (reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        exit(1);
+    } else if (reply->type == REDIS_REPLY_ERROR) {
+        fprintf(stderr, "SCAN error: %s\n", reply->str);
+        exit(1);
+    } else if (reply->type != REDIS_REPLY_ARRAY) {
+        fprintf(stderr, "Non ARRAY response from SCAN!\n");
+        exit(1);
+    } else if (reply->elements != 2) {
+        fprintf(stderr, "Invalid element count from SCAN!\n");
+        exit(1);
+    }
+
+    /* Validate our types are correct */
+    assert(reply->element[0]->type == REDIS_REPLY_STRING);
+    assert(reply->element[1]->type == REDIS_REPLY_ARRAY);
+
+    /* Update iterator */
+    *it = strtoull(reply->element[0]->str, NULL, 10);
+
+    return reply;
+}
+
+static int getDbSize(void) {
+    redisReply *reply;
+    int size;
+
+    reply = redisCommand(context, "DBSIZE");
+
+    if (reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        exit(1);
+    } else if (reply->type == REDIS_REPLY_ERROR) {
+        fprintf(stderr, "Couldn't determine DBSIZE: %s\n", reply->str);
+        exit(1);
+    } else if (reply->type != REDIS_REPLY_INTEGER) {
+        fprintf(stderr, "Non INTEGER response from DBSIZE!\n");
+        exit(1);
+    }
+
+    /* Grab the number of keys and free our reply */
+    size = reply->integer;
+    freeReplyObject(reply);
+
+    return size;
+}
+
+static int getDatabases(void) {
+    redisReply *reply;
+    int dbnum;
+
+    reply = redisCommand(context, "CONFIG GET databases");
+
+    if (reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        exit(1);
+    } else if (reply->type == REDIS_REPLY_ERROR) {
+        dbnum = 16;
+        fprintf(stderr, "CONFIG GET databases fails: %s, use default value 16 instead\n", reply->str);
+    } else {
+        assert(reply->type == (config.current_resp3 ? REDIS_REPLY_MAP : REDIS_REPLY_ARRAY));
+        assert(reply->elements == 2);
+        dbnum = atoi(reply->element[1]->str);
+    }
+
+    freeReplyObject(reply);
+    return dbnum;
+}
+
+typedef struct {
+    char *name;
+    char *sizecmd;
+    char *sizeunit;
+    unsigned long long biggest;
+    unsigned long long count;
+    unsigned long long totalsize;
+    sds biggest_key;
+} typeinfo;
+
+typeinfo type_string = {"string", "STRLEN", "bytes"};
+typeinfo type_list = {"list", "LLEN", "items"};
+typeinfo type_set = {"set", "SCARD", "members"};
+typeinfo type_hash = {"hash", "HLEN", "fields"};
+typeinfo type_zset = {"zset", "ZCARD", "members"};
+typeinfo type_stream = {"stream", "XLEN", "entries"};
+typeinfo type_other = {"other", NULL, "?"};
+
+static typeinfo *typeinfo_add(dict *types, char *name, typeinfo *type_template) {
+    typeinfo *info = zmalloc(sizeof(typeinfo));
+    *info = *type_template;
+    info->name = sdsnew(name);
+    dictAdd(types, info->name, info);
+    return info;
+}
+
+void type_free(void *val) {
+    typeinfo *info = val;
+    if (info->biggest_key) sdsfree(info->biggest_key);
+    sdsfree(info->name);
+    zfree(info);
+}
+
+static dictType typeinfoDictType = {
+    dictSdsHash,       /* hash function */
+    NULL,              /* key dup */
+    dictSdsKeyCompare, /* key compare */
+    NULL,              /* key destructor (owned by the value)*/
+    type_free,         /* val destructor */
+    NULL               /* allow to expand */
+};
+
+static void getKeyTypes(dict *types_dict, redisReply *keys, typeinfo **types) {
+    redisReply *reply;
+    unsigned int i;
+
+    /* Pipeline TYPE commands */
+    for (i = 0; i < keys->elements; i++) {
+        const char *argv[] = {"TYPE", keys->element[i]->str};
+        size_t lens[] = {4, keys->element[i]->len};
+        redisAppendCommandArgv(context, 2, argv, lens);
+    }
+
+    /* Retrieve types */
+    for (i = 0; i < keys->elements; i++) {
+        if (redisGetReply(context, (void **)&reply) != REDIS_OK) {
+            fprintf(stderr, "Error getting type for key '%s' (%d: %s)\n", keys->element[i]->str, context->err,
+                    context->errstr);
+            exit(1);
+        } else if (reply->type != REDIS_REPLY_STATUS) {
+            if (reply->type == REDIS_REPLY_ERROR) {
+                fprintf(stderr, "TYPE returned an error: %s\n", reply->str);
+            } else {
+                fprintf(stderr, "Invalid reply type (%d) for TYPE on key '%s'!\n", reply->type, keys->element[i]->str);
+            }
+            exit(1);
+        }
+
+        sds typereply = sdsnew(reply->str);
+        dictEntry *de = dictFind(types_dict, typereply);
+        sdsfree(typereply);
+        typeinfo *type = NULL;
+        if (de)
+            type = dictGetVal(de);
+        else if (strcmp(reply->str, "none")) /* create new types for modules, (but not for deleted keys) */
+            type = typeinfo_add(types_dict, reply->str, &type_other);
+        types[i] = type;
+        freeReplyObject(reply);
+    }
+}
+
+static void
+getKeySizes(redisReply *keys, typeinfo **types, unsigned long long *sizes, int memkeys, unsigned memkeys_samples) {
+    redisReply *reply;
+    unsigned int i;
+
+    /* Pipeline size commands */
+    for (i = 0; i < keys->elements; i++) {
+        /* Skip keys that disappeared between SCAN and TYPE (or unknown types when not in memkeys mode) */
+        if (!types[i] || (!types[i]->sizecmd && !memkeys)) continue;
+
+        if (!memkeys) {
+            const char *argv[] = {types[i]->sizecmd, keys->element[i]->str};
+            size_t lens[] = {strlen(types[i]->sizecmd), keys->element[i]->len};
+            redisAppendCommandArgv(context, 2, argv, lens);
+        } else if (memkeys_samples == 0) {
+            const char *argv[] = {"MEMORY", "USAGE", keys->element[i]->str};
+            size_t lens[] = {6, 5, keys->element[i]->len};
+            redisAppendCommandArgv(context, 3, argv, lens);
+        } else {
+            sds samplesstr = sdsfromlonglong(memkeys_samples);
+            const char *argv[] = {"MEMORY", "USAGE", keys->element[i]->str, "SAMPLES", samplesstr};
+            size_t lens[] = {6, 5, keys->element[i]->len, 7, sdslen(samplesstr)};
+            redisAppendCommandArgv(context, 5, argv, lens);
+            sdsfree(samplesstr);
+        }
+    }
+
+    /* Retrieve sizes */
+    for (i = 0; i < keys->elements; i++) {
+        /* Skip keys that disappeared between SCAN and TYPE (or unknown types when not in memkeys mode) */
+        if (!types[i] || (!types[i]->sizecmd && !memkeys)) {
+            sizes[i] = 0;
+            continue;
+        }
+
+        /* Retrieve size */
+        if (redisGetReply(context, (void **)&reply) != REDIS_OK) {
+            fprintf(stderr, "Error getting size for key '%s' (%d: %s)\n", keys->element[i]->str, context->err,
+                    context->errstr);
+            exit(1);
+        } else if (reply->type != REDIS_REPLY_INTEGER) {
+            /* Theoretically the key could have been removed and
+             * added as a different type between TYPE and SIZE */
+            fprintf(stderr, "Warning:  %s on '%s' failed (may have changed type)\n",
+                    !memkeys ? types[i]->sizecmd : "MEMORY USAGE", keys->element[i]->str);
+            sizes[i] = 0;
+        } else {
+            sizes[i] = reply->integer;
+        }
+
+        freeReplyObject(reply);
+    }
+}
+
+static void longStatLoopModeStop(int s) {
+    UNUSED(s);
+    force_cancel_loop = 1;
+}
+
+/* In cluster mode we may need to send the READONLY command.
+   Ignore the error in case the server isn't using cluster mode. */
+static void sendReadOnly(void) {
+    redisReply *read_reply;
+    read_reply = redisCommand(context, "READONLY");
+    if (read_reply == NULL) {
+        fprintf(stderr, "\nI/O error\n");
+        exit(1);
+    } else if (read_reply->type == REDIS_REPLY_ERROR &&
+               strcmp(read_reply->str, "ERR This instance has cluster support disabled") != 0) {
+        fprintf(stderr, "Error: %s\n", read_reply->str);
+        exit(1);
+    }
+    freeReplyObject(read_reply);
+}
+
+static void findBigKeys(int memkeys, unsigned memkeys_samples) {
+    unsigned long long sampled = 0, total_keys, totlen = 0, *sizes = NULL, it = 0, scan_loops = 0;
+    redisReply *reply, *keys;
+    unsigned int arrsize = 0, i;
+    dictIterator *di;
+    dictEntry *de;
+    typeinfo **types = NULL;
+    double pct;
+
+    dict *types_dict = dictCreate(&typeinfoDictType);
+    typeinfo_add(types_dict, "string", &type_string);
+    typeinfo_add(types_dict, "list", &type_list);
+    typeinfo_add(types_dict, "set", &type_set);
+    typeinfo_add(types_dict, "hash", &type_hash);
+    typeinfo_add(types_dict, "zset", &type_zset);
+    typeinfo_add(types_dict, "stream", &type_stream);
+
+    signal(SIGINT, longStatLoopModeStop);
+    /* Total keys pre scanning */
+    total_keys = getDbSize();
+
+    /* Status message */
+    printf("\n# Scanning the entire keyspace to find biggest keys as well as\n");
+    printf("# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec\n");
+    printf("# per 100 SCAN commands (not usually needed).\n\n");
+
+    /* Use readonly in cluster */
+    sendReadOnly();
+
+    /* SCAN loop */
+    do {
+        /* Calculate approximate percentage completion */
+        pct = 100 * (double)sampled / total_keys;
+
+        /* Grab some keys and point to the keys array */
+        reply = sendScan(&it);
+        scan_loops++;
+        keys = reply->element[1];
+
+        /* Reallocate our type and size array if we need to */
+        if (keys->elements > arrsize) {
+            types = zrealloc(types, sizeof(typeinfo *) * keys->elements);
+            sizes = zrealloc(sizes, sizeof(unsigned long long) * keys->elements);
+
+            if (!types || !sizes) {
+                fprintf(stderr, "Failed to allocate storage for keys!\n");
+                exit(1);
+            }
+
+            arrsize = keys->elements;
+        }
+
+        /* Retrieve types and then sizes */
+        getKeyTypes(types_dict, keys, types);
+        getKeySizes(keys, types, sizes, memkeys, memkeys_samples);
+
+        /* Now update our stats */
+        for (i = 0; i < keys->elements; i++) {
+            typeinfo *type = types[i];
+            /* Skip keys that disappeared between SCAN and TYPE */
+            if (!type) continue;
+
+            type->totalsize += sizes[i];
+            type->count++;
+            totlen += keys->element[i]->len;
+            sampled++;
+
+            if (type->biggest < sizes[i]) {
+                /* Keep track of biggest key name for this type */
+                if (type->biggest_key) sdsfree(type->biggest_key);
+                type->biggest_key = sdscatrepr(sdsempty(), keys->element[i]->str, keys->element[i]->len);
+                if (!type->biggest_key) {
+                    fprintf(stderr, "Failed to allocate memory for key!\n");
+                    exit(1);
+                }
+
+                printf("[%05.2f%%] Biggest %-6s found so far '%s' with %llu %s\n", pct, type->name, type->biggest_key,
+                       sizes[i], !memkeys ? type->sizeunit : "bytes");
+
+                /* Keep track of the biggest size for this type */
+                type->biggest = sizes[i];
+            }
+
+            /* Update overall progress */
+            if (sampled % 1000000 == 0) {
+                printf("[%05.2f%%] Sampled %llu keys so far\n", pct, sampled);
+            }
+        }
+
+        /* Sleep if we've been directed to do so */
+        if (config.interval && (scan_loops % 100) == 0) {
+            usleep(config.interval);
+        }
+
+        freeReplyObject(reply);
+    } while (force_cancel_loop == 0 && it != 0);
+
+    if (types) zfree(types);
+    if (sizes) zfree(sizes);
+
+    /* We're done */
+    printf("\n-------- summary -------\n\n");
+    if (force_cancel_loop) printf("[%05.2f%%] ", pct);
+    printf("Sampled %llu keys in the keyspace!\n", sampled);
+    printf("Total key length in bytes is %llu (avg len %.2f)\n\n", totlen, totlen ? (double)totlen / sampled : 0);
+
+    /* Output the biggest keys we found, for types we did find */
+    di = dictGetIterator(types_dict);
+    while ((de = dictNext(di))) {
+        typeinfo *type = dictGetVal(de);
+        if (type->biggest_key) {
+            printf("Biggest %6s found '%s' has %llu %s\n", type->name, type->biggest_key, type->biggest,
+                   !memkeys ? type->sizeunit : "bytes");
+        }
+    }
+    dictReleaseIterator(di);
+
+    printf("\n");
+
+    di = dictGetIterator(types_dict);
+    while ((de = dictNext(di))) {
+        typeinfo *type = dictGetVal(de);
+        printf("%llu %ss with %llu %s (%05.2f%% of keys, avg size %.2f)\n", type->count, type->name, type->totalsize,
+               !memkeys ? type->sizeunit : "bytes", sampled ? 100 * (double)type->count / sampled : 0,
+               type->count ? (double)type->totalsize / type->count : 0);
+    }
+    dictReleaseIterator(di);
+
+    dictRelease(types_dict);
+
+    /* Success! */
+    exit(0);
+}
+
+static void getKeyFreqs(redisReply *keys, unsigned long long *freqs) {
+    redisReply *reply;
+    unsigned int i;
+
+    /* Pipeline OBJECT freq commands */
+    for (i = 0; i < keys->elements; i++) {
+        const char *argv[] = {"OBJECT", "FREQ", keys->element[i]->str};
+        size_t lens[] = {6, 4, keys->element[i]->len};
+        redisAppendCommandArgv(context, 3, argv, lens);
+    }
+
+    /* Retrieve freqs */
+    for (i = 0; i < keys->elements; i++) {
+        if (redisGetReply(context, (void **)&reply) != REDIS_OK) {
+            sds keyname = sdscatrepr(sdsempty(), keys->element[i]->str, keys->element[i]->len);
+            fprintf(stderr, "Error getting freq for key '%s' (%d: %s)\n", keyname, context->err, context->errstr);
+            sdsfree(keyname);
+            exit(1);
+        } else if (reply->type != REDIS_REPLY_INTEGER) {
+            if (reply->type == REDIS_REPLY_ERROR) {
+                fprintf(stderr, "Error: %s\n", reply->str);
+                exit(1);
+            } else {
+                sds keyname = sdscatrepr(sdsempty(), keys->element[i]->str, keys->element[i]->len);
+                fprintf(stderr, "Warning: OBJECT freq on '%s' failed (may have been deleted)\n", keyname);
+                sdsfree(keyname);
+                freqs[i] = 0;
+            }
+        } else {
+            freqs[i] = reply->integer;
+        }
+        freeReplyObject(reply);
+    }
+}
+
+#define HOTKEYS_SAMPLE 16
+static void findHotKeys(void) {
+    redisReply *keys, *reply;
+    unsigned long long counters[HOTKEYS_SAMPLE] = {0};
+    sds hotkeys[HOTKEYS_SAMPLE] = {NULL};
+    unsigned long long sampled = 0, total_keys, *freqs = NULL, it = 0, scan_loops = 0;
+    unsigned int arrsize = 0, i, k;
+    double pct;
+
+    signal(SIGINT, longStatLoopModeStop);
+    /* Total keys pre scanning */
+    total_keys = getDbSize();
+
+    /* Status message */
+    printf("\n# Scanning the entire keyspace to find hot keys as well as\n");
+    printf("# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec\n");
+    printf("# per 100 SCAN commands (not usually needed).\n\n");
+
+    /* Use readonly in cluster */
+    sendReadOnly();
+
+    /* SCAN loop */
+    do {
+        /* Calculate approximate percentage completion */
+        pct = 100 * (double)sampled / total_keys;
+
+        /* Grab some keys and point to the keys array */
+        reply = sendScan(&it);
+        scan_loops++;
+        keys = reply->element[1];
+
+        /* Reallocate our freqs array if we need to */
+        if (keys->elements > arrsize) {
+            freqs = zrealloc(freqs, sizeof(unsigned long long) * keys->elements);
+
+            if (!freqs) {
+                fprintf(stderr, "Failed to allocate storage for keys!\n");
+                exit(1);
+            }
+
+            arrsize = keys->elements;
+        }
+
+        getKeyFreqs(keys, freqs);
+
+        /* Now update our stats */
+        for (i = 0; i < keys->elements; i++) {
+            sampled++;
+            /* Update overall progress */
+            if (sampled % 1000000 == 0) {
+                printf("[%05.2f%%] Sampled %llu keys so far\n", pct, sampled);
+            }
+
+            /* Use eviction pool here */
+            k = 0;
+            while (k < HOTKEYS_SAMPLE && freqs[i] > counters[k]) k++;
+            if (k == 0) continue;
+            k--;
+            if (k == 0 || counters[k] == 0) {
+                sdsfree(hotkeys[k]);
+            } else {
+                sdsfree(hotkeys[0]);
+                memmove(counters, counters + 1, sizeof(counters[0]) * k);
+                memmove(hotkeys, hotkeys + 1, sizeof(hotkeys[0]) * k);
+            }
+            counters[k] = freqs[i];
+            hotkeys[k] = sdscatrepr(sdsempty(), keys->element[i]->str, keys->element[i]->len);
+            printf("[%05.2f%%] Hot key '%s' found so far with counter %llu\n", pct, hotkeys[k], freqs[i]);
+        }
+
+        /* Sleep if we've been directed to do so */
+        if (config.interval && (scan_loops % 100) == 0) {
+            usleep(config.interval);
+        }
+
+        freeReplyObject(reply);
+    } while (force_cancel_loop == 0 && it != 0);
+
+    if (freqs) zfree(freqs);
+
+    /* We're done */
+    printf("\n-------- summary -------\n\n");
+    if (force_cancel_loop) printf("[%05.2f%%] ", pct);
+    printf("Sampled %llu keys in the keyspace!\n", sampled);
+
+    for (i = 1; i <= HOTKEYS_SAMPLE; i++) {
+        k = HOTKEYS_SAMPLE - i;
+        if (counters[k] > 0) {
+            printf("hot key found with counter: %llu\tkeyname: %s\n", counters[k], hotkeys[k]);
+            sdsfree(hotkeys[k]);
+        }
+    }
+
+    exit(0);
+}
+
+/*------------------------------------------------------------------------------
+ * Stats mode
+ *--------------------------------------------------------------------------- */
+
+/* Return the specified INFO field from the INFO command output "info".
+ * A new buffer is allocated for the result, that needs to be free'd.
+ * If the field is not found NULL is returned. */
+static char *getInfoField(char *info, char *field) {
+    char *p = strstr(info, field);
+    char *n1, *n2;
+    char *result;
+
+    if (!p) return NULL;
+    p += strlen(field) + 1;
+    n1 = strchr(p, '\r');
+    n2 = strchr(p, ',');
+    if (n2 && n2 < n1) n1 = n2;
+    result = zmalloc(sizeof(char) * (n1 - p) + 1);
+    memcpy(result, p, (n1 - p));
+    result[n1 - p] = '\0';
+    return result;
+}
+
+/* Like the above function but automatically convert the result into
+ * a long. On error (missing field) LONG_MIN is returned. */
+static long getLongInfoField(char *info, char *field) {
+    char *value = getInfoField(info, field);
+    long l;
+
+    if (!value) return LONG_MIN;
+    l = strtol(value, NULL, 10);
+    zfree(value);
+    return l;
+}
+
+/* Convert number of bytes into a human readable string of the form:
+ * 100B, 2G, 100M, 4K, and so forth. */
+void bytesToHuman(char *s, size_t size, long long n) {
+    double d;
+
+    if (n < 0) {
+        *s = '-';
+        s++;
+        n = -n;
+    }
+    if (n < 1024) {
+        /* Bytes */
+        snprintf(s, size, "%lldB", n);
+        return;
+    } else if (n < (1024 * 1024)) {
+        d = (double)n / (1024);
+        snprintf(s, size, "%.2fK", d);
+    } else if (n < (1024LL * 1024 * 1024)) {
+        d = (double)n / (1024 * 1024);
+        snprintf(s, size, "%.2fM", d);
+    } else if (n < (1024LL * 1024 * 1024 * 1024)) {
+        d = (double)n / (1024LL * 1024 * 1024);
+        snprintf(s, size, "%.2fG", d);
+    }
+}
+
+static void statMode(void) {
+    redisReply *reply;
+    long aux, requests = 0;
+    int dbnum = getDatabases();
+    int i = 0;
+
+    while (1) {
+        char buf[64];
+        int j;
+
+        reply = reconnectingRedisCommand(context, "INFO");
+        if (reply == NULL) {
+            fprintf(stderr, "\nI/O error\n");
+            exit(1);
+        } else if (reply->type == REDIS_REPLY_ERROR) {
+            fprintf(stderr, "ERROR: %s\n", reply->str);
+            exit(1);
+        }
+
+        if ((i++ % 20) == 0) {
+            printf("------- data ------ --------------------- load -------------------- - child -\n"
+                   "keys       mem      clients blocked requests            connections          \n");
+        }
+
+        /* Keys */
+        aux = 0;
+        for (j = 0; j < dbnum; j++) {
+            long k;
+
+            snprintf(buf, sizeof(buf), "db%d:keys", j);
+            k = getLongInfoField(reply->str, buf);
+            if (k == LONG_MIN) continue;
+            aux += k;
+        }
+        snprintf(buf, sizeof(buf), "%ld", aux);
+        printf("%-11s", buf);
+
+        /* Used memory */
+        aux = getLongInfoField(reply->str, "used_memory");
+        bytesToHuman(buf, sizeof(buf), aux);
+        printf("%-8s", buf);
+
+        /* Clients */
+        aux = getLongInfoField(reply->str, "connected_clients");
+        snprintf(buf, sizeof(buf), "%ld", aux);
+        printf(" %-8s", buf);
+
+        /* Blocked (BLPOPPING) Clients */
+        aux = getLongInfoField(reply->str, "blocked_clients");
+        snprintf(buf, sizeof(buf), "%ld", aux);
+        printf("%-8s", buf);
+
+        /* Requests */
+        aux = getLongInfoField(reply->str, "total_commands_processed");
+        snprintf(buf, sizeof(buf), "%ld (+%ld)", aux, requests == 0 ? 0 : aux - requests);
+        printf("%-19s", buf);
+        requests = aux;
+
+        /* Connections */
+        aux = getLongInfoField(reply->str, "total_connections_received");
+        snprintf(buf, sizeof(buf), "%ld", aux);
+        printf(" %-12s", buf);
+
+        /* Children */
+        aux = getLongInfoField(reply->str, "bgsave_in_progress");
+        aux |= getLongInfoField(reply->str, "aof_rewrite_in_progress") << 1;
+        aux |= getLongInfoField(reply->str, "loading") << 2;
+        switch (aux) {
+        case 0: break;
+        case 1: printf("SAVE"); break;
+        case 2: printf("AOF"); break;
+        case 3: printf("SAVE+AOF"); break;
+        case 4: printf("LOAD"); break;
+        }
+
+        printf("\n");
+        freeReplyObject(reply);
+        usleep(config.interval);
+    }
+}
+
+/*------------------------------------------------------------------------------
+ * Scan mode
+ *--------------------------------------------------------------------------- */
+
+static void scanMode(void) {
+    redisReply *reply;
+    unsigned long long cur = 0;
+    signal(SIGINT, longStatLoopModeStop);
+    do {
+        reply = sendScan(&cur);
+        for (unsigned int j = 0; j < reply->element[1]->elements; j++) {
+            if (config.output == OUTPUT_STANDARD) {
+                sds out =
+                    sdscatrepr(sdsempty(), reply->element[1]->element[j]->str, reply->element[1]->element[j]->len);
+                printf("%s\n", out);
+                sdsfree(out);
+            } else {
+                printf("%s\n", reply->element[1]->element[j]->str);
+            }
+        }
+        freeReplyObject(reply);
+        if (config.interval) usleep(config.interval);
+    } while (force_cancel_loop == 0 && cur != 0);
+
+    exit(0);
+}
+
+/*------------------------------------------------------------------------------
+ * LRU test mode
+ *--------------------------------------------------------------------------- */
+
+/* Return an integer from min to max (both inclusive) using a power-law
+ * distribution, depending on the value of alpha: the greater the alpha
+ * the more bias towards lower values.
+ *
+ * With alpha = 6.2 the output follows the 80-20 rule where 20% of
+ * the returned numbers will account for 80% of the frequency. */
+long long powerLawRand(long long min, long long max, double alpha) {
+    double pl, r;
+
+    max += 1;
+    r = ((double)rand()) / RAND_MAX;
+    pl = pow(((pow(max, alpha + 1) - pow(min, alpha + 1)) * r + pow(min, alpha + 1)), (1.0 / (alpha + 1)));
+    return (max - 1 - (long long)pl) + min;
+}
+
+/* Generates a key name among a set of lru_test_sample_size keys, using
+ * an 80-20 distribution. */
+void LRUTestGenKey(char *buf, size_t buflen) {
+    snprintf(buf, buflen, "lru:%lld", powerLawRand(1, config.lru_test_sample_size, 6.2));
+}
+
+#define LRU_CYCLE_PERIOD 1000 /* 1000 milliseconds. */
+#define LRU_CYCLE_PIPELINE_SIZE 250
+static void LRUTestMode(void) {
+    redisReply *reply;
+    char key[128];
+    long long start_cycle;
+    int j;
+
+    srand(time(NULL) ^ getpid());
+    while (1) {
+        /* Perform cycles of 1 second with 50% writes and 50% reads.
+         * We use pipelining batching writes / reads N times per cycle in order
+         * to fill the target instance easily. */
+        start_cycle = mstime();
+        long long hits = 0, misses = 0;
+        while (mstime() - start_cycle < LRU_CYCLE_PERIOD) {
+            /* Write cycle. */
+            for (j = 0; j < LRU_CYCLE_PIPELINE_SIZE; j++) {
+                char val[6];
+                val[5] = '\0';
+                for (int i = 0; i < 5; i++) val[i] = 'A' + rand() % ('z' - 'A');
+                LRUTestGenKey(key, sizeof(key));
+                redisAppendCommand(context, "SET %s %s", key, val);
+            }
+            for (j = 0; j < LRU_CYCLE_PIPELINE_SIZE; j++) redisGetReply(context, (void **)&reply);
+
+            /* Read cycle. */
+            for (j = 0; j < LRU_CYCLE_PIPELINE_SIZE; j++) {
+                LRUTestGenKey(key, sizeof(key));
+                redisAppendCommand(context, "GET %s", key);
+            }
+            for (j = 0; j < LRU_CYCLE_PIPELINE_SIZE; j++) {
+                if (redisGetReply(context, (void **)&reply) == REDIS_OK) {
+                    switch (reply->type) {
+                    case REDIS_REPLY_ERROR: fprintf(stderr, "%s\n", reply->str); break;
+                    case REDIS_REPLY_NIL: misses++; break;
+                    default: hits++; break;
+                    }
+                }
+            }
+
+            if (context->err) {
+                fprintf(stderr, "I/O error during LRU test\n");
+                exit(1);
+            }
+        }
+        /* Print stats. */
+        printf("%lld Gets/sec | Hits: %lld (%.2f%%) | Misses: %lld (%.2f%%)\n", hits + misses, hits,
+               (double)hits / (hits + misses) * 100, misses, (double)misses / (hits + misses) * 100);
+    }
+    exit(0);
+}
+
+/*------------------------------------------------------------------------------
+ * Intrinsic latency mode.
+ *
+ * Measure max latency of a running process that does not result from
+ * syscalls. Basically this software should provide a hint about how much
+ * time the kernel leaves the process without a chance to run.
+ *--------------------------------------------------------------------------- */
+
+/* This is just some computation the compiler can't optimize out.
+ * Should run in less than 100-200 microseconds even using very
+ * slow hardware. Runs in less than 10 microseconds in modern HW. */
+unsigned long compute_something_fast(void) {
+    unsigned char s[256], i, j, t;
+    int count = 1000, k;
+    unsigned long output = 0;
+
+    for (k = 0; k < 256; k++) s[k] = k;
+
+    i = 0;
+    j = 0;
+    while (count--) {
+        i++;
+        j = j + s[i];
+        t = s[i];
+        s[i] = s[j];
+        s[j] = t;
+        output += s[(s[i] + s[j]) & 255];
+    }
+    return output;
+}
+
+static void sigIntHandler(int s) {
+    UNUSED(s);
+
+    if (config.monitor_mode || config.pubsub_mode) {
+        close(context->fd);
+        context->fd = REDIS_INVALID_FD;
+        config.blocking_state_aborted = 1;
+    } else {
+        exit(1);
+    }
+}
+
+static void intrinsicLatencyMode(void) {
+    long long test_end, run_time, max_latency = 0, runs = 0;
+
+    run_time = (long long)config.intrinsic_latency_duration * 1000000;
+    test_end = ustime() + run_time;
+    signal(SIGINT, longStatLoopModeStop);
+
+    while (1) {
+        long long start, end, latency;
+
+        start = ustime();
+        compute_something_fast();
+        end = ustime();
+        latency = end - start;
+        runs++;
+        if (latency <= 0) continue;
+
+        /* Reporting */
+        if (latency > max_latency) {
+            max_latency = latency;
+            printf("Max latency so far: %lld microseconds.\n", max_latency);
+        }
+
+        double avg_us = (double)run_time / runs;
+        double avg_ns = avg_us * 1e3;
+        if (force_cancel_loop || end > test_end) {
+            printf("\n%lld total runs "
+                   "(avg latency: "
+                   "%.4f microseconds / %.2f nanoseconds per run).\n",
+                   runs, avg_us, avg_ns);
+            printf("Worst run took %.0fx longer than the average latency.\n", max_latency / avg_us);
+            exit(0);
+        }
+    }
+}
+
+static sds askPassword(const char *msg) {
+    linenoiseMaskModeEnable();
+    sds auth = linenoise(msg);
+    linenoiseMaskModeDisable();
+    return auth;
+}
+
+/* Prints out the hint completion string for a given input prefix string. */
+void testHint(const char *input) {
+    cliInitHelp();
+
+    sds hint = getHintForInput(input);
+    printf("%s\n", hint);
+    exit(0);
+}
+
+sds readHintSuiteLine(char buf[], size_t size, FILE *fp) {
+    while (fgets(buf, size, fp) != NULL) {
+        if (buf[0] != '#') {
+            sds input = sdsnew(buf);
+
+            /* Strip newline. */
+            input = sdstrim(input, "\n");
+            return input;
+        }
+    }
+    return NULL;
+}
+
+/* Runs a suite of hint completion tests contained in a file. */
+void testHintSuite(char *filename) {
+    FILE *fp;
+    char buf[256];
+    sds line, input, expected, hint;
+    int pass = 0, fail = 0;
+    int argc;
+    char **argv;
+
+    fp = fopen(filename, "r");
+    if (!fp) {
+        fprintf(stderr, "Can't open file '%s': %s\n", filename, strerror(errno));
+        exit(-1);
+    }
+
+    cliInitHelp();
+
+    while (1) {
+        line = readHintSuiteLine(buf, sizeof(buf), fp);
+        if (line == NULL) break;
+        argv = sdssplitargs(line, &argc);
+        sdsfree(line);
+        if (argc == 0) {
+            sdsfreesplitres(argv, argc);
+            continue;
+        }
+
+        if (argc == 1) {
+            fprintf(stderr, "Missing expected hint for input '%s'\n", argv[0]);
+            exit(-1);
+        }
+        input = argv[0];
+        expected = argv[1];
+        hint = getHintForInput(input);
+        if (config.verbose) {
+            printf("Input: '%s', Expected: '%s', Hint: '%s'\n", input, expected, hint);
+        }
+
+        /* Strip trailing spaces from hint - they don't matter. */
+        while (hint != NULL && sdslen(hint) > 0 && hint[sdslen(hint) - 1] == ' ') {
+            sdssetlen(hint, sdslen(hint) - 1);
+            hint[sdslen(hint)] = '\0';
+        }
+
+        if (hint == NULL || strcmp(hint, expected) != 0) {
+            fprintf(stderr, "Test case '%s' FAILED: expected '%s', got '%s'\n", input, expected, hint);
+            ++fail;
+        } else {
+            ++pass;
+        }
+        sdsfreesplitres(argv, argc);
+        sdsfree(hint);
+    }
+    fclose(fp);
+
+    printf("%s: %d/%d passed\n", fail == 0 ? "SUCCESS" : "FAILURE", pass, pass + fail);
+    exit(fail);
+}
+
+/*------------------------------------------------------------------------------
+ * Program main()
+ *--------------------------------------------------------------------------- */
+
+int main(int argc, char **argv) {
+    int firstarg;
+    struct timeval tv;
+
+    memset(&config.sslconfig, 0, sizeof(config.sslconfig));
+    config.conn_info.hostip = sdsnew("127.0.0.1");
+    config.conn_info.hostport = 6379;
+    config.connect_timeout.tv_sec = 0;
+    config.connect_timeout.tv_usec = 0;
+    config.hostsocket = NULL;
+    config.repeat = 1;
+    config.interval = 0;
+    config.dbnum = 0;
+    config.conn_info.input_dbnum = 0;
+    config.interactive = 0;
+    config.shutdown = 0;
+    config.monitor_mode = 0;
+    config.pubsub_mode = 0;
+    config.pubsub_unsharded_count = 0;
+    config.pubsub_sharded_count = 0;
+    config.blocking_state_aborted = 0;
+    config.latency_mode = 0;
+    config.latency_dist_mode = 0;
+    config.latency_history = 0;
+    config.lru_test_mode = 0;
+    config.lru_test_sample_size = 0;
+    config.cluster_mode = 0;
+    config.cluster_send_asking = 0;
+    config.replica_mode = 0;
+    config.getrdb_mode = 0;
+    config.get_functions_rdb_mode = 0;
+    config.stat_mode = 0;
+    config.scan_mode = 0;
+    config.count = 10;
+    config.intrinsic_latency_mode = 0;
+    config.pattern = NULL;
+    config.rdb_filename = NULL;
+    config.pipe_mode = 0;
+    config.pipe_timeout = CLI_DEFAULT_PIPE_TIMEOUT;
+    config.bigkeys = 0;
+    config.memkeys = 0;
+    config.hotkeys = 0;
+    config.stdin_lastarg = 0;
+    config.stdin_tag_arg = 0;
+    config.stdin_tag_name = NULL;
+    config.conn_info.auth = NULL;
+    config.askpass = 0;
+    config.conn_info.user = NULL;
+    config.eval = NULL;
+    config.eval_ldb = 0;
+    config.eval_ldb_end = 0;
+    config.eval_ldb_sync = 0;
+    config.enable_ldb_on_eval = 0;
+    config.last_cmd_type = -1;
+    config.last_reply = NULL;
+    config.verbose = 0;
+    config.set_errcode = 0;
+    config.no_auth_warning = 0;
+    config.in_multi = 0;
+    config.server_version = NULL;
+    config.prefer_ipv4 = 0;
+    config.prefer_ipv6 = 0;
+    config.cluster_manager_command.name = NULL;
+    config.cluster_manager_command.argc = 0;
+    config.cluster_manager_command.argv = NULL;
+    config.cluster_manager_command.stdin_arg = NULL;
+    config.cluster_manager_command.flags = 0;
+    config.cluster_manager_command.replicas = 0;
+    config.cluster_manager_command.from = NULL;
+    config.cluster_manager_command.to = NULL;
+    config.cluster_manager_command.from_user = NULL;
+    config.cluster_manager_command.from_pass = NULL;
+    config.cluster_manager_command.from_askpass = 0;
+    config.cluster_manager_command.weight = NULL;
+    config.cluster_manager_command.weight_argc = 0;
+    config.cluster_manager_command.slots = 0;
+    config.cluster_manager_command.timeout = CLUSTER_MANAGER_MIGRATE_TIMEOUT;
+    config.cluster_manager_command.pipeline = CLUSTER_MANAGER_MIGRATE_PIPELINE;
+    config.cluster_manager_command.threshold = CLUSTER_MANAGER_REBALANCE_THRESHOLD;
+    config.cluster_manager_command.backup_dir = NULL;
+    pref.hints = 1;
+
+    spectrum_palette = spectrum_palette_color;
+    spectrum_palette_size = spectrum_palette_color_size;
+
+    if (!isatty(fileno(stdout)) && (getenv("FAKETTY") == NULL)) {
+        config.output = OUTPUT_RAW;
+        config.push_output = 0;
+    } else {
+        config.output = OUTPUT_STANDARD;
+        config.push_output = 1;
+    }
+    config.mb_delim = sdsnew("\n");
+    config.cmd_delim = sdsnew("\n");
+
+    firstarg = parseOptions(argc, argv);
+    argc -= firstarg;
+    argv += firstarg;
+
+    parseEnv();
+
+    if (config.askpass) {
+        config.conn_info.auth = askPassword("Please input password: ");
+    }
+
+    if (config.cluster_manager_command.from_askpass) {
+        config.cluster_manager_command.from_pass = askPassword("Please input import source node password: ");
+    }
+
+#ifdef USE_OPENSSL
+    if (config.tls) {
+        cliSecureInit();
+    }
+#endif
+
+    gettimeofday(&tv, NULL);
+    init_genrand64(((long long)tv.tv_sec * 1000000 + tv.tv_usec) ^ getpid());
+
+    /* Cluster Manager mode */
+    if (CLUSTER_MANAGER_MODE()) {
+        clusterManagerCommandProc *proc = validateClusterManagerCommand();
+        if (!proc) {
+            exit(1);
+        }
+        clusterManagerMode(proc);
+    }
+
+    /* Latency mode */
+    if (config.latency_mode) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        latencyMode();
+    }
+
+    /* Latency distribution mode */
+    if (config.latency_dist_mode) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        latencyDistMode();
+    }
+
+    /* Replica mode */
+    if (config.replica_mode) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        sendCapa();
+        sendReplconf("rdb-filter-only", "");
+        replicaMode(1);
+    }
+
+    /* Get RDB/functions mode. */
+    if (config.getrdb_mode || config.get_functions_rdb_mode) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        sendCapa();
+        sendRdbOnly();
+        if (config.get_functions_rdb_mode && !sendReplconf("rdb-filter-only", "functions")) {
+            fprintf(stderr, "Failed requesting functions only RDB from server, aborting\n");
+            exit(1);
+        }
+        getRDB(NULL);
+    }
+
+    /* Pipe mode */
+    if (config.pipe_mode) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        pipeMode();
+    }
+
+    /* Find big keys */
+    if (config.bigkeys) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        findBigKeys(0, 0);
+    }
+
+    /* Find large keys */
+    if (config.memkeys) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        findBigKeys(1, config.memkeys_samples);
+    }
+
+    /* Find hot keys */
+    if (config.hotkeys) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        findHotKeys();
+    }
+
+    /* Stat mode */
+    if (config.stat_mode) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        if (config.interval == 0) config.interval = 1000000;
+        statMode();
+    }
+
+    /* Scan mode */
+    if (config.scan_mode) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        scanMode();
+    }
+
+    /* LRU test mode */
+    if (config.lru_test_mode) {
+        if (cliConnect(0) == REDIS_ERR) exit(1);
+        LRUTestMode();
+    }
+
+    /* Intrinsic latency mode */
+    if (config.intrinsic_latency_mode) intrinsicLatencyMode();
+
+    /* Print command-line hint for an input prefix string */
+    if (config.test_hint) {
+        testHint(config.test_hint);
+    }
+    /* Run test suite for command-line hints */
+    if (config.test_hint_file) {
+        testHintSuite(config.test_hint_file);
+    }
+
+    /* Start interactive mode when no command is provided */
+    if (argc == 0 && !config.eval) {
+        /* Ignore SIGPIPE in interactive mode to force a reconnect */
+        signal(SIGPIPE, SIG_IGN);
+        signal(SIGINT, sigIntHandler);
+
+        /* Note that in repl mode we don't abort on connection error.
+         * A new attempt will be performed for every command send. */
+        cliConnect(0);
+        repl();
+    }
+
+    /* Otherwise, we have some arguments to execute */
+    if (config.eval) {
+        if (cliConnect(0) != REDIS_OK) exit(1);
+        return evalMode(argc, argv);
+    } else {
+        cliConnect(CC_QUIET);
+        return noninteractive(argc, argv);
+    }
+}