gvsafronov/futriix
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

clang-format: set ColumnLimit to 0 and reformat (#1045)

Browse Source 
This commit hopefully improves the formatting of the codebase by setting
ColumnLimit to 0 and hence stopping clang-format from trying to put as
much stuff in one line as possible.

This change enabled us to remove most of `clang-format off` directives
and fixed a bunch of lines that looked like this:

```c
#define KEY \
    VALUE /* comment */
```

Additionally, one pair of `clang-format off` / `clang-format on` had
`clang-format off` as the second comment and hence didn't enable the
formatting for the rest of the file. This commit addresses this issue as
well.

Please tell me if anything in the changes seem off. If everything is
fine, I will add this commit to `.git-blame-ignore-revs` later.

---------

Signed-off-by: Mikhail Koviazin <mikhail.koviazin@aiven.io>
This commit is contained in:
Mikhail Koviazin 2024-09-25 02:22:54 +03:00 committed by GitHub
parent 6ce75cdea8
commit af811748e7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
62 changed files with 2091 additions and 2210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/.clang-format
View File

@ -2,7 +2,7 @@ BasedOnStyle: LLVM
IndentWidth: 4
TabWidth: 4
UseTab: Never
ColumnLimit: 120
ColumnLimit: 0
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 100

56
src/acl.c
View File

@ -3117,37 +3117,35 @@ void aclCommand(client *c) {
addReply(c, shared.ok);
} else if (c->argc == 2 && !strcasecmp(sub, "help")) {
/* clang-format off */
const char *help[] = {
"CAT [<category>]",
" List all commands that belong to <category>, or all command categories",
" when no category is specified.",
"DELUSER <username> [<username> ...]",
" Delete a list of users.",
"DRYRUN <username> <command> [<arg> ...]",
" Returns whether the user can execute the given command without executing the command.",
"GETUSER <username>",
" Get the user's details.",
"GENPASS [<bits>]",
" Generate a secure 256-bit user password. The optional `bits` argument can",
" be used to specify a different size.",
"LIST",
" Show users details in config file format.",
"LOAD",
" Reload users from the ACL file.",
"LOG [<count> | RESET]",
" Show the ACL log entries.",
"SAVE",
" Save the current config to the ACL file.",
"SETUSER <username> <attribute> [<attribute> ...]",
" Create or modify a user with the specified attributes.",
"USERS",
" List all the registered usernames.",
"WHOAMI",
" Return the current connection username.",
NULL
"CAT [<category>]",
" List all commands that belong to <category>, or all command categories",
" when no category is specified.",
"DELUSER <username> [<username> ...]",
" Delete a list of users.",
"DRYRUN <username> <command> [<arg> ...]",
" Returns whether the user can execute the given command without executing the command.",
"GETUSER <username>",
" Get the user's details.",
"GENPASS [<bits>]",
" Generate a secure 256-bit user password. The optional `bits` argument can",
" be used to specify a different size.",
"LIST",
" Show users details in config file format.",
"LOAD",
" Reload users from the ACL file.",
"LOG [<count> | RESET]",
" Show the ACL log entries.",
"SAVE",
" Save the current config to the ACL file.",
"SETUSER <username> <attribute> [<attribute> ...]",
" Create or modify a user with the specified attributes.",
"USERS",
" List all the registered usernames.",
"WHOAMI",
" Return the current connection username.",
NULL,
};
/* clang-format on */
addReplyHelp(c, help);
} else {
addReplySubcommandSyntaxError(c);

12
src/ae.c
View File

@ -63,14 +63,14 @@
#endif
#endif
#define AE_LOCK(eventLoop) \
if ((eventLoop)->flags & AE_PROTECT_POLL) { \
assert(pthread_mutex_lock(&(eventLoop)->poll_mutex) == 0); \
#define AE_LOCK(eventLoop) \
if ((eventLoop)->flags & AE_PROTECT_POLL) { \
assert(pthread_mutex_lock(&(eventLoop)->poll_mutex) == 0); \
}
#define AE_UNLOCK(eventLoop) \
if ((eventLoop)->flags & AE_PROTECT_POLL) { \
assert(pthread_mutex_unlock(&(eventLoop)->poll_mutex) == 0); \
#define AE_UNLOCK(eventLoop) \
if ((eventLoop)->flags & AE_PROTECT_POLL) { \
assert(pthread_mutex_unlock(&(eventLoop)->poll_mutex) == 0); \
}
aeEventLoop *aeCreateEventLoop(int setsize) {

11
src/ae.h
View File

@ -42,12 +42,11 @@
#define AE_NONE 0 /* No events registered. */
#define AE_READABLE 1 /* Fire when descriptor is readable. */
#define AE_WRITABLE 2 /* Fire when descriptor is writable. */
#define AE_BARRIER \
4 /* With WRITABLE, never fire the event if the \
READABLE event already fired in the same event \
loop iteration. Useful when you want to persist \
things to disk before sending replies, and want \
to do that in a group fashion. */
#define AE_BARRIER 4 /* With WRITABLE, never fire the event if the \
READABLE event already fired in the same event \
loop iteration. Useful when you want to persist \
things to disk before sending replies, and want \
to do that in a group fashion. */
#define AE_FILE_EVENTS (1 << 0)
#define AE_TIME_EVENTS (1 << 1)

40
src/asciilogo.h
View File

@ -28,25 +28,23 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
/* clang-format off */
const char *ascii_logo =
" .+^+. \n"
" .+#########+. \n"
" .+########+########+. Valkey %s (%s/%d) %s bit\n"
" .+########+' '+########+. \n"
" .########+' .+. '+########. Running in %s mode\n"
" |####+' .+#######+. '+####| Port: %d\n"
" |###| .+###############+. |###| PID: %ld \n"
" |###| |#####*'' ''*#####| |###| \n"
" |###| |####' .-. '####| |###| \n"
" |###| |###( (@@@) )###| |###| https://valkey.io \n"
" |###| |####. '-' .####| |###| \n"
" |###| |#####*. .*#####| |###| \n"
" |###| '+#####| |#####+' |###| \n"
" |####+. +##| |#+' .+####| \n"
" '#######+ |##| .+########' \n"
" '+###| |##| .+########+' \n"
" '| |####+########+' \n"
" +#########+' \n"
" '+v+' \n\n";
/* clang-format off */
" .+^+. \n"
" .+#########+. \n"
" .+########+########+. Valkey %s (%s/%d) %s bit\n"
" .+########+' '+########+. \n"
" .########+' .+. '+########. Running in %s mode\n"
" |####+' .+#######+. '+####| Port: %d\n"
" |###| .+###############+. |###| PID: %ld \n"
" |###| |#####*'' ''*#####| |###| \n"
" |###| |####' .-. '####| |###| \n"
" |###| |###( (@@@) )###| |###| https://valkey.io \n"
" |###| |####. '-' .####| |###| \n"
" |###| |#####*. .*#####| |###| \n"
" |###| '+#####| |#####+' |###| \n"
" |####+. +##| |#+' .+####| \n"
" '#######+ |##| .+########' \n"
" '+###| |##| .+########+' \n"
" '| |####+########+' \n"
" +#########+' \n"
" '+v+' \n\n";

197
src/atomicvar.h
View File

@ -1,197 +0,0 @@
/* This file implements atomic counters using c11 _Atomic, __atomic or __sync
* macros if available, otherwise we will throw an error when compile.
*
* The exported interface is composed of the following macros:
*
* atomicIncr(var,count) -- Increment the atomic counter
* atomicGetIncr(var,oldvalue_var,count) -- Get and increment the atomic counter
* atomicIncrGet(var,newvalue_var,count) -- Increment and get the atomic counter new value
* atomicDecr(var,count) -- Decrement the atomic counter
* atomicGet(var,dstvar) -- Fetch the atomic counter value
* atomicSet(var,value) -- Set the atomic counter value
* atomicGetWithSync(var,value) -- 'atomicGet' with inter-thread synchronization
* atomicSetWithSync(var,value) -- 'atomicSet' with inter-thread synchronization
*
* Atomic operations on flags.
* Flag type can be int, long, long long or their unsigned counterparts.
* The value of the flag can be 1 or 0.
*
* atomicFlagGetSet(var,oldvalue_var) -- Get and set the atomic counter value
*
* NOTE1: __atomic* and _Atomic implementations can be actually elaborated to support any value by changing the
* hardcoded new value passed to __atomic_exchange* from 1 to @param count
* i.e oldvalue_var = atomic_exchange_explicit(&var, count).
* However, in order to be compatible with the __sync functions family, we can use only 0 and 1.
* The only exchange alternative suggested by __sync is __sync_lock_test_and_set,
* But as described by the gnu manual for __sync_lock_test_and_set():
* https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html
* "A target may support reduced functionality here by which the only valid value to store is the immediate constant 1.
* The exact value actually stored in *ptr is implementation defined." Hence, we can't rely on it for a any value other
* than 1. We eventually chose to implement this method with __sync_val_compare_and_swap since it satisfies
* functionality needed for atomicFlagGetSet (if the flag was 0 -> set to 1, if it's already 1 -> do nothing, but the
* final result is that the flag is set), and also it has a full barrier (__sync_lock_test_and_set has acquire barrier).
*
* NOTE2: Unlike other atomic type, which aren't guaranteed to be lock free, c11 atomic_flag does.
* To check whether a type is lock free, atomic_is_lock_free() can be used.
* It can be considered to limit the flag type to atomic_flag to improve performance.
*
* Never use return value from the macros, instead use the AtomicGetIncr()
* if you need to get the current value and increment it atomically, like
* in the following example:
*
* long oldvalue;
* atomicGetIncr(myvar,oldvalue,1);
* doSomethingWith(oldvalue);
*
* ----------------------------------------------------------------------------
*
* Copyright (c) 2015, 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 <pthread.h>
#include "config.h"
#ifndef __ATOMIC_VAR_H
#define __ATOMIC_VAR_H
/* Define serverAtomic for atomic variable. */
#define serverAtomic
/* To test the server with Helgrind (a Valgrind tool) it is useful to define
* the following macro, so that __sync macros are used: those can be detected
* by Helgrind (even if they are less efficient) so that no false positive
* is reported. */
// #define __ATOMIC_VAR_FORCE_SYNC_MACROS
/* There will be many false positives if we test the server with Helgrind, since
* Helgrind can't understand we have imposed ordering on the program, so
* we use macros in helgrind.h to tell Helgrind inter-thread happens-before
* relationship explicitly for avoiding false positives.
*
* For more details, please see: valgrind/helgrind.h and
* https://www.valgrind.org/docs/manual/hg-manual.html#hg-manual.effective-use
*
* These macros take effect only when 'make helgrind', and you must first
* install Valgrind in the default path configuration. */
#ifdef __ATOMIC_VAR_FORCE_SYNC_MACROS
#include <valgrind/helgrind.h>
#else
#define ANNOTATE_HAPPENS_BEFORE(v) ((void)v)
#define ANNOTATE_HAPPENS_AFTER(v) ((void)v)
#endif
#if !defined(__ATOMIC_VAR_FORCE_SYNC_MACROS) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
!defined(__STDC_NO_ATOMICS__)
/* Use '_Atomic' keyword if the compiler supports. */
#undef serverAtomic
#define serverAtomic _Atomic
/* Implementation using _Atomic in C11. */
#include <stdatomic.h>
#define atomicIncr(var, count) atomic_fetch_add_explicit(&var, (count), memory_order_relaxed)
#define atomicGetIncr(var, oldvalue_var, count) \
do { \
oldvalue_var = atomic_fetch_add_explicit(&var, (count), memory_order_relaxed); \
} while (0)
#define atomicIncrGet(var, newvalue_var, count) newvalue_var = atomicIncr(var, count) + count
#define atomicDecr(var, count) atomic_fetch_sub_explicit(&var, (count), memory_order_relaxed)
#define atomicGet(var, dstvar) \
do { \
dstvar = atomic_load_explicit(&var, memory_order_relaxed); \
} while (0)
#define atomicSet(var, value) atomic_store_explicit(&var, value, memory_order_relaxed)
#define atomicGetWithSync(var, dstvar) \
do { \
dstvar = atomic_load_explicit(&var, memory_order_seq_cst); \
} while (0)
#define atomicSetWithSync(var, value) atomic_store_explicit(&var, value, memory_order_seq_cst)
#define atomicFlagGetSet(var, oldvalue_var) oldvalue_var = atomic_exchange_explicit(&var, 1, memory_order_relaxed)
#define REDIS_ATOMIC_API "c11-builtin"
#elif !defined(__ATOMIC_VAR_FORCE_SYNC_MACROS) && \
(!defined(__clang__) || !defined(__APPLE__) || __apple_build_version__ > 4210057) && defined(__ATOMIC_RELAXED) && \
defined(__ATOMIC_SEQ_CST)
/* Implementation using __atomic macros. */
#define atomicIncr(var, count) __atomic_add_fetch(&var, (count), __ATOMIC_RELAXED)
#define atomicIncrGet(var, newvalue_var, count) newvalue_var = __atomic_add_fetch(&var, (count), __ATOMIC_RELAXED)
#define atomicGetIncr(var, oldvalue_var, count) \
do { \
oldvalue_var = __atomic_fetch_add(&var, (count), __ATOMIC_RELAXED); \
} while (0)
#define atomicDecr(var, count) __atomic_sub_fetch(&var, (count), __ATOMIC_RELAXED)
#define atomicGet(var, dstvar) \
do { \
dstvar = __atomic_load_n(&var, __ATOMIC_RELAXED); \
} while (0)
#define atomicSet(var, value) __atomic_store_n(&var, value, __ATOMIC_RELAXED)
#define atomicGetWithSync(var, dstvar) \
do { \
dstvar = __atomic_load_n(&var, __ATOMIC_SEQ_CST); \
} while (0)
#define atomicSetWithSync(var, value) __atomic_store_n(&var, value, __ATOMIC_SEQ_CST)
#define atomicFlagGetSet(var, oldvalue_var) oldvalue_var = __atomic_exchange_n(&var, 1, __ATOMIC_RELAXED)
#define REDIS_ATOMIC_API "atomic-builtin"
#elif defined(HAVE_ATOMIC)
/* Implementation using __sync macros. */
#define atomicIncr(var, count) __sync_add_and_fetch(&var, (count))
#define atomicIncrGet(var, newvalue_var, count) newvalue_var = __sync_add_and_fetch(&var, (count))
#define atomicGetIncr(var, oldvalue_var, count) \
do { \
oldvalue_var = __sync_fetch_and_add(&var, (count)); \
} while (0)
#define atomicDecr(var, count) __sync_sub_and_fetch(&var, (count))
#define atomicGet(var, dstvar) \
do { \
dstvar = __sync_sub_and_fetch(&var, 0); \
} while (0)
#define atomicSet(var, value) \
do { \
while (!__sync_bool_compare_and_swap(&var, var, value)); \
} while (0)
/* Actually the builtin issues a full memory barrier by default. */
#define atomicGetWithSync(var, dstvar) \
do { \
dstvar = __sync_sub_and_fetch(&var, 0, __sync_synchronize); \
ANNOTATE_HAPPENS_AFTER(&var); \
} while (0)
#define atomicSetWithSync(var, value) \
do { \
ANNOTATE_HAPPENS_BEFORE(&var); \
while (!__sync_bool_compare_and_swap(&var, var, value, __sync_synchronize)); \
} while (0)
#define atomicFlagGetSet(var, oldvalue_var) oldvalue_var = __sync_val_compare_and_swap(&var, 0, 1)
#define REDIS_ATOMIC_API "sync-builtin"
#else
#error "Unable to determine atomic operations for your platform"
#endif
#endif /* __ATOMIC_VAR_H */

8
src/cli_commands.c
View File

@ -2,11 +2,11 @@
#include "cli_commands.h"
/* Definitions to configure commands.c to generate the above structs. */
#define MAKE_CMD(name, summary, complexity, since, doc_flags, replaced, deprecated, group, group_enum, history, \
num_history, tips, num_tips, function, arity, flags, acl, key_specs, key_specs_num, get_keys, \
numargs) \
#define MAKE_CMD(name, summary, complexity, since, doc_flags, replaced, deprecated, group, group_enum, history, \
num_history, tips, num_tips, function, arity, flags, acl, key_specs, key_specs_num, get_keys, \
numargs) \
name, summary, group, since, numargs
#define MAKE_ARG(name, type, key_spec_index, token, summary, since, flags, numsubargs, deprecated_since) \
#define MAKE_ARG(name, type, key_spec_index, token, summary, since, flags, numsubargs, deprecated_since) \
name, type, token, since, flags, numsubargs
#define COMMAND_ARG cliCommandArg
#define COMMAND_STRUCT commandDocs

4
src/cluster.h
View File

@ -5,8 +5,8 @@
* Cluster exported API.
*----------------------------------------------------------------------------*/
#define CLUSTER_SLOT_MASK_BITS 14 /* Number of bits used for slot id. */
#define CLUSTER_SLOTS (1 << CLUSTER_SLOT_MASK_BITS) /* Total number of slots in cluster mode, which is 16384. */
#define CLUSTER_SLOT_MASK_BITS 14 /* Number of bits used for slot id. */
#define CLUSTER_SLOTS (1 << CLUSTER_SLOT_MASK_BITS) /* Total number of slots in cluster mode, which is 16384. */
#define CLUSTER_SLOT_MASK ((unsigned long long)(CLUSTER_SLOTS - 1)) /* Bit mask for slot id stored in LSB. */
#define CLUSTER_OK 0 /* Everything looks ok */
#define CLUSTER_FAIL 1 /* The cluster can't work */

21
src/cluster_legacy.c
View File

@ -144,7 +144,7 @@ static inline int defaultClientPort(void) {
return server.tls_cluster ? server.tls_port : server.port;
}
#define isSlotUnclaimed(slot) \
#define isSlotUnclaimed(slot) \
(server.cluster->slots[slot] == NULL || bitmapTestBit(server.cluster->owner_not_claiming_slot, slot))
#define RCVBUF_INIT_LEN 1024
@ -191,7 +191,10 @@ dictType clusterSdsToListType = {
};
typedef struct {
enum { ITER_DICT, ITER_LIST } type;
enum {
ITER_DICT,
ITER_LIST
} type;
union {
dictIterator di;
listIter li;
@ -4576,7 +4579,7 @@ void clusterHandleReplicaFailover(void) {
* elapsed, we can setup a new one. */
if (auth_age > auth_retry_time) {
server.cluster->failover_auth_time = mstime() +
500 + /* Fixed delay of 500 milliseconds, let FAIL msg propagate. */
500 + /* Fixed delay of 500 milliseconds, let FAIL msg propagate. */
random() % 500; /* Random delay between 0 and 500 milliseconds. */
server.cluster->failover_auth_count = 0;
server.cluster->failover_auth_sent = 0;
@ -5509,10 +5512,14 @@ struct clusterNodeFlags {
};
static struct clusterNodeFlags clusterNodeFlagsTable[] = {
{CLUSTER_NODE_MYSELF, "myself,"}, {CLUSTER_NODE_PRIMARY, "master,"},
{CLUSTER_NODE_REPLICA, "slave,"}, {CLUSTER_NODE_PFAIL, "fail?,"},
{CLUSTER_NODE_FAIL, "fail,"}, {CLUSTER_NODE_HANDSHAKE, "handshake,"},
{CLUSTER_NODE_NOADDR, "noaddr,"}, {CLUSTER_NODE_NOFAILOVER, "nofailover,"}};
{CLUSTER_NODE_MYSELF, "myself,"},
{CLUSTER_NODE_PRIMARY, "master,"},
{CLUSTER_NODE_REPLICA, "slave,"},
{CLUSTER_NODE_PFAIL, "fail?,"},
{CLUSTER_NODE_FAIL, "fail,"},
{CLUSTER_NODE_HANDSHAKE, "handshake,"},
{CLUSTER_NODE_NOADDR, "noaddr,"},
{CLUSTER_NODE_NOFAILOVER, "nofailover,"}};
/* Concatenate the comma separated list of node flags to the given SDS
* string 'ci'. */

5
src/cluster_legacy.h
View File

@ -292,9 +292,8 @@ static_assert(offsetof(clusterMsg, data) == 2256, "unexpected field offset");
/* Message flags better specify the packet content or are used to
* provide some information about the node state. */
#define CLUSTERMSG_FLAG0_PAUSED (1 << 0) /* Primary paused for manual failover. */
#define CLUSTERMSG_FLAG0_FORCEACK \
(1 << 1) /* Give ACK to AUTH_REQUEST even if \
#define CLUSTERMSG_FLAG0_PAUSED (1 << 0) /* Primary paused for manual failover. */
#define CLUSTERMSG_FLAG0_FORCEACK (1 << 1) /* Give ACK to AUTH_REQUEST even if \
primary is up. */
#define CLUSTERMSG_FLAG0_EXT_DATA (1 << 2) /* Message contains extension data */

9
src/cluster_slot_stats.c
View File

@ -8,7 +8,14 @@
#define UNASSIGNED_SLOT 0
typedef enum { KEY_COUNT, CPU_USEC, NETWORK_BYTES_IN, NETWORK_BYTES_OUT, SLOT_STAT_COUNT, INVALID } slotStatType;
typedef enum {
KEY_COUNT,
CPU_USEC,
NETWORK_BYTES_IN,
NETWORK_BYTES_OUT,
SLOT_STAT_COUNT,
INVALID
} slotStatType;
/* -----------------------------------------------------------------------------
* CLUSTER SLOT-STATS command

10
src/commands.c
View File

@ -1,12 +1,12 @@
#include "commands.h"
#include "server.h"
#define MAKE_CMD(name, summary, complexity, since, doc_flags, replaced, deprecated, group, group_enum, history, \
num_history, tips, num_tips, function, arity, flags, acl, key_specs, key_specs_num, get_keys, \
numargs) \
name, summary, complexity, since, doc_flags, replaced, deprecated, group_enum, history, num_history, tips, \
#define MAKE_CMD(name, summary, complexity, since, doc_flags, replaced, deprecated, group, group_enum, history, \
num_history, tips, num_tips, function, arity, flags, acl, key_specs, key_specs_num, get_keys, \
numargs) \
name, summary, complexity, since, doc_flags, replaced, deprecated, group_enum, history, num_history, tips, \
num_tips, function, arity, flags, acl, key_specs, key_specs_num, get_keys, numargs
#define MAKE_ARG(name, type, key_spec_index, token, summary, since, flags, numsubargs, deprecated_since) \
#define MAKE_ARG(name, type, key_spec_index, token, summary, since, flags, numsubargs, deprecated_since) \
name, type, key_spec_index, token, summary, since, flags, deprecated_since, numsubargs
#define COMMAND_STRUCT serverCommand
#define COMMAND_ARG serverCommandArg

433
src/config.c
View File

@ -51,76 +51,105 @@ typedef struct deprecatedConfig {
const int argc_max;
} deprecatedConfig;
configEnum maxmemory_policy_enum[] = {{"volatile-lru", MAXMEMORY_VOLATILE_LRU},
{"volatile-lfu", MAXMEMORY_VOLATILE_LFU},
{"volatile-random", MAXMEMORY_VOLATILE_RANDOM},
{"volatile-ttl", MAXMEMORY_VOLATILE_TTL},
{"allkeys-lru", MAXMEMORY_ALLKEYS_LRU},
{"allkeys-lfu", MAXMEMORY_ALLKEYS_LFU},
{"allkeys-random", MAXMEMORY_ALLKEYS_RANDOM},
{"noeviction", MAXMEMORY_NO_EVICTION},
{NULL, 0}};
configEnum maxmemory_policy_enum[] = {
{"volatile-lru", MAXMEMORY_VOLATILE_LRU},
{"volatile-lfu", MAXMEMORY_VOLATILE_LFU},
{"volatile-random", MAXMEMORY_VOLATILE_RANDOM},
{"volatile-ttl", MAXMEMORY_VOLATILE_TTL},
{"allkeys-lru", MAXMEMORY_ALLKEYS_LRU},
{"allkeys-lfu", MAXMEMORY_ALLKEYS_LFU},
{"allkeys-random", MAXMEMORY_ALLKEYS_RANDOM},
{"noeviction", MAXMEMORY_NO_EVICTION},
{NULL, 0}};
configEnum syslog_facility_enum[] = {{"user", LOG_USER}, {"local0", LOG_LOCAL0},
{"local1", LOG_LOCAL1}, {"local2", LOG_LOCAL2},
{"local3", LOG_LOCAL3}, {"local4", LOG_LOCAL4},
{"local5", LOG_LOCAL5}, {"local6", LOG_LOCAL6},
{"local7", LOG_LOCAL7}, {NULL, 0}};
configEnum syslog_facility_enum[] = {
{"user", LOG_USER},
{"local0", LOG_LOCAL0},
{"local1", LOG_LOCAL1},
{"local2", LOG_LOCAL2},
{"local3", LOG_LOCAL3},
{"local4", LOG_LOCAL4},
{"local5", LOG_LOCAL5},
{"local6", LOG_LOCAL6},
{"local7", LOG_LOCAL7},
{NULL, 0}};
configEnum loglevel_enum[] = {{"debug", LL_DEBUG}, {"verbose", LL_VERBOSE}, {"notice", LL_NOTICE},
{"warning", LL_WARNING}, {"nothing", LL_NOTHING}, {NULL, 0}};
configEnum loglevel_enum[] = {
{"debug", LL_DEBUG},
{"verbose", LL_VERBOSE},
{"notice", LL_NOTICE},
{"warning", LL_WARNING},
{"nothing", LL_NOTHING},
{NULL, 0}};
configEnum supervised_mode_enum[] = {{"upstart", SUPERVISED_UPSTART},
{"systemd", SUPERVISED_SYSTEMD},
{"auto", SUPERVISED_AUTODETECT},
{"no", SUPERVISED_NONE},
{NULL, 0}};
configEnum supervised_mode_enum[] = {
{"upstart", SUPERVISED_UPSTART},
{"systemd", SUPERVISED_SYSTEMD},
{"auto", SUPERVISED_AUTODETECT},
{"no", SUPERVISED_NONE},
{NULL, 0}};
configEnum aof_fsync_enum[] = {{"everysec", AOF_FSYNC_EVERYSEC},
{"always", AOF_FSYNC_ALWAYS},
{"no", AOF_FSYNC_NO},
{NULL, 0}};
configEnum aof_fsync_enum[] = {
{"everysec", AOF_FSYNC_EVERYSEC},
{"always", AOF_FSYNC_ALWAYS},
{"no", AOF_FSYNC_NO},
{NULL, 0}};
configEnum shutdown_on_sig_enum[] = {{"default", 0}, {"save", SHUTDOWN_SAVE}, {"nosave", SHUTDOWN_NOSAVE},
{"now", SHUTDOWN_NOW}, {"force", SHUTDOWN_FORCE}, {NULL, 0}};
configEnum shutdown_on_sig_enum[] = {
{"default", 0},
{"save", SHUTDOWN_SAVE},
{"nosave", SHUTDOWN_NOSAVE},
{"now", SHUTDOWN_NOW},
{"force", SHUTDOWN_FORCE},
{NULL, 0}};
configEnum repl_diskless_load_enum[] = {{"disabled", REPL_DISKLESS_LOAD_DISABLED},
{"on-empty-db", REPL_DISKLESS_LOAD_WHEN_DB_EMPTY},
{"swapdb", REPL_DISKLESS_LOAD_SWAPDB},
{NULL, 0}};
configEnum repl_diskless_load_enum[] = {
{"disabled", REPL_DISKLESS_LOAD_DISABLED},
{"on-empty-db", REPL_DISKLESS_LOAD_WHEN_DB_EMPTY},
{"swapdb", REPL_DISKLESS_LOAD_SWAPDB},
{NULL, 0}};
configEnum tls_auth_clients_enum[] = {{"no", TLS_CLIENT_AUTH_NO},
{"yes", TLS_CLIENT_AUTH_YES},
{"optional", TLS_CLIENT_AUTH_OPTIONAL},
{NULL, 0}};
configEnum tls_auth_clients_enum[] = {
{"no", TLS_CLIENT_AUTH_NO},
{"yes", TLS_CLIENT_AUTH_YES},
{"optional", TLS_CLIENT_AUTH_OPTIONAL},
{NULL, 0}};
configEnum oom_score_adj_enum[] = {{"no", OOM_SCORE_ADJ_NO},
{"yes", OOM_SCORE_RELATIVE},
{"relative", OOM_SCORE_RELATIVE},
{"absolute", OOM_SCORE_ADJ_ABSOLUTE},
{NULL, 0}};
configEnum oom_score_adj_enum[] = {
{"no", OOM_SCORE_ADJ_NO},
{"yes", OOM_SCORE_RELATIVE},
{"relative", OOM_SCORE_RELATIVE},
{"absolute", OOM_SCORE_ADJ_ABSOLUTE},
{NULL, 0}};
configEnum acl_pubsub_default_enum[] = {{"allchannels", SELECTOR_FLAG_ALLCHANNELS}, {"resetchannels", 0}, {NULL, 0}};
configEnum acl_pubsub_default_enum[] = {
{"allchannels", SELECTOR_FLAG_ALLCHANNELS},
{"resetchannels", 0},
{NULL, 0}};
configEnum sanitize_dump_payload_enum[] = {{"no", SANITIZE_DUMP_NO},
{"yes", SANITIZE_DUMP_YES},
{"clients", SANITIZE_DUMP_CLIENTS},
{NULL, 0}};
configEnum sanitize_dump_payload_enum[] = {
{"no", SANITIZE_DUMP_NO},
{"yes", SANITIZE_DUMP_YES},
{"clients", SANITIZE_DUMP_CLIENTS},
{NULL, 0}};
configEnum protected_action_enum[] = {{"no", PROTECTED_ACTION_ALLOWED_NO},
{"yes", PROTECTED_ACTION_ALLOWED_YES},
{"local", PROTECTED_ACTION_ALLOWED_LOCAL},
{NULL, 0}};
configEnum protected_action_enum[] = {
{"no", PROTECTED_ACTION_ALLOWED_NO},
{"yes", PROTECTED_ACTION_ALLOWED_YES},
{"local", PROTECTED_ACTION_ALLOWED_LOCAL},
{NULL, 0}};
configEnum cluster_preferred_endpoint_type_enum[] = {{"ip", CLUSTER_ENDPOINT_TYPE_IP},
{"hostname", CLUSTER_ENDPOINT_TYPE_HOSTNAME},
{"unknown-endpoint", CLUSTER_ENDPOINT_TYPE_UNKNOWN_ENDPOINT},
{NULL, 0}};
configEnum cluster_preferred_endpoint_type_enum[] = {
{"ip", CLUSTER_ENDPOINT_TYPE_IP},
{"hostname", CLUSTER_ENDPOINT_TYPE_HOSTNAME},
{"unknown-endpoint", CLUSTER_ENDPOINT_TYPE_UNKNOWN_ENDPOINT},
{NULL, 0}};
configEnum propagation_error_behavior_enum[] = {{"ignore", PROPAGATION_ERR_BEHAVIOR_IGNORE},
{"panic", PROPAGATION_ERR_BEHAVIOR_PANIC},
{"panic-on-replicas", PROPAGATION_ERR_BEHAVIOR_PANIC_ON_REPLICAS},
{NULL, 0}};
configEnum propagation_error_behavior_enum[] = {
{"ignore", PROPAGATION_ERR_BEHAVIOR_IGNORE},
{"panic", PROPAGATION_ERR_BEHAVIOR_PANIC},
{"panic-on-replicas", PROPAGATION_ERR_BEHAVIOR_PANIC_ON_REPLICAS},
{NULL, 0}};
/* Output buffer limits presets. */
clientBufferLimitsConfig clientBufferLimitsDefaults[CLIENT_TYPE_OBUF_COUNT] = {
@ -1760,10 +1789,10 @@ int rewriteConfig(char *path, int force_write) {
#define LOADBUF_SIZE 256
static char loadbuf[LOADBUF_SIZE];
#define embedCommonConfig(config_name, config_alias, config_flags) \
#define embedCommonConfig(config_name, config_alias, config_flags) \
.name = (config_name), .alias = (config_alias), .flags = (config_flags),
#define embedConfigInterface(initfn, setfn, getfn, rewritefn, applyfn) \
#define embedConfigInterface(initfn, setfn, getfn, rewritefn, applyfn) \
.interface = {.init = (initfn), .set = (setfn), .get = (getfn), .rewrite = (rewritefn), .apply = (applyfn)},
/* What follows is the generic config types that are supported. To add a new
@ -1814,16 +1843,16 @@ static void boolConfigRewrite(standardConfig *config, const char *name, struct r
rewriteConfigYesNoOption(state, name, val, config->data.yesno.default_value);
}
#define createBoolConfig(name, alias, flags, config_addr, default, is_valid, apply) \
{ \
embedCommonConfig(name, alias, flags) \
embedConfigInterface(boolConfigInit, boolConfigSet, boolConfigGet, boolConfigRewrite, apply) \
.type = BOOL_CONFIG, \
.data.yesno = { \
.config = &(config_addr), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
} \
#define createBoolConfig(name, alias, flags, config_addr, default, is_valid, apply) \
{ \
embedCommonConfig(name, alias, flags) \
embedConfigInterface(boolConfigInit, boolConfigSet, boolConfigGet, boolConfigRewrite, apply) \
.type = BOOL_CONFIG, \
.data.yesno = { \
.config = &(config_addr), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
} \
}
/* String Configs */
@ -1904,30 +1933,30 @@ static void sdsConfigRewrite(standardConfig *config, const char *name, struct re
#define ALLOW_EMPTY_STRING 0
#define EMPTY_STRING_IS_NULL 1
#define createStringConfig(name, alias, flags, empty_to_null, config_addr, default, is_valid, apply) \
{ \
embedCommonConfig(name, alias, flags) \
embedConfigInterface(stringConfigInit, stringConfigSet, stringConfigGet, stringConfigRewrite, apply) \
.type = STRING_CONFIG, \
.data.string = { \
.config = &(config_addr), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
.convert_empty_to_null = (empty_to_null), \
} \
#define createStringConfig(name, alias, flags, empty_to_null, config_addr, default, is_valid, apply) \
{ \
embedCommonConfig(name, alias, flags) \
embedConfigInterface(stringConfigInit, stringConfigSet, stringConfigGet, stringConfigRewrite, apply) \
.type = STRING_CONFIG, \
.data.string = { \
.config = &(config_addr), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
.convert_empty_to_null = (empty_to_null), \
} \
}
#define createSDSConfig(name, alias, flags, empty_to_null, config_addr, default, is_valid, apply) \
{ \
embedCommonConfig(name, alias, flags) \
embedConfigInterface(sdsConfigInit, sdsConfigSet, sdsConfigGet, sdsConfigRewrite, apply) \
.type = SDS_CONFIG, \
.data.sds = { \
.config = &(config_addr), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
.convert_empty_to_null = (empty_to_null), \
} \
#define createSDSConfig(name, alias, flags, empty_to_null, config_addr, default, is_valid, apply) \
{ \
embedCommonConfig(name, alias, flags) \
embedConfigInterface(sdsConfigInit, sdsConfigSet, sdsConfigGet, sdsConfigRewrite, apply) \
.type = SDS_CONFIG, \
.data.sds = { \
.config = &(config_addr), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
.convert_empty_to_null = (empty_to_null), \
} \
}
/* Enum configs */
@ -1977,17 +2006,17 @@ static void enumConfigRewrite(standardConfig *config, const char *name, struct r
rewriteConfigEnumOption(state, name, val, config);
}
#define createEnumConfig(name, alias, flags, enum, config_addr, default, is_valid, apply) \
{ \
embedCommonConfig(name, alias, flags) \
embedConfigInterface(enumConfigInit, enumConfigSet, enumConfigGet, enumConfigRewrite, apply) \
.type = ENUM_CONFIG, \
.data.enumd = { \
.config = &(config_addr), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
.enum_value = (enum), \
} \
#define createEnumConfig(name, alias, flags, enum, config_addr, default, is_valid, apply) \
{ \
embedCommonConfig(name, alias, flags) \
embedConfigInterface(enumConfigInit, enumConfigSet, enumConfigGet, enumConfigRewrite, apply) \
.type = ENUM_CONFIG, \
.data.enumd = { \
.config = &(config_addr), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
.enum_value = (enum), \
} \
}
/* Gets a 'long long val' and sets it into the union, using a macro to get
@ -2022,30 +2051,30 @@ int setNumericType(standardConfig *config, long long val, const char **err) {
/* Gets a 'long long val' and sets it with the value from the union, using a
* macro to get compile time type check. */
#define GET_NUMERIC_TYPE(val) \
if (config->data.numeric.numeric_type == NUMERIC_TYPE_INT) { \
val = *(config->data.numeric.config.i); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_UINT) { \
val = *(config->data.numeric.config.ui); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_LONG) { \
val = *(config->data.numeric.config.l); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_ULONG) { \
val = *(config->data.numeric.config.ul); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_LONG_LONG) { \
if (config->flags & MODULE_CONFIG) \
val = getModuleNumericConfig(config->privdata); \
else \
val = *(config->data.numeric.config.ll); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_ULONG_LONG) { \
val = *(config->data.numeric.config.ull); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_SIZE_T) { \
val = *(config->data.numeric.config.st); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_SSIZE_T) { \
val = *(config->data.numeric.config.sst); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_OFF_T) { \
val = *(config->data.numeric.config.ot); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_TIME_T) { \
val = *(config->data.numeric.config.tt); \
#define GET_NUMERIC_TYPE(val) \
if (config->data.numeric.numeric_type == NUMERIC_TYPE_INT) { \
val = *(config->data.numeric.config.i); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_UINT) { \
val = *(config->data.numeric.config.ui); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_LONG) { \
val = *(config->data.numeric.config.l); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_ULONG) { \
val = *(config->data.numeric.config.ul); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_LONG_LONG) { \
if (config->flags & MODULE_CONFIG) \
val = getModuleNumericConfig(config->privdata); \
else \
val = *(config->data.numeric.config.ll); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_ULONG_LONG) { \
val = *(config->data.numeric.config.ull); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_SIZE_T) { \
val = *(config->data.numeric.config.st); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_SSIZE_T) { \
val = *(config->data.numeric.config.sst); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_OFF_T) { \
val = *(config->data.numeric.config.ot); \
} else if (config->data.numeric.numeric_type == NUMERIC_TYPE_TIME_T) { \
val = *(config->data.numeric.config.tt); \
}
/* Numeric configs */
@ -2187,57 +2216,57 @@ static void numericConfigRewrite(standardConfig *config, const char *name, struc
}
}
#define embedCommonNumericalConfig(name, alias, _flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
{ \
embedCommonConfig(name, alias, _flags) \
embedConfigInterface(numericConfigInit, numericConfigSet, numericConfigGet, numericConfigRewrite, apply) \
.type = NUMERIC_CONFIG, \
.data.numeric = { \
.lower_bound = (lower), \
.upper_bound = (upper), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
#define embedCommonNumericalConfig(name, alias, _flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
{ \
embedCommonConfig(name, alias, _flags) \
embedConfigInterface(numericConfigInit, numericConfigSet, numericConfigGet, numericConfigRewrite, apply) \
.type = NUMERIC_CONFIG, \
.data.numeric = { \
.lower_bound = (lower), \
.upper_bound = (upper), \
.default_value = (default), \
.is_valid_fn = (is_valid), \
.flags = (num_conf_flags),
#define createIntConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_INT, \
.config.i = &(config_addr) \
} \
#define createIntConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_INT, \
.config.i = &(config_addr) \
} \
}
#define createUIntConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_UINT, \
.config.ui = &(config_addr) \
} \
#define createUIntConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_UINT, \
.config.ui = &(config_addr) \
} \
}
#define createLongConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_LONG, \
.config.l = &(config_addr) \
} \
#define createLongConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_LONG, \
.config.l = &(config_addr) \
} \
}
#define createULongConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_ULONG, \
.config.ul = &(config_addr) \
} \
#define createULongConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_ULONG, \
.config.ul = &(config_addr) \
} \
}
#define createLongLongConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_LONG_LONG, \
.config.ll = &(config_addr) \
} \
#define createLongLongConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_LONG_LONG, \
.config.ll = &(config_addr) \
} \
}
#define createULongLongConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
@ -2248,40 +2277,40 @@ static void numericConfigRewrite(standardConfig *config, const char *name, struc
} \
}
#define createSizeTConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_SIZE_T, \
.config.st = &(config_addr) \
} \
#define createSizeTConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_SIZE_T, \
.config.st = &(config_addr) \
} \
}
#define createSSizeTConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_SSIZE_T, \
.config.sst = &(config_addr) \
} \
#define createSSizeTConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_SSIZE_T, \
.config.sst = &(config_addr) \
} \
}
#define createTimeTConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_TIME_T, \
.config.tt = &(config_addr) \
} \
#define createTimeTConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_TIME_T, \
.config.tt = &(config_addr) \
} \
}
#define createOffTConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_OFF_T, \
.config.ot = &(config_addr) \
} \
#define createOffTConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, apply) \
embedCommonNumericalConfig(name, alias, flags, lower, upper, config_addr, default, num_conf_flags, is_valid, \
apply) \
.numeric_type = NUMERIC_TYPE_OFF_T, \
.config.ot = &(config_addr) \
} \
}
#define createSpecialConfig(name, alias, modifiable, setfn, getfn, rewritefn, applyfn) \
{.type = SPECIAL_CONFIG, \
#define createSpecialConfig(name, alias, modifiable, setfn, getfn, rewritefn, applyfn) \
{.type = SPECIAL_CONFIG, \
embedCommonConfig(name, alias, modifiable) embedConfigInterface(NULL, setfn, getfn, rewritefn, applyfn)}
static int isValidActiveDefrag(int val, const char **err) {
@ -3054,7 +3083,6 @@ static int applyClientMaxMemoryUsage(const char **err) {
}
standardConfig static_configs[] = {
/* clang-format off */
/* Bool configs */
createBoolConfig("rdbchecksum", NULL, IMMUTABLE_CONFIG, server.rdb_checksum, 1, NULL, NULL),
createBoolConfig("daemonize", NULL, IMMUTABLE_CONFIG, server.daemonize, 0, NULL, NULL),
@ -3066,7 +3094,7 @@ standardConfig static_configs[] = {
createBoolConfig("activerehashing", NULL, MODIFIABLE_CONFIG, server.activerehashing, 1, NULL, NULL),
createBoolConfig("stop-writes-on-bgsave-error", NULL, MODIFIABLE_CONFIG, server.stop_writes_on_bgsave_err, 1, NULL, NULL),
createBoolConfig("set-proc-title", NULL, IMMUTABLE_CONFIG, server.set_proc_title, 1, NULL, NULL), /* Should setproctitle be used? */
createBoolConfig("dynamic-hz", NULL, MODIFIABLE_CONFIG, server.dynamic_hz, 1, NULL, NULL), /* Adapt hz to # of clients.*/
createBoolConfig("dynamic-hz", NULL, MODIFIABLE_CONFIG, server.dynamic_hz, 1, NULL, NULL), /* Adapt hz to # of clients.*/
createBoolConfig("lazyfree-lazy-eviction", NULL, DEBUG_CONFIG | MODIFIABLE_CONFIG, server.lazyfree_lazy_eviction, 1, NULL, NULL),
createBoolConfig("lazyfree-lazy-expire", NULL, DEBUG_CONFIG | MODIFIABLE_CONFIG, server.lazyfree_lazy_expire, 1, NULL, NULL),
createBoolConfig("lazyfree-lazy-server-del", NULL, DEBUG_CONFIG | MODIFIABLE_CONFIG, server.lazyfree_lazy_server_del, 1, NULL, NULL),
@ -3164,7 +3192,7 @@ standardConfig static_configs[] = {
/* Integer configs */
createIntConfig("databases", NULL, IMMUTABLE_CONFIG, 1, INT_MAX, server.dbnum, 16, INTEGER_CONFIG, NULL, NULL),
createIntConfig("port", NULL, MODIFIABLE_CONFIG, 0, 65535, server.port, 6379, INTEGER_CONFIG, NULL, updatePort), /* TCP port. */
createIntConfig("port", NULL, MODIFIABLE_CONFIG, 0, 65535, server.port, 6379, INTEGER_CONFIG, NULL, updatePort), /* TCP port. */
createIntConfig("io-threads", NULL, DEBUG_CONFIG | IMMUTABLE_CONFIG, 1, 128, server.io_threads_num, 1, INTEGER_CONFIG, NULL, NULL), /* Single threaded by default */
createIntConfig("events-per-io-thread", NULL, MODIFIABLE_CONFIG, 0, INT_MAX, server.events_per_io_thread, 2, INTEGER_CONFIG, NULL, NULL),
createIntConfig("prefetch-batch-max-size", NULL, MODIFIABLE_CONFIG, 0, 128, server.prefetch_batch_max_size, 16, INTEGER_CONFIG, NULL, NULL),
@ -3173,9 +3201,9 @@ standardConfig static_configs[] = {
createIntConfig("list-max-listpack-size", "list-max-ziplist-size", MODIFIABLE_CONFIG, INT_MIN, INT_MAX, server.list_max_listpack_size, -2, INTEGER_CONFIG, NULL, NULL),
createIntConfig("tcp-keepalive", NULL, MODIFIABLE_CONFIG, 0, INT_MAX, server.tcpkeepalive, 300, INTEGER_CONFIG, NULL, NULL),
createIntConfig("cluster-migration-barrier", NULL, MODIFIABLE_CONFIG, 0, INT_MAX, server.cluster_migration_barrier, 1, INTEGER_CONFIG, NULL, NULL),
createIntConfig("active-defrag-cycle-min", NULL, MODIFIABLE_CONFIG, 1, 99, server.active_defrag_cycle_min, 1, INTEGER_CONFIG, NULL, updateDefragConfiguration), /* Default: 1% CPU min (at lower threshold) */
createIntConfig("active-defrag-cycle-max", NULL, MODIFIABLE_CONFIG, 1, 99, server.active_defrag_cycle_max, 25, INTEGER_CONFIG, NULL, updateDefragConfiguration), /* Default: 25% CPU max (at upper threshold) */
createIntConfig("active-defrag-threshold-lower", NULL, MODIFIABLE_CONFIG, 0, 1000, server.active_defrag_threshold_lower, 10, INTEGER_CONFIG, NULL, NULL), /* Default: don't defrag when fragmentation is below 10% */
createIntConfig("active-defrag-cycle-min", NULL, MODIFIABLE_CONFIG, 1, 99, server.active_defrag_cycle_min, 1, INTEGER_CONFIG, NULL, updateDefragConfiguration), /* Default: 1% CPU min (at lower threshold) */
createIntConfig("active-defrag-cycle-max", NULL, MODIFIABLE_CONFIG, 1, 99, server.active_defrag_cycle_max, 25, INTEGER_CONFIG, NULL, updateDefragConfiguration), /* Default: 25% CPU max (at upper threshold) */
createIntConfig("active-defrag-threshold-lower", NULL, MODIFIABLE_CONFIG, 0, 1000, server.active_defrag_threshold_lower, 10, INTEGER_CONFIG, NULL, NULL), /* Default: don't defrag when fragmentation is below 10% */
createIntConfig("active-defrag-threshold-upper", NULL, MODIFIABLE_CONFIG, 0, 1000, server.active_defrag_threshold_upper, 100, INTEGER_CONFIG, NULL, updateDefragConfiguration), /* Default: maximum defrag force at 100% fragmentation */
createIntConfig("lfu-log-factor", NULL, MODIFIABLE_CONFIG, 0, INT_MAX, server.lfu_log_factor, 10, INTEGER_CONFIG, NULL, NULL),
createIntConfig("lfu-decay-time", NULL, MODIFIABLE_CONFIG, 0, INT_MAX, server.lfu_decay_time, 1, INTEGER_CONFIG, NULL, NULL),
@ -3188,7 +3216,7 @@ standardConfig static_configs[] = {
createIntConfig("tcp-backlog", NULL, IMMUTABLE_CONFIG, 0, INT_MAX, server.tcp_backlog, 511, INTEGER_CONFIG, NULL, NULL), /* TCP listen backlog. */
createIntConfig("cluster-port", NULL, IMMUTABLE_CONFIG, 0, 65535, server.cluster_port, 0, INTEGER_CONFIG, NULL, NULL),
createIntConfig("cluster-announce-bus-port", NULL, MODIFIABLE_CONFIG, 0, 65535, server.cluster_announce_bus_port, 0, INTEGER_CONFIG, NULL, updateClusterAnnouncedPort), /* Default: Use +10000 offset. */
createIntConfig("cluster-announce-port", NULL, MODIFIABLE_CONFIG, 0, 65535, server.cluster_announce_port, 0, INTEGER_CONFIG, NULL, updateClusterAnnouncedPort), /* Use server.port */
createIntConfig("cluster-announce-port", NULL, MODIFIABLE_CONFIG, 0, 65535, server.cluster_announce_port, 0, INTEGER_CONFIG, NULL, updateClusterAnnouncedPort), /* Use server.port */
createIntConfig("cluster-announce-tls-port", NULL, MODIFIABLE_CONFIG, 0, 65535, server.cluster_announce_tls_port, 0, INTEGER_CONFIG, NULL, updateClusterAnnouncedPort), /* Use server.tls_port */
createIntConfig("repl-timeout", NULL, MODIFIABLE_CONFIG, 1, INT_MAX, server.repl_timeout, 60, INTEGER_CONFIG, NULL, NULL),
createIntConfig("repl-ping-replica-period", "repl-ping-slave-period", MODIFIABLE_CONFIG, 1, INT_MAX, server.repl_ping_replica_period, 10, INTEGER_CONFIG, NULL, NULL),
@ -3244,7 +3272,7 @@ standardConfig static_configs[] = {
createSizeTConfig("stream-node-max-bytes", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.stream_node_max_bytes, 4096, MEMORY_CONFIG, NULL, NULL),
createSizeTConfig("zset-max-listpack-value", "zset-max-ziplist-value", MODIFIABLE_CONFIG, 0, LONG_MAX, server.zset_max_listpack_value, 64, MEMORY_CONFIG, NULL, NULL),
createSizeTConfig("hll-sparse-max-bytes", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.hll_sparse_max_bytes, 3000, MEMORY_CONFIG, NULL, NULL),
createSizeTConfig("tracking-table-max-keys", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.tracking_table_max_keys, 1000000, INTEGER_CONFIG, NULL, NULL), /* Default: 1 million keys max. */
createSizeTConfig("tracking-table-max-keys", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.tracking_table_max_keys, 1000000, INTEGER_CONFIG, NULL, NULL), /* Default: 1 million keys max. */
createSizeTConfig("client-query-buffer-limit", NULL, DEBUG_CONFIG | MODIFIABLE_CONFIG, 1024 * 1024, LONG_MAX, server.client_max_querybuf_len, 1024 * 1024 * 1024, MEMORY_CONFIG, NULL, NULL), /* Default: 1GB max query buffer. */
createSSizeTConfig("maxmemory-clients", NULL, MODIFIABLE_CONFIG, -100, SSIZE_MAX, server.maxmemory_clients, 0, MEMORY_CONFIG | PERCENT_CONFIG, NULL, applyClientMaxMemoryUsage),
@ -3286,8 +3314,7 @@ standardConfig static_configs[] = {
createSpecialConfig("latency-tracking-info-percentiles", NULL, MODIFIABLE_CONFIG | MULTI_ARG_CONFIG, setConfigLatencyTrackingInfoPercentilesOutputOption, getConfigLatencyTrackingInfoPercentilesOutputOption, rewriteConfigLatencyTrackingInfoPercentilesOutputOption, NULL),
/* NULL Terminator, this is dropped when we convert to the runtime array. */
{NULL}
/* clang-format on */
{NULL},
};
/* Create a new config by copying the passed in config. Returns 1 on success

28
src/config.h
View File

@ -77,8 +77,8 @@
#endif
/* Test for backtrace() */
#if defined(__APPLE__) || (defined(__linux__) && defined(__GLIBC__)) || defined(__FreeBSD__) || \
((defined(__OpenBSD__) || defined(__NetBSD__) || defined(__sun)) && defined(USE_BACKTRACE)) || \
#if defined(__APPLE__) || (defined(__linux__) && defined(__GLIBC__)) || defined(__FreeBSD__) || \
((defined(__OpenBSD__) || defined(__NetBSD__) || defined(__sun)) && defined(USE_BACKTRACE)) || \
defined(__DragonFly__) || (defined(__UCLIBC__) && defined(__UCLIBC_HAS_BACKTRACE__))
#define HAVE_BACKTRACE 1
#endif
@ -98,21 +98,21 @@
#endif
/* Test for accept4() */
#if defined(__linux__) || defined(__FreeBSD__) || defined(OpenBSD5_7) || \
(defined(__DragonFly__) && __DragonFly_version >= 400305) || \
#if defined(__linux__) || defined(__FreeBSD__) || defined(OpenBSD5_7) || \
(defined(__DragonFly__) && __DragonFly_version >= 400305) || \
(defined(__NetBSD__) && (defined(NetBSD8_0) || __NetBSD_Version__ >= 800000000))
#define HAVE_ACCEPT4 1
#endif
/* Detect for pipe2() */
#if defined(__linux__) || defined(__FreeBSD__) || defined(OpenBSD5_7) || \
(defined(__DragonFly__) && __DragonFly_version >= 400106) || \
#if defined(__linux__) || defined(__FreeBSD__) || defined(OpenBSD5_7) || \
(defined(__DragonFly__) && __DragonFly_version >= 400106) || \
(defined(__NetBSD__) && (defined(NetBSD6_0) || __NetBSD_Version__ >= 600000000))
#define HAVE_PIPE2 1
#endif
/* Detect for kqueue */
#if (defined(__APPLE__) && defined(MAC_OS_10_6_DETECTED)) || defined(__DragonFly__) || defined(__FreeBSD__) || \
#if (defined(__APPLE__) && defined(MAC_OS_10_6_DETECTED)) || defined(__DragonFly__) || defined(__FreeBSD__) || \
defined(__OpenBSD__) || defined(__NetBSD__)
#define HAVE_KQUEUE 1
#endif
@ -176,7 +176,7 @@
* the plain fsync() call. */
#if (defined(__linux__) && defined(SYNC_FILE_RANGE_WAIT_BEFORE))
#define HAVE_SYNC_FILE_RANGE 1
#define rdb_fsync_range(fd, off, size) \
#define rdb_fsync_range(fd, off, size) \
sync_file_range(fd, off, size, SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE)
#elif defined(__APPLE__)
#define rdb_fsync_range(fd, off, size) fcntl(fd, F_FULLFSYNC)
@ -216,16 +216,16 @@ void setproctitle(const char *fmt, ...);
#define BIG_ENDIAN 4321 /* most-significant byte first (IBM, net) */
#define PDP_ENDIAN 3412 /* LSB first in word, MSW first in long (pdp)*/
#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || defined(vax) || defined(ns32000) || \
defined(sun386) || defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || defined(__alpha__) || \
#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || defined(vax) || defined(ns32000) || \
defined(sun386) || defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || defined(__alpha__) || \
defined(__alpha)
#define BYTE_ORDER LITTLE_ENDIAN
#endif
#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || defined(is68k) || defined(tahoe) || \
defined(ibm032) || defined(ibm370) || defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) || \
defined(apollo) || defined(__convex__) || defined(_CRAY) || defined(__hppa) || defined(__hp9000) || \
defined(__hp9000s300) || defined(__hp9000s700) || defined(BIT_ZERO_ON_LEFT) || defined(m68k) || \
#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || defined(is68k) || defined(tahoe) || \
defined(ibm032) || defined(ibm370) || defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) || \
defined(apollo) || defined(__convex__) || defined(_CRAY) || defined(__hppa) || defined(__hp9000) || \
defined(__hp9000s300) || defined(__hp9000s700) || defined(BIT_ZERO_ON_LEFT) || defined(m68k) || \
defined(__sparc) || (defined(__APPLE__) && defined(__POWERPC__))
#define BYTE_ORDER BIG_ENDIAN
#endif

34
src/debug.c
View File

@ -1169,20 +1169,20 @@ int bugReportStart(void) {
/* Returns the current eip and set it to the given new value (if its not NULL) */
static void *getAndSetMcontextEip(ucontext_t *uc, void *eip) {
#define NOT_SUPPORTED() \
do { \
UNUSED(uc); \
UNUSED(eip); \
return NULL; \
#define NOT_SUPPORTED() \
do { \
UNUSED(uc); \
UNUSED(eip); \
return NULL; \
} while (0)
#define GET_SET_RETURN(target_var, new_val) \
do { \
void *old_val = (void *)target_var; \
if (new_val) { \
void **temp = (void **)&target_var; \
*temp = new_val; \
} \
return old_val; \
#define GET_SET_RETURN(target_var, new_val) \
do { \
void *old_val = (void *)target_var; \
if (new_val) { \
void **temp = (void **)&target_var; \
*temp = new_val; \
} \
return old_val; \
} while (0)
#if defined(__APPLE__) && !defined(MAC_OS_10_6_DETECTED)
/* OSX < 10.6 */
@ -1284,10 +1284,10 @@ void logStackContent(void **sp) {
/* Log dump of processor registers */
void logRegisters(ucontext_t *uc) {
serverLog(LL_WARNING | LL_RAW, "\n------ REGISTERS ------\n");
#define NOT_SUPPORTED() \
do { \
UNUSED(uc); \
serverLog(LL_WARNING, " Dumping of registers not supported for this OS/arch"); \
#define NOT_SUPPORTED() \
do { \
UNUSED(uc); \
serverLog(LL_WARNING, " Dumping of registers not supported for this OS/arch"); \
} while (0)
/* OSX */

14
src/debugmacro.h
View File

@ -34,13 +34,13 @@
#define _REDIS_DEBUGMACRO_H_
#include <stdio.h>
#define D(...) \
do { \
FILE *fp = fopen("/tmp/log.txt", "a"); \
fprintf(fp, "%s:%s:%d:\t", __FILE__, __func__, __LINE__); \
fprintf(fp, __VA_ARGS__); \
fprintf(fp, "\n"); \
fclose(fp); \
#define D(...) \
do { \
FILE *fp = fopen("/tmp/log.txt", "a"); \
fprintf(fp, "%s:%s:%d:\t", __FILE__, __func__, __LINE__); \
fprintf(fp, __VA_ARGS__); \
fprintf(fp, "\n"); \
fclose(fp); \
} while (0)
#endif /* _REDIS_DEBUGMACRO_H_ */

56
src/dict.c
View File

@ -885,37 +885,37 @@ void dictTwoPhaseUnlinkFree(dict *d, dictEntry *he, dictEntry **plink, int table
}
/* In the macros below, `de` stands for dict entry. */
#define DICT_SET_VALUE(de, field, val) \
{ \
if (entryIsNormal(de)) { \
dictEntryNormal *_de = decodeEntryNormal(de); \
_de->field = val; \
} else if (entryIsEmbedded(de)) { \
dictEntryEmbedded *_de = decodeEntryEmbedded(de); \
_de->field = val; \
} else { \
panic("Entry type not supported"); \
} \
#define DICT_SET_VALUE(de, field, val) \
{ \
if (entryIsNormal(de)) { \
dictEntryNormal *_de = decodeEntryNormal(de); \
_de->field = val; \
} else if (entryIsEmbedded(de)) { \
dictEntryEmbedded *_de = decodeEntryEmbedded(de); \
_de->field = val; \
} else { \
panic("Entry type not supported"); \
} \
}
#define DICT_INCR_VALUE(de, field, val) \
{ \
if (entryIsNormal(de)) { \
dictEntryNormal *_de = decodeEntryNormal(de); \
_de->field += val; \
} else if (entryIsEmbedded(de)) { \
dictEntryEmbedded *_de = decodeEntryEmbedded(de); \
_de->field += val; \
} else { \
panic("Entry type not supported"); \
} \
#define DICT_INCR_VALUE(de, field, val) \
{ \
if (entryIsNormal(de)) { \
dictEntryNormal *_de = decodeEntryNormal(de); \
_de->field += val; \
} else if (entryIsEmbedded(de)) { \
dictEntryEmbedded *_de = decodeEntryEmbedded(de); \
_de->field += val; \
} else { \
panic("Entry type not supported"); \
} \
}
#define DICT_GET_VALUE(de, field) \
(entryIsNormal(de) ? decodeEntryNormal(de)->field \
: (entryIsEmbedded(de) ? decodeEntryEmbedded(de)->field \
#define DICT_GET_VALUE(de, field) \
(entryIsNormal(de) ? decodeEntryNormal(de)->field \
: (entryIsEmbedded(de) ? decodeEntryEmbedded(de)->field \
: (panic("Entry type not supported"), ((dictEntryNormal *)de)->field)))
#define DICT_GET_VALUE_PTR(de, field) \
(entryIsNormal(de) \
? &decodeEntryNormal(de)->field \
#define DICT_GET_VALUE_PTR(de, field) \
(entryIsNormal(de) \
? &decodeEntryNormal(de)->field \
: (entryIsEmbedded(de) ? &decodeEntryEmbedded(de)->field : (panic("Entry type not supported"), NULL)))
void dictSetKey(dict *d, dictEntry *de, void *key) {

10
src/dict.h
View File

@ -144,15 +144,15 @@ typedef struct {
#define DICT_HT_INITIAL_SIZE (1 << (DICT_HT_INITIAL_EXP))
/* ------------------------------- Macros ------------------------------------*/
#define dictFreeVal(d, entry) \
do { \
if ((d)->type->valDestructor) (d)->type->valDestructor((d), dictGetVal(entry)); \
#define dictFreeVal(d, entry) \
do { \
if ((d)->type->valDestructor) (d)->type->valDestructor((d), dictGetVal(entry)); \
} while (0)
#define dictFreeKey(d, entry) \
#define dictFreeKey(d, entry) \
if ((d)->type->keyDestructor) (d)->type->keyDestructor((d), dictGetKey(entry))
#define dictCompareKeys(d, key1, key2) \
#define dictCompareKeys(d, key1, key2) \
(((d)->type->keyCompare) ? (d)->type->keyCompare((d), key1, key2) : (key1) == (key2))
#define dictMetadata(d) (&(d)->metadata)

36
src/eval.c
View File

@ -667,27 +667,25 @@ void evalShaRoCommand(client *c) {
void scriptCommand(client *c) {
if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr, "help")) {
/* clang-format off */
const char *help[] = {
"DEBUG (YES|SYNC|NO)",
" Set the debug mode for subsequent scripts executed.",
"EXISTS <sha1> [<sha1> ...]",
" Return information about the existence of the scripts in the script cache.",
"FLUSH [ASYNC|SYNC]",
" Flush the Lua scripts cache. Very dangerous on replicas.",
" When called without the optional mode argument, the behavior is determined",
" by the lazyfree-lazy-user-flush configuration directive. Valid modes are:",
" * ASYNC: Asynchronously flush the scripts cache.",
" * SYNC: Synchronously flush the scripts cache.",
"KILL",
" Kill the currently executing Lua script.",
"LOAD <script>",
" Load a script into the scripts cache without executing it.",
"SHOW <sha1>",
" Show a script from the scripts cache.",
NULL
"DEBUG (YES|SYNC|NO)",
" Set the debug mode for subsequent scripts executed.",
"EXISTS <sha1> [<sha1> ...]",
" Return information about the existence of the scripts in the script cache.",
"FLUSH [ASYNC|SYNC]",
" Flush the Lua scripts cache. Very dangerous on replicas.",
" When called without the optional mode argument, the behavior is determined",
" by the lazyfree-lazy-user-flush configuration directive. Valid modes are:",
" * ASYNC: Asynchronously flush the scripts cache.",
" * SYNC: Synchronously flush the scripts cache.",
"KILL",
" Kill the currently executing Lua script.",
"LOAD <script>",
" Load a script into the scripts cache without executing it.",
"SHOW <sha1>",
" Show a script from the scripts cache.",
NULL,
};
/* clang-format on */
addReplyHelp(c, help);
} else if (c->argc >= 2 && !strcasecmp(c->argv[1]->ptr, "flush")) {
int async = 0;

13
src/expire.c
View File

@ -42,7 +42,7 @@
/* Constants table from pow(0.98, 1) to pow(0.98, 16).
* Help calculating the db->avg_ttl. */
static double avg_ttl_factor[16] = {0.98, 0.9604, 0.941192, 0.922368, 0.903921, 0.885842, 0.868126, 0.850763,
static double avg_ttl_factor[16] = {0.98, 0.9604, 0.941192, 0.922368, 0.903921, 0.885842, 0.868126, 0.850763,
0.833748, 0.817073, 0.800731, 0.784717, 0.769022, 0.753642, 0.738569, 0.723798};
/* Helper function for the activeExpireCycle() function.
@ -111,12 +111,11 @@ int activeExpireCycleTryExpire(serverDb *db, dictEntry *de, long long now) {
* order to do more work in both the fast and slow expire cycles.
*/
#define ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP 20 /* Keys for each DB loop. */
#define ACTIVE_EXPIRE_CYCLE_FAST_DURATION 1000 /* Microseconds. */
#define ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 /* Max % of CPU to use. */
#define ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE \
10 /* % of stale keys after which \
we do extra efforts. */
#define ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP 20 /* Keys for each DB loop. */
#define ACTIVE_EXPIRE_CYCLE_FAST_DURATION 1000 /* Microseconds. */
#define ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 /* Max % of CPU to use. */
#define ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE 10 /* % of stale keys after which \
we do extra efforts. */
/* Data used by the expire dict scan callback. */
typedef struct {

83
src/functions.c
View File

@ -34,7 +34,11 @@
#define LOAD_TIMEOUT_MS 500
typedef enum { restorePolicy_Flush, restorePolicy_Append, restorePolicy_Replace } restorePolicy;
typedef enum {
restorePolicy_Flush,
restorePolicy_Append,
restorePolicy_Replace
} restorePolicy;
static size_t engine_cache_memory = 0;
@ -819,46 +823,45 @@ void functionFlushCommand(client *c) {
/* FUNCTION HELP */
void functionHelpCommand(client *c) {
/* clang-format off */
const char *help[] = {
"LOAD [REPLACE] <FUNCTION CODE>",
" Create a new library with the given library name and code.",
"DELETE <LIBRARY NAME>",
" Delete the given library.",
"LIST [LIBRARYNAME PATTERN] [WITHCODE]",
" Return general information on all the libraries:",
" * Library name",
" * The engine used to run the Library",
" * Functions list",
" * Library code (if WITHCODE is given)",
" It also possible to get only function that matches a pattern using LIBRARYNAME argument.",
"STATS",
" Return information about the current function running:",
" * Function name",
" * Command used to run the function",
" * Duration in MS that the function is running",
" If no function is running, return nil",
" In addition, returns a list of available engines.",
"KILL",
" Kill the current running function.",
"FLUSH [ASYNC|SYNC]",
" Delete all the libraries.",
" When called without the optional mode argument, the behavior is determined by the",
" lazyfree-lazy-user-flush configuration directive. Valid modes are:",
" * ASYNC: Asynchronously flush the libraries.",
" * SYNC: Synchronously flush the libraries.",
"DUMP",
" Return a serialized payload representing the current libraries, can be restored using FUNCTION RESTORE command",
"RESTORE <PAYLOAD> [FLUSH|APPEND|REPLACE]",
" Restore the libraries represented by the given payload, it is possible to give a restore policy to",
" control how to handle existing libraries (default APPEND):",
" * FLUSH: delete all existing libraries.",
" * APPEND: appends the restored libraries to the existing libraries. On collision, abort.",
" * REPLACE: appends the restored libraries to the existing libraries, On collision, replace the old",
" libraries with the new libraries (notice that even on this option there is a chance of failure",
" in case of functions name collision with another library).",
NULL };
/* clang-format on */
"LOAD [REPLACE] <FUNCTION CODE>",
" Create a new library with the given library name and code.",
"DELETE <LIBRARY NAME>",
" Delete the given library.",
"LIST [LIBRARYNAME PATTERN] [WITHCODE]",
" Return general information on all the libraries:",
" * Library name",
" * The engine used to run the Library",
" * Functions list",
" * Library code (if WITHCODE is given)",
" It also possible to get only function that matches a pattern using LIBRARYNAME argument.",
"STATS",
" Return information about the current function running:",
" * Function name",
" * Command used to run the function",
" * Duration in MS that the function is running",
" If no function is running, return nil",
" In addition, returns a list of available engines.",
"KILL",
" Kill the current running function.",
"FLUSH [ASYNC|SYNC]",
" Delete all the libraries.",
" When called without the optional mode argument, the behavior is determined by the",
" lazyfree-lazy-user-flush configuration directive. Valid modes are:",
" * ASYNC: Asynchronously flush the libraries.",
" * SYNC: Synchronously flush the libraries.",
"DUMP",
" Return a serialized payload representing the current libraries, can be restored using FUNCTION RESTORE command",
"RESTORE <PAYLOAD> [FLUSH|APPEND|REPLACE]",
" Restore the libraries represented by the given payload, it is possible to give a restore policy to",
" control how to handle existing libraries (default APPEND):",
" * FLUSH: delete all existing libraries.",
" * APPEND: appends the restored libraries to the existing libraries. On collision, abort.",
" * REPLACE: appends the restored libraries to the existing libraries, On collision, replace the old",
" libraries with the new libraries (notice that even on this option there is a chance of failure",
" in case of functions name collision with another library).",
NULL,
};
addReplyHelp(c, help);
}

67
src/hyperloglog.c
View File

@ -192,9 +192,8 @@ struct hllhdr {
#define HLL_INVALIDATE_CACHE(hdr) (hdr)->card[7] |= (1 << 7)
#define HLL_VALID_CACHE(hdr) (((hdr)->card[7] & (1 << 7)) == 0)
#define HLL_P 14 /* The greater is P, the smaller the error. */
#define HLL_Q \
(64 - HLL_P) /* The number of bits of the hash value used for \
#define HLL_P 14 /* The greater is P, the smaller the error. */
#define HLL_Q (64 - HLL_P) /* The number of bits of the hash value used for \
determining the number of leading zeros. */
#define HLL_REGISTERS (1 << HLL_P) /* With P=14, 16384 registers. */
#define HLL_P_MASK (HLL_REGISTERS - 1) /* Mask to index register. */
@ -338,30 +337,30 @@ static char *invalid_hll_err = "-INVALIDOBJ Corrupted HLL object detected";
/* Store the value of the register at position 'regnum' into variable 'target'.
* 'p' is an array of unsigned bytes. */
#define HLL_DENSE_GET_REGISTER(target, p, regnum) \
do { \
uint8_t *_p = (uint8_t *)p; \
unsigned long _byte = regnum * HLL_BITS / 8; \
unsigned long _fb = regnum * HLL_BITS & 7; \
unsigned long _fb8 = 8 - _fb; \
unsigned long b0 = _p[_byte]; \
unsigned long b1 = _p[_byte + 1]; \
target = ((b0 >> _fb) | (b1 << _fb8)) & HLL_REGISTER_MAX; \
#define HLL_DENSE_GET_REGISTER(target, p, regnum) \
do { \
uint8_t *_p = (uint8_t *)p; \
unsigned long _byte = regnum * HLL_BITS / 8; \
unsigned long _fb = regnum * HLL_BITS & 7; \
unsigned long _fb8 = 8 - _fb; \
unsigned long b0 = _p[_byte]; \
unsigned long b1 = _p[_byte + 1]; \
target = ((b0 >> _fb) | (b1 << _fb8)) & HLL_REGISTER_MAX; \
} while (0)
/* Set the value of the register at position 'regnum' to 'val'.
* 'p' is an array of unsigned bytes. */
#define HLL_DENSE_SET_REGISTER(p, regnum, val) \
do { \
uint8_t *_p = (uint8_t *)p; \
unsigned long _byte = (regnum) * HLL_BITS / 8; \
unsigned long _fb = (regnum) * HLL_BITS & 7; \
unsigned long _fb8 = 8 - _fb; \
unsigned long _v = (val); \
_p[_byte] &= ~(HLL_REGISTER_MAX << _fb); \
_p[_byte] |= _v << _fb; \
_p[_byte + 1] &= ~(HLL_REGISTER_MAX >> _fb8); \
_p[_byte + 1] |= _v >> _fb8; \
#define HLL_DENSE_SET_REGISTER(p, regnum, val) \
do { \
uint8_t *_p = (uint8_t *)p; \
unsigned long _byte = (regnum) * HLL_BITS / 8; \
unsigned long _fb = (regnum) * HLL_BITS & 7; \
unsigned long _fb8 = 8 - _fb; \
unsigned long _v = (val); \
_p[_byte] &= ~(HLL_REGISTER_MAX << _fb); \
_p[_byte] |= _v << _fb; \
_p[_byte + 1] &= ~(HLL_REGISTER_MAX >> _fb8); \
_p[_byte + 1] |= _v >> _fb8; \
} while (0)
/* Macros to access the sparse representation.
@ -379,19 +378,19 @@ static char *invalid_hll_err = "-INVALIDOBJ Corrupted HLL object detected";
#define HLL_SPARSE_VAL_MAX_LEN 4
#define HLL_SPARSE_ZERO_MAX_LEN 64
#define HLL_SPARSE_XZERO_MAX_LEN 16384
#define HLL_SPARSE_VAL_SET(p, val, len) \
do { \
*(p) = (((val) - 1) << 2 | ((len) - 1)) | HLL_SPARSE_VAL_BIT; \
#define HLL_SPARSE_VAL_SET(p, val, len) \
do { \
*(p) = (((val) - 1) << 2 | ((len) - 1)) | HLL_SPARSE_VAL_BIT; \
} while (0)
#define HLL_SPARSE_ZERO_SET(p, len) \
do { \
*(p) = (len) - 1; \
#define HLL_SPARSE_ZERO_SET(p, len) \
do { \
*(p) = (len) - 1; \
} while (0)
#define HLL_SPARSE_XZERO_SET(p, len) \
do { \
int _l = (len) - 1; \
*(p) = (_l >> 8) | HLL_SPARSE_XZERO_BIT; \
*((p) + 1) = (_l & 0xff); \
#define HLL_SPARSE_XZERO_SET(p, len) \
do { \
int _l = (len) - 1; \
*(p) = (_l >> 8) | HLL_SPARSE_XZERO_BIT; \
*((p) + 1) = (_l & 0xff); \
} while (0)
#define HLL_ALPHA_INF 0.721347520444481703680 /* constant for 0.5/ln(2) */

11
src/kvstore.c
View File

@ -56,10 +56,10 @@ struct _kvstore {
dict **dicts;
long long num_dicts;
long long num_dicts_bits;
list *rehashing; /* List of dictionaries in this kvstore that are currently rehashing. */
int resize_cursor; /* Cron job uses this cursor to gradually resize dictionaries (only used if num_dicts > 1). */
int allocated_dicts; /* The number of allocated dicts. */
int non_empty_dicts; /* The number of non-empty dicts. */
list *rehashing; /* List of dictionaries in this kvstore that are currently rehashing. */
int resize_cursor; /* Cron job uses this cursor to gradually resize dictionaries (only used if num_dicts > 1). */
int allocated_dicts; /* The number of allocated dicts. */
int non_empty_dicts; /* The number of non-empty dicts. */
unsigned long long key_count; /* Total number of keys in this kvstore. */
unsigned long long bucket_count; /* Total number of buckets in this kvstore across dictionaries. */
unsigned long long *dict_size_index; /* Binary indexed tree (BIT) that describes cumulative key frequencies up until
@ -145,7 +145,8 @@ static void cumulativeKeyCountAdd(kvstore *kvs, int didx, long delta) {
dict *d = kvstoreGetDict(kvs, didx);
size_t dsize = dictSize(d);
int non_empty_dicts_delta = dsize == 1 ? 1 : dsize == 0 ? -1 : 0;
int non_empty_dicts_delta = dsize == 1 ? 1 : dsize == 0 ? -1
: 0;
kvs->non_empty_dicts += non_empty_dicts_delta;
/* BIT does not need to be calculated when there's only one dict. */

32
src/latency.c
View File

@ -731,25 +731,23 @@ void latencyCommand(client *c) {
latencySpecificCommandsFillCDF(c);
}
} else if (!strcasecmp(c->argv[1]->ptr, "help") && c->argc == 2) {
/* clang-format off */
const char *help[] = {
"DOCTOR",
" Return a human readable latency analysis report.",
"GRAPH <event>",
" Return an ASCII latency graph for the <event> class.",
"HISTORY <event>",
" Return time-latency samples for the <event> class.",
"LATEST",
" Return the latest latency samples for all events.",
"RESET [<event> ...]",
" Reset latency data of one or more <event> classes.",
" (default: reset all data for all event classes)",
"HISTOGRAM [COMMAND ...]",
" Return a cumulative distribution of latencies in the format of a histogram for the specified command names.",
" If no commands are specified then all histograms are replied.",
NULL
"DOCTOR",
" Return a human readable latency analysis report.",
"GRAPH <event>",
" Return an ASCII latency graph for the <event> class.",
"HISTORY <event>",
" Return time-latency samples for the <event> class.",
"LATEST",
" Return the latest latency samples for all events.",
"RESET [<event> ...]",
" Reset latency data of one or more <event> classes.",
" (default: reset all data for all event classes)",
"HISTOGRAM [COMMAND ...]",
" Return a cumulative distribution of latencies in the format of a histogram for the specified command names.",
" If no commands are specified then all histograms are replied.",
NULL,
};
/* clang-format on */
addReplyHelp(c, help);
} else {
addReplySubcommandSyntaxError(c);

22
src/latency.h
View File

@ -67,22 +67,22 @@ void latencyAddSample(const char *event, mstime_t latency);
/* Latency monitoring macros. */
/* Start monitoring an event. We just set the current time. */
#define latencyStartMonitor(var) \
if (server.latency_monitor_threshold) { \
var = mstime(); \
} else { \
var = 0; \
#define latencyStartMonitor(var) \
if (server.latency_monitor_threshold) { \
var = mstime(); \
} else { \
var = 0; \
}
/* End monitoring an event, compute the difference with the current time
* to check the amount of time elapsed. */
#define latencyEndMonitor(var) \
if (server.latency_monitor_threshold) { \
var = mstime() - var; \
#define latencyEndMonitor(var) \
if (server.latency_monitor_threshold) { \
var = mstime() - var; \
}
/* Add the sample only if the elapsed time is >= to the configured threshold. */
#define latencyAddSampleIfNeeded(event, var) \
#define latencyAddSampleIfNeeded(event, var) \
if (server.latency_monitor_threshold && (var) >= server.latency_monitor_threshold) latencyAddSample((event), (var));
/* Remove time from a nested event. */
@ -98,8 +98,8 @@ typedef enum {
EL_DURATION_TYPE_EL = 0, // cumulative time duration metric of the whole eventloop
EL_DURATION_TYPE_CMD, // cumulative time duration metric of executing commands
EL_DURATION_TYPE_AOF, // cumulative time duration metric of flushing AOF in eventloop
EL_DURATION_TYPE_CRON, // cumulative time duration metric of cron (serverCron and beforeSleep, but excluding IO and
// AOF)
EL_DURATION_TYPE_CRON, // cumulative time duration metric of cron (serverCron and beforeSleep, but excluding IO and
// AOF)
EL_DURATION_TYPE_NUM
} DurationType;

36
src/listpack.c
View File

@ -97,25 +97,25 @@
#define LP_ENCODING_6BIT_STR_LEN(p) ((p)[0] & 0x3F)
#define LP_ENCODING_12BIT_STR_LEN(p) ((((p)[0] & 0xF) << 8) | (p)[1])
#define LP_ENCODING_32BIT_STR_LEN(p) \
#define LP_ENCODING_32BIT_STR_LEN(p) \
(((uint32_t)(p)[1] << 0) | ((uint32_t)(p)[2] << 8) | ((uint32_t)(p)[3] << 16) | ((uint32_t)(p)[4] << 24))
#define lpGetTotalBytes(p) \
#define lpGetTotalBytes(p) \
(((uint32_t)(p)[0] << 0) | ((uint32_t)(p)[1] << 8) | ((uint32_t)(p)[2] << 16) | ((uint32_t)(p)[3] << 24))
#define lpGetNumElements(p) (((uint32_t)(p)[4] << 0) | ((uint32_t)(p)[5] << 8))
#define lpSetTotalBytes(p, v) \
do { \
(p)[0] = (v) & 0xff; \
(p)[1] = ((v) >> 8) & 0xff; \
(p)[2] = ((v) >> 16) & 0xff; \
(p)[3] = ((v) >> 24) & 0xff; \
#define lpSetTotalBytes(p, v) \
do { \
(p)[0] = (v) & 0xff; \
(p)[1] = ((v) >> 8) & 0xff; \
(p)[2] = ((v) >> 16) & 0xff; \
(p)[3] = ((v) >> 24) & 0xff; \
} while (0)
#define lpSetNumElements(p, v) \
do { \
(p)[4] = (v) & 0xff; \
(p)[5] = ((v) >> 8) & 0xff; \
#define lpSetNumElements(p, v) \
do { \
(p)[4] = (v) & 0xff; \
(p)[5] = ((v) >> 8) & 0xff; \
} while (0)
/* Validates that 'p' is not outside the listpack.
@ -123,16 +123,16 @@
* that this element is valid, so it can be freely used.
* Generally functions such lpNext and lpDelete assume the input pointer is
* already validated (since it's the return value of another function). */
#define ASSERT_INTEGRITY(lp, p) \
do { \
assert((p) >= (lp) + LP_HDR_SIZE && (p) < (lp) + lpGetTotalBytes((lp))); \
#define ASSERT_INTEGRITY(lp, p) \
do { \
assert((p) >= (lp) + LP_HDR_SIZE && (p) < (lp) + lpGetTotalBytes((lp))); \
} while (0)
/* Similar to the above, but validates the entire element length rather than just
* it's pointer. */
#define ASSERT_INTEGRITY_LEN(lp, p, len) \
do { \
assert((p) >= (lp) + LP_HDR_SIZE && (p) + (len) < (lp) + lpGetTotalBytes((lp))); \
#define ASSERT_INTEGRITY_LEN(lp, p, len) \
do { \
assert((p) >= (lp) + LP_HDR_SIZE && (p) + (len) < (lp) + lpGetTotalBytes((lp))); \
} while (0)
static inline void lpAssertValidEntry(unsigned char *lp, size_t lpbytes, unsigned char *p);

6
src/memory_prefetch.c
View File

@ -17,7 +17,11 @@ dictEntry *dictGetNext(const dictEntry *de);
/* Forward declarations of kvstore.c functions */
dict *kvstoreGetDict(kvstore *kvs, int didx);
typedef enum { HT_IDX_FIRST = 0, HT_IDX_SECOND = 1, HT_IDX_INVALID = -1 } HashTableIndex;
typedef enum {
HT_IDX_FIRST = 0,
HT_IDX_SECOND = 1,
HT_IDX_INVALID = -1
} HashTableIndex;
typedef enum {
PREFETCH_BUCKET, /* Initial state, determines which hash table to use and prefetch the table's bucket */

12
src/memtest.c
View File

@ -135,12 +135,12 @@ int memtest_addressing(unsigned long *l, size_t bytes, int interactive) {
* In this test we can't call rand() since the system may be completely
* unable to handle library calls, so we have to resort to our own
* PRNG that only uses local state. We use an xorshift* PRNG. */
#define xorshift64star_next() \
do { \
rseed ^= rseed >> 12; \
rseed ^= rseed << 25; \
rseed ^= rseed >> 27; \
rout = rseed * UINT64_C(2685821657736338717); \
#define xorshift64star_next() \
do { \
rseed ^= rseed >> 12; \
rseed ^= rseed << 25; \
rseed ^= rseed >> 27; \
rout = rseed * UINT64_C(2685821657736338717); \
} while (0)
void memtest_fill_random(unsigned long *l, size_t bytes, int interactive) {

26
src/module.c
View File

@ -180,15 +180,12 @@ typedef struct ValkeyModuleCtx ValkeyModuleCtx;
#define VALKEYMODULE_CTX_BLOCKED_TIMEOUT (1 << 3)
#define VALKEYMODULE_CTX_THREAD_SAFE (1 << 4)
#define VALKEYMODULE_CTX_BLOCKED_DISCONNECTED (1 << 5)
#define VALKEYMODULE_CTX_TEMP_CLIENT \
(1 << 6) /* Return client object to the pool \
when the context is destroyed */
#define VALKEYMODULE_CTX_NEW_CLIENT \
(1 << 7) /* Free client object when the \
context is destroyed */
#define VALKEYMODULE_CTX_TEMP_CLIENT (1 << 6) /* Return client object to the pool \
when the context is destroyed */
#define VALKEYMODULE_CTX_NEW_CLIENT (1 << 7) /* Free client object when the \
context is destroyed */
#define VALKEYMODULE_CTX_CHANNELS_POS_REQUEST (1 << 8)
#define VALKEYMODULE_CTX_COMMAND \
(1 << 9) /* Context created to serve a command from call() or AOF (which calls cmd->proc directly) */
#define VALKEYMODULE_CTX_COMMAND (1 << 9) /* Context created to serve a command from call() or AOF (which calls cmd->proc directly) */
/* This represents a key opened with VM_OpenKey(). */
@ -249,9 +246,8 @@ typedef struct ValkeyModuleCommand ValkeyModuleCommand;
#define VALKEYMODULE_REPLYFLAG_NONE 0
#define VALKEYMODULE_REPLYFLAG_TOPARSE (1 << 0) /* Protocol must be parsed. */
#define VALKEYMODULE_REPLYFLAG_NESTED \
(1 << 1) /* Nested reply object. No proto \
or struct free. */
#define VALKEYMODULE_REPLYFLAG_NESTED (1 << 1) /* Nested reply object. No proto \
or struct free. */
/* Reply of VM_Call() function. The function is filled in a lazy
* way depending on the function called on the reply structure. By default
@ -408,7 +404,7 @@ typedef struct ValkeyModuleServerInfoData {
* In case 'ctx' has no 'module' member (and therefore no module->options),
* we assume default behavior, that is, the server signals.
* (see VM_GetThreadSafeContext) */
#define SHOULD_SIGNAL_MODIFIED_KEYS(ctx) \
#define SHOULD_SIGNAL_MODIFIED_KEYS(ctx) \
((ctx)->module ? !((ctx)->module->options & VALKEYMODULE_OPTION_NO_IMPLICIT_SIGNAL_MODIFIED) : 1)
/* Server events hooks data structures and defines: this modules API
@ -5957,7 +5953,7 @@ void VM_CallReplyPromiseSetUnblockHandler(ValkeyModuleCallReply *reply,
int VM_CallReplyPromiseAbort(ValkeyModuleCallReply *reply, void **private_data) {
ValkeyModuleAsyncRMCallPromise *promise = callReplyGetPrivateData(reply);
if (!promise->c)
return VALKEYMODULE_ERR; /* Promise can not be aborted, either already aborted or already finished. */
return VALKEYMODULE_ERR; /* Promise can not be aborted, either already aborted or already finished. */
if (!(promise->c->flag.blocked)) return VALKEYMODULE_ERR; /* Client is not blocked anymore, can not abort it. */
/* Client is still blocked, remove it from any blocking state and release it. */
@ -11837,8 +11833,8 @@ int moduleRegisterApi(const char *funcname, void *funcptr) {
/* Register Module APIs under both RedisModule_ and ValkeyModule_ namespaces
* so that legacy Redis module binaries can continue to function */
#define REGISTER_API(name) \
moduleRegisterApi("ValkeyModule_" #name, (void *)(unsigned long)VM_##name); \
#define REGISTER_API(name) \
moduleRegisterApi("ValkeyModule_" #name, (void *)(unsigned long)VM_##name); \
moduleRegisterApi("RedisModule_" #name, (void *)(unsigned long)VM_##name);
/* Global initialization at server startup. */

204
src/networking.c
View File

@ -50,7 +50,11 @@ char *getClientSockname(client *c);
int ProcessingEventsWhileBlocked = 0; /* See processEventsWhileBlocked(). */
__thread sds thread_shared_qb = NULL;
typedef enum { PARSE_OK = 0, PARSE_ERR = -1, PARSE_NEEDMORE = -2 } parseResult;
typedef enum {
PARSE_OK = 0,
PARSE_ERR = -1,
PARSE_NEEDMORE = -2,
} parseResult;
/* Return the amount of memory used by the sds string at object->ptr
* for a string object. This includes internal fragmentation. */
@ -3267,7 +3271,6 @@ sds catClientInfoString(sds s, client *client, int hide_user_data) {
*p++ = 'S';
}
/* clang-format off */
if (client->flag.primary) *p++ = 'M';
if (client->flag.pubsub) *p++ = 'P';
if (client->flag.multi) *p++ = 'x';
@ -3302,43 +3305,43 @@ sds catClientInfoString(sds s, client *client, int hide_user_data) {
replBufBlock *cur = listNodeValue(client->ref_repl_buf_node);
used_blocks_of_repl_buf = last->id - cur->id + 1;
}
/* clang-format off */
sds ret = sdscatfmt(s, FMTARGS(
"id=%U", (unsigned long long) client->id,
" addr=%s", getClientPeerId(client),
" laddr=%s", getClientSockname(client),
" %s", connGetInfo(client->conn, conninfo, sizeof(conninfo)),
" name=%s", hide_user_data ? "*redacted*" : (client->name ? (char*)client->name->ptr : ""),
" age=%I", (long long)(commandTimeSnapshot() / 1000 - client->ctime),
" idle=%I", (long long)(server.unixtime - client->last_interaction),
" flags=%s", flags,
" db=%i", client->db->id,
" sub=%i", (int) dictSize(client->pubsub_channels),
" psub=%i", (int) dictSize(client->pubsub_patterns),
" ssub=%i", (int) dictSize(client->pubsubshard_channels),
" multi=%i", (client->flag.multi) ? client->mstate.count : -1,
" watch=%i", (int) listLength(client->watched_keys),
" qbuf=%U", client->querybuf ? (unsigned long long) sdslen(client->querybuf) : 0,
" qbuf-free=%U", client->querybuf ? (unsigned long long) sdsavail(client->querybuf) : 0,
" argv-mem=%U", (unsigned long long) client->argv_len_sum,
" multi-mem=%U", (unsigned long long) client->mstate.argv_len_sums,
" rbs=%U", (unsigned long long) client->buf_usable_size,
" rbp=%U", (unsigned long long) client->buf_peak,
" obl=%U", (unsigned long long) client->bufpos,
" oll=%U", (unsigned long long) listLength(client->reply) + used_blocks_of_repl_buf,
" omem=%U", (unsigned long long) obufmem, /* should not include client->buf since we want to see 0 for static clients. */
" tot-mem=%U", (unsigned long long) total_mem,
" events=%s", events,
" cmd=%s", client->lastcmd ? client->lastcmd->fullname : "NULL",
" user=%s", hide_user_data ? "*redacted*" : (client->user ? client->user->name : "(superuser)"),
" redir=%I", (client->flag.tracking) ? (long long) client->client_tracking_redirection : -1,
" resp=%i", client->resp,
" lib-name=%s", client->lib_name ? (char*)client->lib_name->ptr : "",
" lib-ver=%s", client->lib_ver ? (char*)client->lib_ver->ptr : "",
" tot-net-in=%U", client->net_input_bytes,
" tot-net-out=%U", client->net_output_bytes,
" tot-cmds=%U", client->commands_processed));
/* clang-format on */
sds ret = sdscatfmt(
s,
FMTARGS(
"id=%U", (unsigned long long)client->id,
" addr=%s", getClientPeerId(client),
" laddr=%s", getClientSockname(client),
" %s", connGetInfo(client->conn, conninfo, sizeof(conninfo)),
" name=%s", hide_user_data ? "*redacted*" : (client->name ? (char *)client->name->ptr : ""),
" age=%I", (long long)(commandTimeSnapshot() / 1000 - client->ctime),
" idle=%I", (long long)(server.unixtime - client->last_interaction),
" flags=%s", flags,
" db=%i", client->db->id,
" sub=%i", (int)dictSize(client->pubsub_channels),
" psub=%i", (int)dictSize(client->pubsub_patterns),
" ssub=%i", (int)dictSize(client->pubsubshard_channels),
" multi=%i", (client->flag.multi) ? client->mstate.count : -1,
" watch=%i", (int)listLength(client->watched_keys),
" qbuf=%U", client->querybuf ? (unsigned long long)sdslen(client->querybuf) : 0,
" qbuf-free=%U", client->querybuf ? (unsigned long long)sdsavail(client->querybuf) : 0,
" argv-mem=%U", (unsigned long long)client->argv_len_sum,
" multi-mem=%U", (unsigned long long)client->mstate.argv_len_sums,
" rbs=%U", (unsigned long long)client->buf_usable_size,
" rbp=%U", (unsigned long long)client->buf_peak,
" obl=%U", (unsigned long long)client->bufpos,
" oll=%U", (unsigned long long)listLength(client->reply) + used_blocks_of_repl_buf,
" omem=%U", (unsigned long long)obufmem, /* should not include client->buf since we want to see 0 for static clients. */
" tot-mem=%U", (unsigned long long)total_mem,
" events=%s", events,
" cmd=%s", client->lastcmd ? client->lastcmd->fullname : "NULL",
" user=%s", hide_user_data ? "*redacted*" : (client->user ? client->user->name : "(superuser)"),
" redir=%I", (client->flag.tracking) ? (long long)client->client_tracking_redirection : -1,
" resp=%i", client->resp,
" lib-name=%s", client->lib_name ? (char *)client->lib_name->ptr : "",
" lib-ver=%s", client->lib_ver ? (char *)client->lib_ver->ptr : "",
" tot-net-in=%U", client->net_input_bytes,
" tot-net-out=%U", client->net_output_bytes,
" tot-cmds=%U", client->commands_processed));
return ret;
}
@ -3482,70 +3485,67 @@ void clientCommand(client *c) {
listIter li;
if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr, "help")) {
/* clang-format off */
const char *help[] = {
"CACHING (YES|NO)",
" Enable/disable tracking of the keys for next command in OPTIN/OPTOUT modes.",
"CAPA <option> [options...]",
" The client claims its some capability options. Options are:",
" * REDIRECT",
" The client can handle redirection during primary and replica failover in standalone mode.",
"GETREDIR",
" Return the client ID we are redirecting to when tracking is enabled.",
"GETNAME",
" Return the name of the current connection.",
"ID",
" Return the ID of the current connection.",
"INFO",
" Return information about the current client connection.",
"KILL <ip:port>",
" Kill connection made from <ip:port>.",
"KILL <option> <value> [<option> <value> [...]]",
" Kill connections. Options are:",
" * ADDR (<ip:port>|<unixsocket>:0)",
" Kill connections made from the specified address",
" * LADDR (<ip:port>|<unixsocket>:0)",
" Kill connections made to specified local address",
" * TYPE (NORMAL|PRIMARY|REPLICA|PUBSUB)",
" Kill connections by type.",
" * USER <username>",
" Kill connections authenticated by <username>.",
" * SKIPME (YES|NO)",
" Skip killing current connection (default: yes).",
" * ID <client-id>",
" Kill connections by client id.",
" * MAXAGE <maxage>",
" Kill connections older than the specified age.",
"LIST [options ...]",
" Return information about client connections. Options:",
" * TYPE (NORMAL|PRIMARY|REPLICA|PUBSUB)",
" Return clients of specified type.",
"UNPAUSE",
" Stop the current client pause, resuming traffic.",
"PAUSE <timeout> [WRITE|ALL]",
" Suspend all, or just write, clients for <timeout> milliseconds.",
"REPLY (ON|OFF|SKIP)",
" Control the replies sent to the current connection.",
"SETNAME <name>",
" Assign the name <name> to the current connection.",
"SETINFO <option> <value>",
" Set client meta attr. Options are:",
" * LIB-NAME: the client lib name.",
" * LIB-VER: the client lib version.",
"UNBLOCK <clientid> [TIMEOUT|ERROR]",
" Unblock the specified blocked client.",
"TRACKING (ON|OFF) [REDIRECT <id>] [BCAST] [PREFIX <prefix> [...]]",
" [OPTIN] [OPTOUT] [NOLOOP]",
" Control server assisted client side caching.",
"TRACKINGINFO",
" Report tracking status for the current connection.",
"NO-EVICT (ON|OFF)",
" Protect current client connection from eviction.",
"NO-TOUCH (ON|OFF)",
" Will not touch LRU/LFU stats when this mode is on.",
NULL
};
/* clang-format on */
"CACHING (YES|NO)",
" Enable/disable tracking of the keys for next command in OPTIN/OPTOUT modes.",
"CAPA <option> [options...]",
" The client claims its some capability options. Options are:",
" * REDIRECT",
" The client can handle redirection during primary and replica failover in standalone mode.",
"GETREDIR",
" Return the client ID we are redirecting to when tracking is enabled.",
"GETNAME",
" Return the name of the current connection.",
"ID",
" Return the ID of the current connection.",
"INFO",
" Return information about the current client connection.",
"KILL <ip:port>",
" Kill connection made from <ip:port>.",
"KILL <option> <value> [<option> <value> [...]]",
" Kill connections. Options are:",
" * ADDR (<ip:port>|<unixsocket>:0)",
" Kill connections made from the specified address",
" * LADDR (<ip:port>|<unixsocket>:0)",
" Kill connections made to specified local address",
" * TYPE (NORMAL|PRIMARY|REPLICA|PUBSUB)",
" Kill connections by type.",
" * USER <username>",
" Kill connections authenticated by <username>.",
" * SKIPME (YES|NO)",
" Skip killing current connection (default: yes).",
" * ID <client-id>",
" Kill connections by client id.",
" * MAXAGE <maxage>",
" Kill connections older than the specified age.",
"LIST [options ...]",
" Return information about client connections. Options:",
" * TYPE (NORMAL|PRIMARY|REPLICA|PUBSUB)",
" Return clients of specified type.",
"UNPAUSE",
" Stop the current client pause, resuming traffic.",
"PAUSE <timeout> [WRITE|ALL]",
" Suspend all, or just write, clients for <timeout> milliseconds.",
"REPLY (ON|OFF|SKIP)",
" Control the replies sent to the current connection.",
"SETNAME <name>",
" Assign the name <name> to the current connection.",
"SETINFO <option> <value>",
" Set client meta attr. Options are:",
" * LIB-NAME: the client lib name.",
" * LIB-VER: the client lib version.",
"UNBLOCK <clientid> [TIMEOUT|ERROR]",
" Unblock the specified blocked client.",
"TRACKING (ON|OFF) [REDIRECT <id>] [BCAST] [PREFIX <prefix> [...]]",
" [OPTIN] [OPTOUT] [NOLOOP]",
" Control server assisted client side caching.",
"TRACKINGINFO",
" Report tracking status for the current connection.",
"NO-EVICT (ON|OFF)",
" Protect current client connection from eviction.",
"NO-TOUCH (ON|OFF)",
" Will not touch LRU/LFU stats when this mode is on.",
NULL};
addReplyHelp(c, help);
} else if (!strcasecmp(c->argv[1]->ptr, "id") && c->argc == 2) {
/* CLIENT ID */

26
src/object.c
View File

@ -1522,22 +1522,20 @@ void objectCommand(client *c) {
* Usage: MEMORY usage <key> */
void memoryCommand(client *c) {
if (!strcasecmp(c->argv[1]->ptr, "help") && c->argc == 2) {
/* clang-format off */
const char *help[] = {
"DOCTOR",
" Return memory problems reports.",
"MALLOC-STATS",
" Return internal statistics report from the memory allocator.",
"PURGE",
" Attempt to purge dirty pages for reclamation by the allocator.",
"STATS",
" Return information about the memory usage of the server.",
"USAGE <key> [SAMPLES <count>]",
" Return memory in bytes used by <key> and its value. Nested values are",
" sampled up to <count> times (default: 5, 0 means sample all).",
NULL
"DOCTOR",
" Return memory problems reports.",
"MALLOC-STATS",
" Return internal statistics report from the memory allocator.",
"PURGE",
" Attempt to purge dirty pages for reclamation by the allocator.",
"STATS",
" Return information about the memory usage of the server.",
"USAGE <key> [SAMPLES <count>]",
" Return memory in bytes used by <key> and its value. Nested values are",
" sampled up to <count> times (default: 5, 0 means sample all).",
NULL,
};
/* clang-format on */
addReplyHelp(c, help);
} else if (!strcasecmp(c->argv[1]->ptr, "usage") && c->argc >= 3) {
dictEntry *de;

126
src/quicklist.c
View File

@ -82,11 +82,11 @@ int quicklistSetPackedThreshold(size_t sz) {
#ifndef REDIS_TEST_VERBOSE
#define D(...)
#else
#define D(...) \
do { \
printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__); \
printf(__VA_ARGS__); \
printf("\n"); \
#define D(...) \
do { \
printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__); \
printf(__VA_ARGS__); \
printf("\n"); \
} while (0)
#endif
@ -100,22 +100,22 @@ static quicklistNode *_quicklistSplitNode(quicklistNode *node, int offset, int a
static quicklistNode *_quicklistMergeNodes(quicklist *quicklist, quicklistNode *center);
/* Simple way to give quicklistEntry structs default values with one call. */
#define initEntry(e) \
do { \
(e)->zi = (e)->value = NULL; \
(e)->longval = -123456789; \
(e)->quicklist = NULL; \
(e)->node = NULL; \
(e)->offset = 123456789; \
(e)->sz = 0; \
#define initEntry(e) \
do { \
(e)->zi = (e)->value = NULL; \
(e)->longval = -123456789; \
(e)->quicklist = NULL; \
(e)->node = NULL; \
(e)->offset = 123456789; \
(e)->sz = 0; \
} while (0)
/* Reset the quicklistIter to prevent it from being used again after
* insert, replace, or other against quicklist operation. */
#define resetIterator(iter) \
do { \
(iter)->current = NULL; \
(iter)->zi = NULL; \
#define resetIterator(iter) \
do { \
(iter)->current = NULL; \
(iter)->zi = NULL; \
} while (0)
/* Create a new quicklist.
@ -240,11 +240,11 @@ static int __quicklistCompressNode(quicklistNode *node) {
}
/* Compress only uncompressed nodes. */
#define quicklistCompressNode(_node) \
do { \
if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_RAW) { \
__quicklistCompressNode((_node)); \
} \
#define quicklistCompressNode(_node) \
do { \
if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_RAW) { \
__quicklistCompressNode((_node)); \
} \
} while (0)
/* Uncompress the listpack in 'node' and update encoding details.
@ -269,20 +269,20 @@ static int __quicklistDecompressNode(quicklistNode *node) {
}
/* Decompress only compressed nodes. */
#define quicklistDecompressNode(_node) \
do { \
if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_LZF) { \
__quicklistDecompressNode((_node)); \
} \
#define quicklistDecompressNode(_node) \
do { \
if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_LZF) { \
__quicklistDecompressNode((_node)); \
} \
} while (0)
/* Force node to not be immediately re-compressible */
#define quicklistDecompressNodeForUse(_node) \
do { \
if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_LZF) { \
__quicklistDecompressNode((_node)); \
(_node)->recompress = 1; \
} \
#define quicklistDecompressNodeForUse(_node) \
do { \
if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_LZF) { \
__quicklistDecompressNode((_node)); \
(_node)->recompress = 1; \
} \
} while (0)
/* Extract the raw LZF data from this quicklistNode.
@ -376,18 +376,18 @@ static void __quicklistCompress(const quicklist *quicklist, quicklistNode *node)
*
* If the 'recompress' flag of the node is false, we check whether the node is
* within the range of compress depth before compressing it. */
#define quicklistCompress(_ql, _node) \
do { \
if ((_node)->recompress) \
quicklistCompressNode((_node)); \
else \
__quicklistCompress((_ql), (_node)); \
#define quicklistCompress(_ql, _node) \
do { \
if ((_node)->recompress) \
quicklistCompressNode((_node)); \
else \
__quicklistCompress((_ql), (_node)); \
} while (0)
/* If we previously used quicklistDecompressNodeForUse(), just recompress. */
#define quicklistRecompressOnly(_node) \
do { \
if ((_node)->recompress) quicklistCompressNode((_node)); \
#define quicklistRecompressOnly(_node) \
do { \
if ((_node)->recompress) quicklistCompressNode((_node)); \
} while (0)
/* Insert 'new_node' after 'old_node' if 'after' is 1.
@ -518,9 +518,9 @@ static int _quicklistNodeAllowMerge(const quicklistNode *a, const quicklistNode
return 1;
}
#define quicklistNodeUpdateSz(node) \
do { \
(node)->sz = lpBytes((node)->entry); \
#define quicklistNodeUpdateSz(node) \
do { \
(node)->sz = lpBytes((node)->entry); \
} while (0)
static quicklistNode *__quicklistCreateNode(int container, void *value, size_t sz) {
@ -627,12 +627,12 @@ void quicklistAppendPlainNode(quicklist *quicklist, unsigned char *data, size_t
quicklist->count += node->count;
}
#define quicklistDeleteIfEmpty(ql, n) \
do { \
if ((n)->count == 0) { \
__quicklistDelNode((ql), (n)); \
(n) = NULL; \
} \
#define quicklistDeleteIfEmpty(ql, n) \
do { \
if ((n)->count == 0) { \
__quicklistDelNode((ql), (n)); \
(n) = NULL; \
} \
} while (0)
static void __quicklistDelNode(quicklist *quicklist, quicklistNode *node) {
@ -1702,17 +1702,17 @@ void quicklistBookmarksClear(quicklist *ql) {
#define yell(str, ...) printf("ERROR! " str "\n\n", __VA_ARGS__)
#define ERROR \
do { \
printf("\tERROR!\n"); \
err++; \
#define ERROR \
do { \
printf("\tERROR!\n"); \
err++; \
} while (0)
#define ERR(x, ...) \
do { \
printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__); \
printf("ERROR! " x "\n", __VA_ARGS__); \
err++; \
#define ERR(x, ...) \
do { \
printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__); \
printf("ERROR! " x "\n", __VA_ARGS__); \
err++; \
} while (0)
#define TEST(name) printf("test — %s\n", name);
@ -1782,9 +1782,9 @@ static int itrprintr_rev(quicklist *ql, int print) {
return _itrprintr(ql, print, 0);
}
#define ql_verify(a, b, c, d, e) \
do { \
err += _ql_verify((a), (b), (c), (d), (e)); \
#define ql_verify(a, b, c, d, e) \
do { \
err += _ql_verify((a), (b), (c), (d), (e)); \
} while (0)
static int _ql_verify_compress(quicklist *ql) {

5
src/quicklist.h
View File

@ -90,9 +90,8 @@ typedef struct quicklistBookmark {
/* 64-bit */
#define QL_FILL_BITS 16
#define QL_COMP_BITS 16
#define QL_BM_BITS \
4 /* we can encode more, but we rather limit the user \
since they cause performance degradation. */
#define QL_BM_BITS 4 /* we can encode more, but we rather limit the user \
since they cause performance degradation. */
#else
#error unknown arch bits count
#endif

20
src/rand.c
View File

@ -47,11 +47,11 @@
#define MASK ((1 << (N - 1)) + (1 << (N - 1)) - 1)
#define LOW(x) ((unsigned)(x) & MASK)
#define HIGH(x) LOW((x) >> N)
#define MUL(x, y, z) \
{ \
int32_t l = (long)(x) * (long)(y); \
(z)[0] = LOW(l); \
(z)[1] = HIGH(l); \
#define MUL(x, y, z) \
{ \
int32_t l = (long)(x) * (long)(y); \
(z)[0] = LOW(l); \
(z)[1] = HIGH(l); \
}
#define CARRY(x, y) ((int32_t)(x) + (long)(y) > MASK)
#define ADDEQU(x, y, z) (z = CARRY(x, (y)), x = LOW(x + (y)))
@ -65,11 +65,11 @@
#define SET3(x, x0, x1, x2) ((x)[0] = (x0), (x)[1] = (x1), (x)[2] = (x2))
#define SETLOW(x, y, n) SET3(x, LOW((y)[n]), LOW((y)[(n) + 1]), LOW((y)[(n) + 2]))
#define SEED(x0, x1, x2) (SET3(x, x0, x1, x2), SET3(a, A0, A1, A2), c = C)
#define REST(v) \
for (i = 0; i < 3; i++) { \
xsubi[i] = x[i]; \
x[i] = temp[i]; \
} \
#define REST(v) \
for (i = 0; i < 3; i++) { \
xsubi[i] = x[i]; \
x[i] = temp[i]; \
} \
return (v);
#define HI_BIT (1L << (2 * N - 1))

20
src/rax.c
View File

@ -54,11 +54,11 @@ void raxDebugShowNode(const char *msg, raxNode *n);
* debugging on/off in order to enable it only when you suspect there is an
* operation causing a bug using the function raxSetDebugMsg(). */
#ifdef RAX_DEBUG_MSG
#define debugf(...) \
if (raxDebugMsg) { \
printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__); \
printf(__VA_ARGS__); \
fflush(stdout); \
#define debugf(...) \
if (raxDebugMsg) { \
printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__); \
printf(__VA_ARGS__); \
fflush(stdout); \
}
#define debugnode(msg, n) raxDebugShowNode(msg, n)
@ -153,8 +153,8 @@ static inline void raxStackFree(raxStack *ts) {
/* Return the pointer to the last child pointer in a node. For the compressed
* nodes this is the only child pointer. */
#define raxNodeLastChildPtr(n) \
((raxNode **)(((char *)(n)) + raxNodeCurrentLength(n) - sizeof(raxNode *) - \
#define raxNodeLastChildPtr(n) \
((raxNode **)(((char *)(n)) + raxNodeCurrentLength(n) - sizeof(raxNode *) - \
(((n)->iskey && !(n)->isnull) ? sizeof(void *) : 0)))
/* Return the pointer to the first child pointer. */
@ -163,9 +163,9 @@ static inline void raxStackFree(raxStack *ts) {
/* Return the current total size of the node. Note that the second line
* computes the padding after the string of characters, needed in order to
* save pointers to aligned addresses. */
#define raxNodeCurrentLength(n) \
(sizeof(raxNode) + (n)->size + raxPadding((n)->size) + \
((n)->iscompr ? sizeof(raxNode *) : sizeof(raxNode *) * (n)->size) + \
#define raxNodeCurrentLength(n) \
(sizeof(raxNode) + (n)->size + raxPadding((n)->size) + \
((n)->iscompr ? sizeof(raxNode *) : sizeof(raxNode *) * (n)->size) + \
(((n)->iskey && !(n)->isnull) * sizeof(void *)))
/* Allocate a new non compressed node with the specified number of children.

14
src/rax.h
View File

@ -166,14 +166,12 @@ typedef int (*raxNodeCallback)(raxNode **noderef);
/* Radix tree iterator state is encapsulated into this data structure. */
#define RAX_ITER_STATIC_LEN 128
#define RAX_ITER_JUST_SEEKED \
(1 << 0) /* Iterator was just seeked. Return current \
element for the first iteration and \
clear the flag. */
#define RAX_ITER_EOF (1 << 1) /* End of iteration reached. */
#define RAX_ITER_SAFE \
(1 << 2) /* Safe iterator, allows operations while \
iterating. But it is slower. */
#define RAX_ITER_JUST_SEEKED (1 << 0) /* Iterator was just seeked. Return current \
element for the first iteration and \
clear the flag. */
#define RAX_ITER_EOF (1 << 1) /* End of iteration reached. */
#define RAX_ITER_SAFE (1 << 2) /* Safe iterator, allows operations while \
iterating. But it is slower. */
typedef struct raxIterator {
int flags;
rax *rt; /* Radix tree we are iterating. */

5
src/rdb.h
View File

@ -79,9 +79,8 @@
#define RDB_TYPE_HASH 4
#define RDB_TYPE_ZSET_2 5 /* ZSET version 2 with doubles stored in binary. */
#define RDB_TYPE_MODULE_PRE_GA 6 /* Used in 4.0 release candidates */
#define RDB_TYPE_MODULE_2 \
7 /* Module value with annotations for parsing without \
the generating module being loaded. */
#define RDB_TYPE_MODULE_2 7 /* Module value with annotations for parsing without \
the generating module being loaded. */
#define RDB_TYPE_HASH_ZIPMAP 9
#define RDB_TYPE_LIST_ZIPLIST 10
#define RDB_TYPE_SET_INTSET 11

6
src/replication.c
View File

@ -4223,9 +4223,9 @@ void refreshGoodReplicasCount(void) {
/* return true if status of good replicas is OK. otherwise false */
int checkGoodReplicasStatus(void) {
return server.primary_host || /* not a primary status should be OK */
!server.repl_min_replicas_max_lag || /* Min replica max lag not configured */
!server.repl_min_replicas_to_write || /* Min replica to write not configured */
return server.primary_host || /* not a primary status should be OK */
!server.repl_min_replicas_max_lag || /* Min replica max lag not configured */
!server.repl_min_replicas_to_write || /* Min replica to write not configured */
server.repl_good_replicas_count >= server.repl_min_replicas_to_write; /* check if we have enough replicas */
}

48
src/rio.c
View File

@ -182,12 +182,16 @@ static int rioFileFlush(rio *r) {
}
static const rio rioFileIO = {
rioFileRead, rioFileWrite, rioFileTell, rioFileFlush, NULL, /* update_checksum */
0, /* current checksum */
0, /* flags */
0, /* bytes read or written */
0, /* read/write chunk size */
{{NULL, 0}} /* union for io-specific vars */
rioFileRead,
rioFileWrite,
rioFileTell,
rioFileFlush,
NULL, /* update_checksum */
0, /* current checksum */
0, /* flags */
0, /* bytes read or written */
0, /* read/write chunk size */
{{NULL, 0}} /* union for io-specific vars */
};
void rioInitWithFile(rio *r, FILE *fp) {
@ -276,12 +280,16 @@ static int rioConnFlush(rio *r) {
}
static const rio rioConnIO = {
rioConnRead, rioConnWrite, rioConnTell, rioConnFlush, NULL, /* update_checksum */
0, /* current checksum */
0, /* flags */
0, /* bytes read or written */
0, /* read/write chunk size */
{{NULL, 0}} /* union for io-specific vars */
rioConnRead,
rioConnWrite,
rioConnTell,
rioConnFlush,
NULL, /* update_checksum */
0, /* current checksum */
0, /* flags */
0, /* bytes read or written */
0, /* read/write chunk size */
{{NULL, 0}} /* union for io-specific vars */
};
/* Create an RIO that implements a buffered read from an fd
@ -388,12 +396,16 @@ static int rioFdFlush(rio *r) {
}
static const rio rioFdIO = {
rioFdRead, rioFdWrite, rioFdTell, rioFdFlush, NULL, /* update_checksum */
0, /* current checksum */
0, /* flags */
0, /* bytes read or written */
0, /* read/write chunk size */
{{NULL, 0}} /* union for io-specific vars */
rioFdRead,
rioFdWrite,
rioFdTell,
rioFdFlush,
NULL, /* update_checksum */
0, /* current checksum */
0, /* flags */
0, /* bytes read or written */
0, /* read/write chunk size */
{{NULL, 0}} /* union for io-specific vars */
};
void rioInitWithFd(rio *r, int fd) {

41
src/script_lua.c
View File

@ -44,7 +44,15 @@
/* Globals that are added by the Lua libraries */
static char *libraries_allow_list[] = {
"string", "cjson", "bit", "cmsgpack", "math", "table", "struct", "os", NULL,
"string",
"cjson",
"bit",
"cmsgpack",
"math",
"table",
"struct",
"os",
NULL,
};
/* Lua API globals */
@ -58,10 +66,33 @@ static char *redis_api_allow_list[] = {
/* Lua builtins */
static char *lua_builtins_allow_list[] = {
"xpcall", "tostring", "getfenv", "setmetatable", "next", "assert", "tonumber",
"rawequal", "collectgarbage", "getmetatable", "rawset", "pcall", "coroutine", "type",
"_G", "select", "unpack", "gcinfo", "pairs", "rawget", "loadstring",
"ipairs", "_VERSION", "setfenv", "load", "error", NULL,
"xpcall",
"tostring",
"getfenv",
"setmetatable",
"next",
"assert",
"tonumber",
"rawequal",
"collectgarbage",
"getmetatable",
"rawset",
"pcall",
"coroutine",
"type",
"_G",
"select",
"unpack",
"gcinfo",
"pairs",
"rawget",
"loadstring",
"ipairs",
"_VERSION",
"setfenv",
"load",
"error",
NULL,
};
/* Lua builtins which are not documented on the Lua documentation */

150
src/sentinel.c
View File

@ -64,21 +64,19 @@ typedef struct sentinelAddr {
#define SRI_PRIMARY (1 << 0)
#define SRI_REPLICA (1 << 1)
#define SRI_SENTINEL (1 << 2)
#define SRI_S_DOWN (1 << 3) /* Subjectively down (no quorum). */
#define SRI_O_DOWN (1 << 4) /* Objectively down (confirmed by others). */
#define SRI_PRIMARY_DOWN \
(1 << 5) /* A Sentinel with this flag set thinks that \
its primary is down. */
#define SRI_FAILOVER_IN_PROGRESS \
(1 << 6) /* Failover is in progress for \
this primary. */
#define SRI_PROMOTED (1 << 7) /* Replica selected for promotion. */
#define SRI_RECONF_SENT (1 << 8) /* REPLICAOF <newprimary> sent. */
#define SRI_RECONF_INPROG (1 << 9) /* Replica synchronization in progress. */
#define SRI_RECONF_DONE (1 << 10) /* Replica synchronized with new primary. */
#define SRI_FORCE_FAILOVER (1 << 11) /* Force failover with primary up. */
#define SRI_SCRIPT_KILL_SENT (1 << 12) /* SCRIPT KILL already sent on -BUSY */
#define SRI_PRIMARY_REBOOT (1 << 13) /* Primary was detected as rebooting */
#define SRI_S_DOWN (1 << 3) /* Subjectively down (no quorum). */
#define SRI_O_DOWN (1 << 4) /* Objectively down (confirmed by others). */
#define SRI_PRIMARY_DOWN (1 << 5) /* A Sentinel with this flag set thinks that \
its primary is down. */
#define SRI_FAILOVER_IN_PROGRESS (1 << 6) /* Failover is in progress for \
this primary. */
#define SRI_PROMOTED (1 << 7) /* Replica selected for promotion. */
#define SRI_RECONF_SENT (1 << 8) /* REPLICAOF <newprimary> sent. */
#define SRI_RECONF_INPROG (1 << 9) /* Replica synchronization in progress. */
#define SRI_RECONF_DONE (1 << 10) /* Replica synchronized with new primary. */
#define SRI_FORCE_FAILOVER (1 << 11) /* Force failover with primary up. */
#define SRI_SCRIPT_KILL_SENT (1 << 12) /* SCRIPT KILL already sent on -BUSY */
#define SRI_PRIMARY_REBOOT (1 << 13) /* Primary was detected as rebooting */
/* Note: when adding new flags, please check the flags section in addReplySentinelValkeyInstance. */
/* Note: times are in milliseconds. */
@ -467,9 +465,17 @@ void sentinelConfigSetCommand(client *c);
/* this array is used for sentinel config lookup, which need to be loaded
* before monitoring primaries config to avoid dependency issues */
const char *preMonitorCfgName[] = {"announce-ip", "announce-port", "deny-scripts-reconfig",
"sentinel-user", "sentinel-pass", "current-epoch",
"myid", "resolve-hostnames", "announce-hostnames"};
const char *preMonitorCfgName[] = {
"announce-ip",
"announce-port",
"deny-scripts-reconfig",
"sentinel-user",
"sentinel-pass",
"current-epoch",
"myid",
"resolve-hostnames",
"announce-hostnames",
};
/* This function overwrites a few normal server config default with Sentinel
* specific defaults. */
@ -3033,8 +3039,16 @@ void sentinelConfigSetCommand(client *c) {
int drop_conns = 0;
char *option;
robj *val;
char *options[] = {"announce-ip", "sentinel-user", "sentinel-pass", "resolve-hostnames",
"announce-port", "announce-hostnames", "loglevel", NULL};
char *options[] = {
"announce-ip",
"sentinel-user",
"sentinel-pass",
"resolve-hostnames",
"announce-port",
"announce-hostnames",
"loglevel",
NULL,
};
static dict *options_dict = NULL;
if (!options_dict) {
options_dict = dictCreate(&stringSetDictType);
@ -3675,57 +3689,55 @@ int sentinelIsQuorumReachable(sentinelValkeyInstance *primary, int *usableptr) {
void sentinelCommand(client *c) {
if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr, "help")) {
/* clang-format off */
const char *help[] = {
"CKQUORUM <primary-name>",
" Check if the current Sentinel configuration is able to reach the quorum",
" needed to failover a primary and the majority needed to authorize the",
" failover.",
"CONFIG SET param value [param value ...]",
" Set a global Sentinel configuration parameter.",
"CONFIG GET <param> [param param param ...]",
" Get global Sentinel configuration parameter.",
"DEBUG [<param> <value> ...]",
" Show a list of configurable time parameters and their values (milliseconds).",
" Or update current configurable parameters values (one or more).",
"GET-PRIMARY-ADDR-BY-NAME <primary-name>",
" Return the ip and port number of the primary with that name.",
"FAILOVER <primary-name>",
" Manually failover a primary node without asking for agreement from other",
" Sentinels",
"FLUSHCONFIG",
" Force Sentinel to rewrite its configuration on disk, including the current",
" Sentinel state.",
"INFO-CACHE <primary-name>",
" Return last cached INFO output from primaries and all its replicas.",
"IS-PRIMARY-DOWN-BY-ADDR <ip> <port> <current-epoch> <runid>",
" Check if the primary specified by ip:port is down from current Sentinel's",
" point of view.",
"PRIMARY <primary-name>",
" Show the state and info of the specified primary.",
"PRIMARIES",
" Show a list of monitored primaries and their state.",
"MONITOR <name> <ip> <port> <quorum>",
" Start monitoring a new primary with the specified name, ip, port and quorum.",
"MYID",
" Return the ID of the Sentinel instance.",
"PENDING-SCRIPTS",
" Get pending scripts information.",
"REMOVE <primary-name>",
" Remove primary from Sentinel's monitor list.",
"REPLICAS <primary-name>",
" Show a list of replicas for this primary and their states.",
"RESET <pattern>",
" Reset primaries for specific primary name matching this pattern.",
"SENTINELS <primary-name>",
" Show a list of Sentinel instances for this primary and their state.",
"SET <primary-name> <option> <value> [<option> <value> ...]",
" Set configuration parameters for certain primaries.",
"SIMULATE-FAILURE [CRASH-AFTER-ELECTION] [CRASH-AFTER-PROMOTION] [HELP]",
" Simulate a Sentinel crash.",
NULL
"CKQUORUM <primary-name>",
" Check if the current Sentinel configuration is able to reach the quorum",
" needed to failover a primary and the majority needed to authorize the",
" failover.",
"CONFIG SET param value [param value ...]",
" Set a global Sentinel configuration parameter.",
"CONFIG GET <param> [param param param ...]",
" Get global Sentinel configuration parameter.",
"DEBUG [<param> <value> ...]",
" Show a list of configurable time parameters and their values (milliseconds).",
" Or update current configurable parameters values (one or more).",
"GET-PRIMARY-ADDR-BY-NAME <primary-name>",
" Return the ip and port number of the primary with that name.",
"FAILOVER <primary-name>",
" Manually failover a primary node without asking for agreement from other",
" Sentinels",
"FLUSHCONFIG",
" Force Sentinel to rewrite its configuration on disk, including the current",
" Sentinel state.",
"INFO-CACHE <primary-name>",
" Return last cached INFO output from primaries and all its replicas.",
"IS-PRIMARY-DOWN-BY-ADDR <ip> <port> <current-epoch> <runid>",
" Check if the primary specified by ip:port is down from current Sentinel's",
" point of view.",
"PRIMARY <primary-name>",
" Show the state and info of the specified primary.",
"PRIMARIES",
" Show a list of monitored primaries and their state.",
"MONITOR <name> <ip> <port> <quorum>",
" Start monitoring a new primary with the specified name, ip, port and quorum.",
"MYID",
" Return the ID of the Sentinel instance.",
"PENDING-SCRIPTS",
" Get pending scripts information.",
"REMOVE <primary-name>",
" Remove primary from Sentinel's monitor list.",
"REPLICAS <primary-name>",
" Show a list of replicas for this primary and their states.",
"RESET <pattern>",
" Reset primaries for specific primary name matching this pattern.",
"SENTINELS <primary-name>",
" Show a list of Sentinel instances for this primary and their state.",
"SET <primary-name> <option> <value> [<option> <value> ...]",
" Set configuration parameters for certain primaries.",
"SIMULATE-FAILURE [CRASH-AFTER-ELECTION] [CRASH-AFTER-PROMOTION] [HELP]",
" Simulate a Sentinel crash.",
NULL,
};
/* clang-format on */
addReplyHelp(c, help);
} else if (!strcasecmp(c->argv[1]->ptr, "primaries") || !strcasecmp(c->argv[1]->ptr, "masters")) {
/* SENTINEL PRIMARIES */

611
src/server.c
View File

@ -4585,7 +4585,15 @@ void addReplyFlagsForKeyArgs(client *c, uint64_t flags) {
/* Must match serverCommandArgType */
const char *ARG_TYPE_STR[] = {
"string", "integer", "double", "key", "pattern", "unix-time", "pure-token", "oneof", "block",
"string",
"integer",
"double",
"key",
"pattern",
"unix-time",
"pure-token",
"oneof",
"block",
};
void addReplyFlagsForArg(client *c, uint64_t flags) {
@ -5160,29 +5168,27 @@ void commandGetKeysCommand(client *c) {
/* COMMAND HELP */
void commandHelpCommand(client *c) {
/* clang-format off */
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
"(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,
};
/* clang-format on */
addReplyHelp(c, help);
}
@ -5341,8 +5347,20 @@ void releaseInfoSectionDict(dict *sec) {
* '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};
char *default_sections[] = {
"server",
"clients",
"memory",
"persistence",
"stats",
"replication",
"cpu",
"module_list",
"errorstats",
"cluster",
"keyspace",
NULL,
};
if (!defaults) defaults = default_sections;
if (argc == 0) {
@ -5434,38 +5452,38 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
call_uname = 0;
}
/* clang-format off */
info = sdscatfmt(info, "# Server\r\n" FMTARGS(
"redis_version:%s\r\n", REDIS_VERSION,
"server_name:%s\r\n", SERVER_NAME,
"valkey_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));
/* clang-format on */
info = sdscatfmt(
info,
"# Server\r\n" FMTARGS(
"redis_version:%s\r\n", REDIS_VERSION,
"server_name:%s\r\n", SERVER_NAME,
"valkey_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()) {
@ -5484,22 +5502,22 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
getExpansiveClientsInfo(&maxin, &maxout);
totalNumberOfStatefulKeys(&blocking_keys, &blocking_keys_on_nokey, &watched_keys);
if (sections++) info = sdscat(info, "\r\n");
/* clang-format off */
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));
/* clang-format on */
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));
}
/* Memory */
@ -5535,66 +5553,66 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
bytesToHuman(maxmemory_hmem, sizeof(maxmemory_hmem), server.maxmemory);
if (sections++) info = sdscat(info, "\r\n");
/* clang-format off */
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_running,
"lazyfree_pending_objects:%zu\r\n", lazyfreeGetPendingObjectsCount(),
"lazyfreed_objects:%zu\r\n", lazyfreeGetFreedObjectsCount()));
/* clang-format on */
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_running,
"lazyfree_pending_objects:%zu\r\n", lazyfreeGetPendingObjectsCount(),
"lazyfreed_objects:%zu\r\n", lazyfreeGetFreedObjectsCount()));
freeMemoryOverheadData(mh);
}
@ -5609,55 +5627,50 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
}
int aof_bio_fsync_status = atomic_load_explicit(&server.aof_bio_fsync_status, memory_order_relaxed);
/* clang-format off */
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));
/* clang-format on */
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) {
/* clang-format off */
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));
/* clang-format on */
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) {
@ -5684,15 +5697,15 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
eta = (elapsed * remaining_bytes) / (server.loading_loaded_bytes + 1);
}
/* clang-format off */
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));
/* clang-format on */
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));
}
}
@ -5704,72 +5717,72 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
server.stat_last_active_defrag_time ? (long long)elapsedUs(server.stat_last_active_defrag_time) : 0;
if (sections++) info = sdscat(info, "\r\n");
/* clang-format off */
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_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 = 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_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);
/* clang-format on */
}
/* Replication */
@ -5791,44 +5804,44 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
replica_read_repl_offset = server.cached_primary->read_reploff;
}
/* clang-format off */
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));
/* clang-format on */
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;
}
/* clang-format off */
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)));
/* clang-format on */
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);
}
/* clang-format off */
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));
/* clang-format on */
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));
@ -5870,19 +5883,19 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
replica_id++;
}
}
/* clang-format off */
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));
/* clang-format on */
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 */
@ -5993,13 +6006,13 @@ sds genValkeyInfoString(dict *section_dict, int all_sections, int everything) {
if (dictFind(section_dict, "debug") != NULL) {
if (sections++) info = sdscat(info, "\r\n");
/* clang-format off */
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));
/* clang-format on */
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;

551
src/server.h
View File

@ -104,7 +104,7 @@ struct hdr_histogram;
#define max(a, b) ((a) > (b) ? (a) : (b))
/* Get the pointer of the outer struct from a member address */
#define server_member2struct(struct_name, member_name, member_addr) \
#define server_member2struct(struct_name, member_name, member_addr) \
((struct_name *)((char *)member_addr - offsetof(struct_name, member_name)))
/* Error codes */
@ -140,9 +140,8 @@ struct hdr_histogram;
#define CONFIG_BINDADDR_MAX 16
#define CONFIG_MIN_RESERVED_FDS 32
#define CONFIG_DEFAULT_PROC_TITLE_TEMPLATE "{title} {listen-addr} {server-mode}"
#define DEFAULT_WAIT_BEFORE_RDB_CLIENT_FREE \
60 /* Grace period in seconds for replica main \
channel to establish psync. */
#define DEFAULT_WAIT_BEFORE_RDB_CLIENT_FREE 60 /* Grace period in seconds for replica main \
channel to establish psync. */
#define INCREMENTAL_REHASHING_THRESHOLD_US 1000
#define LOADING_PROCESS_EVENTS_INTERVAL_DEFAULT 100 /* Default: 0.1 seconds */
@ -238,9 +237,8 @@ extern int configOOMScoreAdjValuesDefaults[CONFIG_OOM_COUNT];
#define CMD_MODULE_NO_CLUSTER (1ULL << 22) /* Deny on Cluster. */
#define CMD_NO_ASYNC_LOADING (1ULL << 23)
#define CMD_NO_MULTI (1ULL << 24)
#define CMD_MOVABLE_KEYS \
(1ULL << 25) /* The legacy range spec doesn't cover all keys. \
* Populated by populateCommandLegacyRangeSpec. */
#define CMD_MOVABLE_KEYS (1ULL << 25) /* The legacy range spec doesn't cover all keys. \
* Populated by populateCommandLegacyRangeSpec. */
#define CMD_ALLOW_BUSY ((1ULL << 26))
#define CMD_MODULE_GETCHANNELS (1ULL << 27) /* Use the modules getchannels interface. */
#define CMD_TOUCHES_ARBITRARY_KEYS (1ULL << 28)
@ -274,14 +272,11 @@ extern int configOOMScoreAdjValuesDefaults[CONFIG_OOM_COUNT];
* of the key, and not necessarily the user data or how it affects it.
* Each key-spec may must have exactly one of these. Any operation that's not
* distinctly deletion, overwrite or read-only would be marked as RW. */
#define CMD_KEY_RO \
(1ULL << 0) /* Read-Only - Reads the value of the key, but \
* doesn't necessarily returns it. */
#define CMD_KEY_RW \
(1ULL << 1) /* Read-Write - Modifies the data stored in the \
* value of the key or its metadata. */
#define CMD_KEY_OW \
(1ULL << 2) /* Overwrite - Overwrites the data stored in \
#define CMD_KEY_RO (1ULL << 0) /* Read-Only - Reads the value of the key, but \
* doesn't necessarily returns it. */
#define CMD_KEY_RW (1ULL << 1) /* Read-Write - Modifies the data stored in the \
* value of the key or its metadata. */
#define CMD_KEY_OW (1ULL << 2) /* Overwrite - Overwrites the data stored in \
* the value of the key. */
#define CMD_KEY_RM (1ULL << 3) /* Deletes the key. */
/* The following refer to user data inside the value of the key, not the metadata
@ -290,29 +285,22 @@ extern int configOOMScoreAdjValuesDefaults[CONFIG_OOM_COUNT];
* It doesn't refer to modification or returning of metadata (like type, count,
* presence of data). Any write that's not INSERT or DELETE, would be an UPDATE.
* Each key-spec may have one of the writes with or without access, or none: */
#define CMD_KEY_ACCESS \
(1ULL << 4) /* Returns, copies or uses the user data from \
* the value of the key. */
#define CMD_KEY_UPDATE \
(1ULL << 5) /* Updates data to the value, new value may \
* depend on the old value. */
#define CMD_KEY_INSERT \
(1ULL << 6) /* Adds data to the value with no chance of \
* modification or deletion of existing data. */
#define CMD_KEY_DELETE \
(1ULL << 7) /* Explicitly deletes some content \
* from the value of the key. */
#define CMD_KEY_ACCESS (1ULL << 4) /* Returns, copies or uses the user data from \
* the value of the key. */
#define CMD_KEY_UPDATE (1ULL << 5) /* Updates data to the value, new value may \
* depend on the old value. */
#define CMD_KEY_INSERT (1ULL << 6) /* Adds data to the value with no chance of \
* modification or deletion of existing data. */
#define CMD_KEY_DELETE (1ULL << 7) /* Explicitly deletes some content \
* from the value of the key. */
/* Other flags: */
#define CMD_KEY_NOT_KEY \
(1ULL << 8) /* A 'fake' key that should be routed \
* like a key in cluster mode but is \
* excluded from other key checks. */
#define CMD_KEY_INCOMPLETE \
(1ULL << 9) /* Means that the keyspec might not point \
* out to all keys it should cover */
#define CMD_KEY_VARIABLE_FLAGS \
(1ULL << 10) /* Means that some keys might have \
* different flags depending on arguments */
#define CMD_KEY_NOT_KEY (1ULL << 8) /* A 'fake' key that should be routed \
* like a key in cluster mode but is \
* excluded from other key checks. */
#define CMD_KEY_INCOMPLETE (1ULL << 9) /* Means that the keyspec might not point \
* out to all keys it should cover */
#define CMD_KEY_VARIABLE_FLAGS (1ULL << 10) /* Means that some keys might have \
* different flags depending on arguments */
/* Key flags for when access type is unknown */
#define CMD_KEY_FULL_ACCESS (CMD_KEY_RW | CMD_KEY_ACCESS | CMD_KEY_UPDATE)
@ -377,15 +365,14 @@ typedef enum blocking_type {
/* Client classes for client limits, currently used only for
* the max-client-output-buffer limit implementation. */
#define CLIENT_TYPE_NORMAL 0 /* Normal req-reply clients + MONITORs */
#define CLIENT_TYPE_REPLICA 1 /* Replicas. */
#define CLIENT_TYPE_PUBSUB 2 /* Clients subscribed to PubSub channels. */
#define CLIENT_TYPE_PRIMARY 3 /* Primary. */
#define CLIENT_TYPE_COUNT 4 /* Total number of client types. */
#define CLIENT_TYPE_OBUF_COUNT \
3 /* Number of clients to expose to output \
buffer configuration. Just the first \
three: normal, replica, pubsub. */
#define CLIENT_TYPE_NORMAL 0 /* Normal req-reply clients + MONITORs */
#define CLIENT_TYPE_REPLICA 1 /* Replicas. */
#define CLIENT_TYPE_PUBSUB 2 /* Clients subscribed to PubSub channels. */
#define CLIENT_TYPE_PRIMARY 3 /* Primary. */
#define CLIENT_TYPE_COUNT 4 /* Total number of client types. */
#define CLIENT_TYPE_OBUF_COUNT 3 /* Number of clients to expose to output \
buffer configuration. Just the first \
three: normal, replica, pubsub. */
/* Replica replication state. Used in server.repl_state for replicas to remember
* what to do next. */
@ -436,10 +423,9 @@ typedef enum {
#define REPLICA_STATE_WAIT_BGSAVE_END 7 /* Waiting RDB file creation to finish. */
#define REPLICA_STATE_SEND_BULK 8 /* Sending RDB file to replica. */
#define REPLICA_STATE_ONLINE 9 /* RDB file transmitted, sending just updates. */
#define REPLICA_STATE_RDB_TRANSMITTED \
10 /* RDB file transmitted - This state is used only for \
* a replica that only wants RDB without replication buffer */
#define REPLICA_STATE_BG_RDB_LOAD 11 /* Main channel of a replica which uses dual channel replication. */
#define REPLICA_STATE_RDB_TRANSMITTED 10 /* RDB file transmitted - This state is used only for \
* a replica that only wants RDB without replication buffer */
#define REPLICA_STATE_BG_RDB_LOAD 11 /* Main channel of a replica which uses dual channel replication. */
/* Replica capabilities. */
#define REPLICA_CAPA_NONE 0
@ -553,12 +539,11 @@ typedef enum {
/* SHUTDOWN flags */
#define SHUTDOWN_NOFLAGS 0 /* No flags. */
#define SHUTDOWN_SAVE \
1 /* Force SAVE on SHUTDOWN even if no save \
points are configured. */
#define SHUTDOWN_NOSAVE 2 /* Don't SAVE on SHUTDOWN. */
#define SHUTDOWN_NOW 4 /* Don't wait for replicas to catch up. */
#define SHUTDOWN_FORCE 8 /* Don't let errors prevent shutdown. */
#define SHUTDOWN_SAVE 1 /* Force SAVE on SHUTDOWN even if no save \
points are configured. */
#define SHUTDOWN_NOSAVE 2 /* Don't SAVE on SHUTDOWN. */
#define SHUTDOWN_NOW 4 /* Don't wait for replicas to catch up. */
#define SHUTDOWN_FORCE 8 /* Don't let errors prevent shutdown. */
/* Command call flags, see call() function */
#define CMD_CALL_NONE 0
@ -582,9 +567,9 @@ typedef enum {
#define PAUSE_ACTION_REPLICA (1 << 4) /* pause replica traffic */
/* common sets of actions to pause/unpause */
#define PAUSE_ACTIONS_CLIENT_WRITE_SET \
#define PAUSE_ACTIONS_CLIENT_WRITE_SET \
(PAUSE_ACTION_CLIENT_WRITE | PAUSE_ACTION_EXPIRE | PAUSE_ACTION_EVICT | PAUSE_ACTION_REPLICA)
#define PAUSE_ACTIONS_CLIENT_ALL_SET \
#define PAUSE_ACTIONS_CLIENT_ALL_SET \
(PAUSE_ACTION_CLIENT_ALL | PAUSE_ACTION_EXPIRE | PAUSE_ACTION_EVICT | PAUSE_ACTION_REPLICA)
/* Client pause purposes. Each purpose has its own end time and pause type. */
@ -629,8 +614,8 @@ typedef enum {
#define NOTIFY_LOADED (1 << 12) /* module only key space notification, indicate a key loaded from rdb */
#define NOTIFY_MODULE (1 << 13) /* d, module key space notification */
#define NOTIFY_NEW (1 << 14) /* n, new key notification */
#define NOTIFY_ALL \
(NOTIFY_GENERIC | NOTIFY_STRING | NOTIFY_LIST | NOTIFY_SET | NOTIFY_HASH | NOTIFY_ZSET | NOTIFY_EXPIRED | \
#define NOTIFY_ALL \
(NOTIFY_GENERIC | NOTIFY_STRING | NOTIFY_LIST | NOTIFY_SET | NOTIFY_HASH | NOTIFY_ZSET | NOTIFY_EXPIRED | \
NOTIFY_EVICTED | NOTIFY_STREAM | NOTIFY_MODULE) /* A flag */
/* Using the following macro you can run code inside serverCron() with the
@ -639,7 +624,7 @@ typedef enum {
#define run_with_period(_ms_) if (((_ms_) <= 1000 / server.hz) || !(server.cronloops % ((_ms_) / (1000 / server.hz))))
/* We can print the stacktrace, so our assert is defined this way: */
#define serverAssertWithInfo(_c, _o, _e) \
#define serverAssertWithInfo(_c, _o, _e) \
(likely(_e) ? (void)0 : (_serverAssertWithInfo(_c, _o, #_e, __FILE__, __LINE__), valkey_unreachable()))
#define serverAssert(_e) (likely(_e) ? (void)0 : (_serverAssert(#_e, __FILE__, __LINE__), valkey_unreachable()))
#define serverPanic(...) _serverPanic(__FILE__, __LINE__, __VA_ARGS__), valkey_unreachable()
@ -654,10 +639,9 @@ typedef enum {
/* latency histogram per command init settings */
#define LATENCY_HISTOGRAM_MIN_VALUE 1L /* >= 1 nanosec */
#define LATENCY_HISTOGRAM_MAX_VALUE 1000000000L /* <= 1 secs */
#define LATENCY_HISTOGRAM_PRECISION \
2 /* Maintain a value precision of 2 significant digits across LATENCY_HISTOGRAM_MIN_VALUE and \
* LATENCY_HISTOGRAM_MAX_VALUE range. Value quantization within the range will thus be no larger than 1/100th \
* (or 1%) of any value. The total size per histogram should sit around 40 KiB Bytes. */
#define LATENCY_HISTOGRAM_PRECISION 2 /* Maintain a value precision of 2 significant digits across LATENCY_HISTOGRAM_MIN_VALUE and \
* LATENCY_HISTOGRAM_MAX_VALUE range. Value quantization within the range will thus be no larger than 1/100th \
* (or 1%) of any value. The total size per histogram should sit around 40 KiB Bytes. */
/* Busy module flags, see busy_module_yield_flags */
#define BUSY_MODULE_YIELD_NONE (0)
@ -665,7 +649,11 @@ typedef enum {
#define BUSY_MODULE_YIELD_CLIENTS (1 << 1)
/* IO poll */
typedef enum { AE_IO_STATE_NONE, AE_IO_STATE_POLL, AE_IO_STATE_DONE } AeIoState;
typedef enum {
AE_IO_STATE_NONE,
AE_IO_STATE_POLL,
AE_IO_STATE_DONE
} AeIoState;
/*-----------------------------------------------------------------------------
* Data types
@ -699,7 +687,7 @@ typedef enum { AE_IO_STATE_NONE, AE_IO_STATE_POLL, AE_IO_STATE_DONE } AeIoState;
#define VALKEYMODULE_TYPE_ENCVER_BITS 10
#define VALKEYMODULE_TYPE_ENCVER_MASK ((1 << VALKEYMODULE_TYPE_ENCVER_BITS) - 1)
#define VALKEYMODULE_TYPE_ENCVER(id) ((id) & VALKEYMODULE_TYPE_ENCVER_MASK)
#define VALKEYMODULE_TYPE_SIGN(id) \
#define VALKEYMODULE_TYPE_SIGN(id) \
(((id) & ~((uint64_t)VALKEYMODULE_TYPE_ENCVER_MASK)) >> VALKEYMODULE_TYPE_ENCVER_BITS)
/* Bit flags for moduleTypeAuxSaveFunc */
@ -827,16 +815,16 @@ struct ValkeyModuleIO {
/* Macro to initialize an IO context. Note that the 'ver' field is populated
* inside rdb.c according to the version of the value to load. */
#define moduleInitIOContext(iovar, mtype, rioptr, keyptr, db) \
do { \
iovar.rio = rioptr; \
iovar.type = mtype; \
iovar.bytes = 0; \
iovar.error = 0; \
iovar.key = keyptr; \
iovar.dbid = db; \
iovar.ctx = NULL; \
iovar.pre_flush_buffer = NULL; \
#define moduleInitIOContext(iovar, mtype, rioptr, keyptr, db) \
do { \
iovar.rio = rioptr; \
iovar.type = mtype; \
iovar.bytes = 0; \
iovar.error = 0; \
iovar.key = keyptr; \
iovar.dbid = db; \
iovar.ctx = NULL; \
iovar.pre_flush_buffer = NULL; \
} while (0)
/* This is a structure used to export DEBUG DIGEST capabilities to
@ -852,10 +840,10 @@ struct ValkeyModuleDigest {
};
/* Just start with a digest composed of all zero bytes. */
#define moduleInitDigestContext(mdvar) \
do { \
memset(mdvar.o, 0, sizeof(mdvar.o)); \
memset(mdvar.x, 0, sizeof(mdvar.x)); \
#define moduleInitDigestContext(mdvar) \
do { \
memset(mdvar.o, 0, sizeof(mdvar.o)); \
memset(mdvar.x, 0, sizeof(mdvar.x)); \
} while (0)
/* Macro to check if the client is in the middle of module based authentication. */
@ -903,12 +891,12 @@ char *getObjectTypeName(robj *);
* Note that this macro is taken near the structure definition to make sure
* we'll update it when the structure is changed, to avoid bugs like
* bug #85 introduced exactly in this way. */
#define initStaticStringObject(_var, _ptr) \
do { \
_var.refcount = OBJ_STATIC_REFCOUNT; \
_var.type = OBJ_STRING; \
_var.encoding = OBJ_ENCODING_RAW; \
_var.ptr = _ptr; \
#define initStaticStringObject(_var, _ptr) \
do { \
_var.refcount = OBJ_STATIC_REFCOUNT; \
_var.type = OBJ_STRING; \
_var.encoding = OBJ_ENCODING_RAW; \
_var.ptr = _ptr; \
} while (0)
struct evictionPoolEntry; /* Defined in evict.c */
@ -1057,36 +1045,30 @@ typedef struct readyList {
/* This structure represents a user. This is useful for ACLs, the
* user is associated to the connection after the connection is authenticated.
* If there is no associated user, the connection uses the default user. */
#define USER_COMMAND_BITS_COUNT \
1024 /* The total number of command bits \
in the user structure. The last valid \
command ID we can set in the user \
is USER_COMMAND_BITS_COUNT-1. */
#define USER_FLAG_ENABLED (1 << 0) /* The user is active. */
#define USER_FLAG_DISABLED (1 << 1) /* The user is disabled. */
#define USER_FLAG_NOPASS \
(1 << 2) /* The user requires no password, any \
provided password will work. For the \
default user, this also means that \
no AUTH is needed, and every \
connection is immediately \
authenticated. */
#define USER_FLAG_SANITIZE_PAYLOAD \
(1 << 3) /* The user require a deep RESTORE \
* payload sanitization. */
#define USER_FLAG_SANITIZE_PAYLOAD_SKIP \
(1 << 4) /* The user should skip the \
* deep sanitization of RESTORE \
* payload. */
#define USER_COMMAND_BITS_COUNT 1024 /* The total number of command bits \
in the user structure. The last valid \
command ID we can set in the user \
is USER_COMMAND_BITS_COUNT-1. */
#define USER_FLAG_ENABLED (1 << 0) /* The user is active. */
#define USER_FLAG_DISABLED (1 << 1) /* The user is disabled. */
#define USER_FLAG_NOPASS (1 << 2) /* The user requires no password, any \
provided password will work. For the \
default user, this also means that \
no AUTH is needed, and every \
connection is immediately \
authenticated. */
#define USER_FLAG_SANITIZE_PAYLOAD (1 << 3) /* The user require a deep RESTORE \
* payload sanitization. */
#define USER_FLAG_SANITIZE_PAYLOAD_SKIP (1 << 4) /* The user should skip the \
* deep sanitization of RESTORE \
* payload. */
#define SELECTOR_FLAG_ROOT \
(1 << 0) /* This is the root user permission \
#define SELECTOR_FLAG_ROOT (1 << 0) /* This is the root user permission \
* selector. */
#define SELECTOR_FLAG_ALLKEYS (1 << 1) /* The user can mention any key. */
#define SELECTOR_FLAG_ALLCOMMANDS (1 << 2) /* The user can run all commands. */
#define SELECTOR_FLAG_ALLCHANNELS \
(1 << 3) /* The user can mention any Pub/Sub \
channel. */
#define SELECTOR_FLAG_ALLCHANNELS (1 << 3) /* The user can mention any Pub/Sub \
channel. */
typedef struct {
sds name; /* The username as an SDS string. */
@ -1101,10 +1083,9 @@ typedef struct {
/* With multiplexing we need to take per-client state.
* Clients are taken in a linked list. */
#define CLIENT_ID_AOF \
(UINT64_MAX) /* Reserved ID for the AOF client. If you \
need more reserved IDs use UINT64_MAX-1, \
-2, ... and so forth. */
#define CLIENT_ID_AOF (UINT64_MAX) /* Reserved ID for the AOF client. If you \
need more reserved IDs use UINT64_MAX-1, \
-2, ... and so forth. */
/* Replication backlog is not a separate memory, it just is one consumer of
* the global replication buffer. This structure records the reference of
@ -1167,82 +1148,81 @@ typedef enum {
} clientIOState;
typedef struct ClientFlags {
uint64_t primary : 1; /* This client is a primary */
uint64_t replica : 1; /* This client is a replica */
uint64_t monitor : 1; /* This client is a replica monitor, see MONITOR */
uint64_t multi : 1; /* This client is in a MULTI context */
uint64_t blocked : 1; /* The client is waiting in a blocking operation */
uint64_t dirty_cas : 1; /* Watched keys modified. EXEC will fail. */
uint64_t close_after_reply : 1; /* Close after writing entire reply. */
uint64_t unblocked : 1; /* This client was unblocked and is stored in server.unblocked_clients */
uint64_t script : 1; /* This is a non connected client used by Lua */
uint64_t asking : 1; /* Client issued the ASKING command */
uint64_t close_asap : 1; /* Close this client ASAP */
uint64_t unix_socket : 1; /* Client connected via Unix domain socket */
uint64_t dirty_exec : 1; /* EXEC will fail for errors while queueing */
uint64_t primary_force_reply : 1; /* Queue replies even if is primary */
uint64_t force_aof : 1; /* Force AOF propagation of current cmd. */
uint64_t force_repl : 1; /* Force replication of current cmd. */
uint64_t pre_psync : 1; /* Instance don't understand PSYNC. */
uint64_t readonly : 1; /* Cluster client is in read-only state. */
uint64_t pubsub : 1; /* Client is in Pub/Sub mode. */
uint64_t prevent_aof_prop : 1; /* Don't propagate to AOF. */
uint64_t prevent_repl_prop : 1; /* Don't propagate to replicas. */
uint64_t prevent_prop : 1; /* Don't propagate to AOF or replicas. */
uint64_t pending_write : 1; /* Client has output to send but a write handler is yet not installed. */
uint64_t pending_read : 1; /* Client has output to send but a write handler is yet not installed. */
uint64_t reply_off : 1; /* Don't send replies to client. */
uint64_t reply_skip_next : 1; /* Set CLIENT_REPLY_SKIP for next cmd */
uint64_t reply_skip : 1; /* Don't send just this reply. */
uint64_t lua_debug : 1; /* Run EVAL in debug mode. */
uint64_t lua_debug_sync : 1; /* EVAL debugging without fork() */
uint64_t module : 1; /* Non connected client used by some module. */
uint64_t protected : 1; /* Client should not be freed for now. */
uint64_t executing_command : 1; /* Indicates that the client is currently in the process of handling a command. */
uint64_t pending_command : 1; /* Indicates the client has a fully parsed command ready for execution. */
uint64_t tracking : 1; /* Client enabled keys tracking in order to perform client side caching. */
uint64_t tracking_broken_redir : 1; /* Target client is invalid. */
uint64_t tracking_bcast : 1; /* Tracking in BCAST mode. */
uint64_t tracking_optin : 1; /* Tracking in opt-in mode. */
uint64_t tracking_optout : 1; /* Tracking in opt-out mode. */
uint64_t tracking_caching : 1; /* CACHING yes/no was given, depending on optin/optout mode. */
uint64_t tracking_noloop : 1; /* Don't send invalidation messages about writes performed by myself. */
uint64_t in_to_table : 1; /* This client is in the timeout table. */
uint64_t protocol_error : 1; /* Protocol error chatting with it. */
uint64_t close_after_command : 1; /* Close after executing commands and writing entire reply. */
uint64_t deny_blocking : 1; /* Indicate that the client should not be blocked. */
uint64_t repl_rdbonly : 1; /* This client is a replica that only wants RDB without replication buffer. */
uint64_t no_evict : 1; /* This client is protected against client memory eviction. */
uint64_t allow_oom : 1; /* Client used by RM_Call is allowed to fully execute scripts even when in OOM */
uint64_t no_touch : 1; /* This client will not touch LFU/LRU stats. */
uint64_t pushing : 1; /* This client is pushing notifications. */
uint64_t module_auth_has_result : 1; /* Indicates a client in the middle of module based auth had been authenticated
from the Module. */
uint64_t primary : 1; /* This client is a primary */
uint64_t replica : 1; /* This client is a replica */
uint64_t monitor : 1; /* This client is a replica monitor, see MONITOR */
uint64_t multi : 1; /* This client is in a MULTI context */
uint64_t blocked : 1; /* The client is waiting in a blocking operation */
uint64_t dirty_cas : 1; /* Watched keys modified. EXEC will fail. */
uint64_t close_after_reply : 1; /* Close after writing entire reply. */
uint64_t unblocked : 1; /* This client was unblocked and is stored in server.unblocked_clients */
uint64_t script : 1; /* This is a non connected client used by Lua */
uint64_t asking : 1; /* Client issued the ASKING command */
uint64_t close_asap : 1; /* Close this client ASAP */
uint64_t unix_socket : 1; /* Client connected via Unix domain socket */
uint64_t dirty_exec : 1; /* EXEC will fail for errors while queueing */
uint64_t primary_force_reply : 1; /* Queue replies even if is primary */
uint64_t force_aof : 1; /* Force AOF propagation of current cmd. */
uint64_t force_repl : 1; /* Force replication of current cmd. */
uint64_t pre_psync : 1; /* Instance don't understand PSYNC. */
uint64_t readonly : 1; /* Cluster client is in read-only state. */
uint64_t pubsub : 1; /* Client is in Pub/Sub mode. */
uint64_t prevent_aof_prop : 1; /* Don't propagate to AOF. */
uint64_t prevent_repl_prop : 1; /* Don't propagate to replicas. */
uint64_t prevent_prop : 1; /* Don't propagate to AOF or replicas. */
uint64_t pending_write : 1; /* Client has output to send but a write handler is yet not installed. */
uint64_t pending_read : 1; /* Client has output to send but a write handler is yet not installed. */
uint64_t reply_off : 1; /* Don't send replies to client. */
uint64_t reply_skip_next : 1; /* Set CLIENT_REPLY_SKIP for next cmd */
uint64_t reply_skip : 1; /* Don't send just this reply. */
uint64_t lua_debug : 1; /* Run EVAL in debug mode. */
uint64_t lua_debug_sync : 1; /* EVAL debugging without fork() */
uint64_t module : 1; /* Non connected client used by some module. */
uint64_t protected : 1; /* Client should not be freed for now. */
uint64_t executing_command : 1; /* Indicates that the client is currently in the process of handling a command. */
uint64_t pending_command : 1; /* Indicates the client has a fully parsed command ready for execution. */
uint64_t tracking : 1; /* Client enabled keys tracking in order to perform client side caching. */
uint64_t tracking_broken_redir : 1; /* Target client is invalid. */
uint64_t tracking_bcast : 1; /* Tracking in BCAST mode. */
uint64_t tracking_optin : 1; /* Tracking in opt-in mode. */
uint64_t tracking_optout : 1; /* Tracking in opt-out mode. */
uint64_t tracking_caching : 1; /* CACHING yes/no was given, depending on optin/optout mode. */
uint64_t tracking_noloop : 1; /* Don't send invalidation messages about writes performed by myself. */
uint64_t in_to_table : 1; /* This client is in the timeout table. */
uint64_t protocol_error : 1; /* Protocol error chatting with it. */
uint64_t close_after_command : 1; /* Close after executing commands and writing entire reply. */
uint64_t deny_blocking : 1; /* Indicate that the client should not be blocked. */
uint64_t repl_rdbonly : 1; /* This client is a replica that only wants RDB without replication buffer. */
uint64_t no_evict : 1; /* This client is protected against client memory eviction. */
uint64_t allow_oom : 1; /* Client used by RM_Call is allowed to fully execute scripts even when in OOM */
uint64_t no_touch : 1; /* This client will not touch LFU/LRU stats. */
uint64_t pushing : 1; /* This client is pushing notifications. */
uint64_t module_auth_has_result : 1; /* Indicates a client in the middle of module based auth had been authenticated
from the Module. */
uint64_t module_prevent_aof_prop : 1; /* Module client do not want to propagate to AOF */
uint64_t module_prevent_repl_prop : 1; /* Module client do not want to propagate to replica */
uint64_t reprocessing_command : 1; /* The client is re-processing the command. */
uint64_t replication_done : 1; /* Indicate that replication has been done on the client */
uint64_t authenticated : 1; /* Indicate a client has successfully authenticated */
uint64_t
protected_rdb_channel : 1; /* Dual channel replication sync: Protects the RDB client from premature \
* release during full sync. This flag is used to ensure that the RDB client, which \
* references the first replication data block required by the replica, is not \
* released prematurely. Protecting the client is crucial for prevention of \
* synchronization failures: \
* If the RDB client is released before the replica initiates PSYNC, the primary \
* will reduce the reference count (o->refcount) of the block needed by the replica.
* \
* This could potentially lead to the removal of the required data block, resulting \
* in synchronization failures. Such failures could occur even in scenarios where \
* the replica only needs an additional 4KB beyond the minimum size of the
* repl_backlog.
* By using this flag, we ensure that the RDB client remains intact until the replica
* \ has successfully initiated PSYNC. */
uint64_t repl_rdb_channel : 1; /* Dual channel replication sync: track a connection which is used for rdb snapshot */
uint64_t dont_cache_primary : 1; /* In some cases we don't want to cache the primary. For example, the replica
* knows that it does not need the cache and required a full sync. With this
* flag, we won't cache the primary in freeClient. */
uint64_t reserved : 6; /* Reserved for future use */
uint64_t protected_rdb_channel : 1; /* Dual channel replication sync: Protects the RDB client from premature \
* release during full sync. This flag is used to ensure that the RDB client, which \
* references the first replication data block required by the replica, is not \
* released prematurely. Protecting the client is crucial for prevention of \
* synchronization failures: \
* If the RDB client is released before the replica initiates PSYNC, the primary \
* will reduce the reference count (o->refcount) of the block needed by the replica.
* \
* This could potentially lead to the removal of the required data block, resulting \
* in synchronization failures. Such failures could occur even in scenarios where \
* the replica only needs an additional 4KB beyond the minimum size of the
* repl_backlog.
* By using this flag, we ensure that the RDB client remains intact until the replica
* \ has successfully initiated PSYNC. */
uint64_t repl_rdb_channel : 1; /* Dual channel replication sync: track a connection which is used for rdb snapshot */
uint64_t dont_cache_primary : 1; /* In some cases we don't want to cache the primary. For example, the replica
* knows that it does not need the cache and required a full sync. With this
* flag, we won't cache the primary in freeClient. */
uint64_t reserved : 6; /* Reserved for future use */
} ClientFlags;
typedef struct client {
@ -1292,52 +1272,52 @@ typedef struct client {
size_t sentlen; /* Amount of bytes already sent in the current
buffer or object being sent. */
time_t ctime; /* Client creation time. */
long duration; /* Current command duration. Used for measuring latency of blocking/non-blocking cmds */
int slot; /* The slot the client is executing against. Set to -1 if no slot is being used */
dictEntry *cur_script; /* Cached pointer to the dictEntry of the script being executed. */
time_t last_interaction; /* Time of the last interaction, used for timeout */
long duration; /* Current command duration. Used for measuring latency of blocking/non-blocking cmds */
int slot; /* The slot the client is executing against. Set to -1 if no slot is being used */
dictEntry *cur_script; /* Cached pointer to the dictEntry of the script being executed. */
time_t last_interaction; /* Time of the last interaction, used for timeout */
time_t obuf_soft_limit_reached_time;
int repl_state; /* Replication state if this is a replica. */
int repl_start_cmd_stream_on_ack; /* Install replica write handler on first ACK. */
int repldbfd; /* Replication DB file descriptor. */
off_t repldboff; /* Replication DB file offset. */
off_t repldbsize; /* Replication DB file size. */
sds replpreamble; /* Replication DB preamble. */
long long read_reploff; /* Read replication offset if this is a primary. */
long long reploff; /* Applied replication offset if this is a primary. */
long long repl_applied; /* Applied replication data count in querybuf, if this is a replica. */
long long repl_ack_off; /* Replication ack offset, if this is a replica. */
long long repl_aof_off; /* Replication AOF fsync ack offset, if this is a replica. */
long long repl_ack_time; /* Replication ack time, if this is a replica. */
long long repl_last_partial_write; /* The last time the server did a partial write from the RDB child pipe to this
replica */
long long psync_initial_offset; /* FULLRESYNC reply offset other replicas
copying this replica output buffer
should use. */
char replid[CONFIG_RUN_ID_SIZE + 1]; /* primary replication ID (if primary). */
int replica_listening_port; /* As configured with: REPLCONF listening-port */
char *replica_addr; /* Optionally given by REPLCONF ip-address */
int replica_version; /* Version on the form 0xMMmmpp. */
short replica_capa; /* Replica capabilities: REPLICA_CAPA_* bitwise OR. */
short replica_req; /* Replica requirements: REPLICA_REQ_* */
uint64_t associated_rdb_client_id; /* The client id of this replica's rdb connection */
time_t rdb_client_disconnect_time; /* Time of the first freeClient call on this client. Used for delaying free. */
multiState mstate; /* MULTI/EXEC state */
blockingState bstate; /* blocking state */
long long woff; /* Last write global replication offset. */
list *watched_keys; /* Keys WATCHED for MULTI/EXEC CAS */
dict *pubsub_channels; /* channels a client is interested in (SUBSCRIBE) */
dict *pubsub_patterns; /* patterns a client is interested in (PSUBSCRIBE) */
dict *pubsubshard_channels; /* shard level channels a client is interested in (SSUBSCRIBE) */
sds peerid; /* Cached peer ID. */
sds sockname; /* Cached connection target address. */
listNode *client_list_node; /* list node in client list */
void *module_blocked_client; /* Pointer to the ValkeyModuleBlockedClient associated with this
* client. This is set in case of module authentication before the
* unblocked client is reprocessed to handle reply callbacks. */
void *module_auth_ctx; /* Ongoing / attempted module based auth callback's ctx.
* This is only tracked within the context of the command attempting
* authentication. If not NULL, it means module auth is in progress. */
int repl_state; /* Replication state if this is a replica. */
int repl_start_cmd_stream_on_ack; /* Install replica write handler on first ACK. */
int repldbfd; /* Replication DB file descriptor. */
off_t repldboff; /* Replication DB file offset. */
off_t repldbsize; /* Replication DB file size. */
sds replpreamble; /* Replication DB preamble. */
long long read_reploff; /* Read replication offset if this is a primary. */
long long reploff; /* Applied replication offset if this is a primary. */
long long repl_applied; /* Applied replication data count in querybuf, if this is a replica. */
long long repl_ack_off; /* Replication ack offset, if this is a replica. */
long long repl_aof_off; /* Replication AOF fsync ack offset, if this is a replica. */
long long repl_ack_time; /* Replication ack time, if this is a replica. */
long long repl_last_partial_write; /* The last time the server did a partial write from the RDB child pipe to this
replica */
long long psync_initial_offset; /* FULLRESYNC reply offset other replicas
copying this replica output buffer
should use. */
char replid[CONFIG_RUN_ID_SIZE + 1]; /* primary replication ID (if primary). */
int replica_listening_port; /* As configured with: REPLCONF listening-port */
char *replica_addr; /* Optionally given by REPLCONF ip-address */
int replica_version; /* Version on the form 0xMMmmpp. */
short replica_capa; /* Replica capabilities: REPLICA_CAPA_* bitwise OR. */
short replica_req; /* Replica requirements: REPLICA_REQ_* */
uint64_t associated_rdb_client_id; /* The client id of this replica's rdb connection */
time_t rdb_client_disconnect_time; /* Time of the first freeClient call on this client. Used for delaying free. */
multiState mstate; /* MULTI/EXEC state */
blockingState bstate; /* blocking state */
long long woff; /* Last write global replication offset. */
list *watched_keys; /* Keys WATCHED for MULTI/EXEC CAS */
dict *pubsub_channels; /* channels a client is interested in (SUBSCRIBE) */
dict *pubsub_patterns; /* patterns a client is interested in (PSUBSCRIBE) */
dict *pubsubshard_channels; /* shard level channels a client is interested in (SSUBSCRIBE) */
sds peerid; /* Cached peer ID. */
sds sockname; /* Cached connection target address. */
listNode *client_list_node; /* list node in client list */
void *module_blocked_client; /* Pointer to the ValkeyModuleBlockedClient associated with this
* client. This is set in case of module authentication before the
* unblocked client is reprocessed to handle reply callbacks. */
void *module_auth_ctx; /* Ongoing / attempted module based auth callback's ctx.
* This is only tracked within the context of the command attempting
* authentication. If not NULL, it means module auth is in progress. */
ValkeyModuleUserChangedFunc auth_callback; /* Module callback to execute
* when the authenticated user
* changes. */
@ -1697,22 +1677,22 @@ struct valkeyServer {
size_t initial_memory_usage; /* Bytes used after initialization. */
int always_show_logo; /* Show logo even for non-stdout logging. */
int in_exec; /* Are we inside EXEC? */
int busy_module_yield_flags; /* Are we inside a busy module? (triggered by RM_Yield). see BUSY_MODULE_YIELD_ flags. */
int busy_module_yield_flags; /* Are we inside a busy module? (triggered by RM_Yield). see BUSY_MODULE_YIELD_ flags. */
const char *busy_module_yield_reply; /* When non-null, we are inside RM_Yield. */
char *ignore_warnings; /* Config: warnings that should be ignored. */
int client_pause_in_transaction; /* Was a client pause executed during this Exec? */
int thp_enabled; /* If true, THP is enabled. */
size_t page_size; /* The page size of OS. */
/* Modules */
dict *moduleapi; /* Exported core APIs dictionary for modules. */
dict *sharedapi; /* Like moduleapi but containing the APIs that
modules share with each other. */
dict *module_configs_queue; /* Dict that stores module configurations from .conf file until after modules are loaded
during startup or arguments to loadex. */
list *loadmodule_queue; /* List of modules to load at startup. */
int module_pipe[2]; /* Pipe used to awake the event loop by module threads. */
pid_t child_pid; /* PID of current child */
int child_type; /* Type of current child */
dict *moduleapi; /* Exported core APIs dictionary for modules. */
dict *sharedapi; /* Like moduleapi but containing the APIs that
modules share with each other. */
dict *module_configs_queue; /* Dict that stores module configurations from .conf file until after modules are loaded
during startup or arguments to loadex. */
list *loadmodule_queue; /* List of modules to load at startup. */
int module_pipe[2]; /* Pipe used to awake the event loop by module threads. */
pid_t child_pid; /* PID of current child */
int child_type; /* Type of current child */
_Atomic int module_gil_acquiring; /* Indicates whether the GIL is being acquiring by the main thread. */
/* Networking */
int port; /* TCP listening port */
@ -1768,10 +1748,10 @@ struct valkeyServer {
int events_per_io_thread; /* Number of events on the event loop to trigger IO threads activation. */
int prefetch_batch_max_size; /* Maximum number of keys to prefetch in a single batch */
long long events_processed_while_blocked; /* processEventsWhileBlocked() */
int enable_protected_configs; /* Enable the modification of protected configs, see PROTECTED_ACTION_ALLOWED_* */
int enable_debug_cmd; /* Enable DEBUG commands, see PROTECTED_ACTION_ALLOWED_* */
int enable_module_cmd; /* Enable MODULE commands, see PROTECTED_ACTION_ALLOWED_* */
int enable_debug_assert; /* Enable debug asserts */
int enable_protected_configs; /* Enable the modification of protected configs, see PROTECTED_ACTION_ALLOWED_* */
int enable_debug_cmd; /* Enable DEBUG commands, see PROTECTED_ACTION_ALLOWED_* */
int enable_module_cmd; /* Enable MODULE commands, see PROTECTED_ACTION_ALLOWED_* */
int enable_debug_assert; /* Enable debug asserts */
/* RDB / AOF loading information */
volatile sig_atomic_t loading; /* We are loading data from disk if true */
@ -1822,7 +1802,7 @@ struct valkeyServer {
struct malloc_stats cron_malloc_stats; /* sampled in serverCron(). */
long long stat_net_input_bytes; /* Bytes read from network. */
long long stat_net_output_bytes; /* Bytes written to network. */
long long stat_net_repl_input_bytes; /* Bytes read during replication, added to stat_net_input_bytes in 'info'. */
long long stat_net_repl_input_bytes; /* Bytes read during replication, added to stat_net_input_bytes in 'info'. */
/* Bytes written during replication, added to stat_net_output_bytes in 'info'. */
long long stat_net_repl_output_bytes;
size_t stat_current_cow_peak; /* Peak size of copy on write bytes. */
@ -1837,8 +1817,8 @@ struct valkeyServer {
size_t stat_clients_type_memory[CLIENT_TYPE_COUNT]; /* Mem usage by type */
size_t stat_cluster_links_memory; /* Mem usage by cluster links */
long long
stat_unexpected_error_replies; /* Number of unexpected (aof-loading, replica to primary, etc.) error replies */
long long stat_total_error_replies; /* Total number of issued error replies ( command + rejected errors ) */
stat_unexpected_error_replies; /* Number of unexpected (aof-loading, replica to primary, etc.) error replies */
long long stat_total_error_replies; /* Total number of issued error replies ( command + rejected errors ) */
long long stat_dump_payload_sanitizations; /* Number deep dump payloads integrity validations. */
long long stat_io_reads_processed; /* Number of read events processed by IO threads */
long long stat_io_writes_processed; /* Number of write events processed by IO threads */
@ -1879,16 +1859,16 @@ struct valkeyServer {
int active_expire_effort; /* From 1 (default) to 10, active effort. */
int lazy_expire_disabled; /* If > 0, don't trigger lazy expire */
int active_defrag_enabled;
int sanitize_dump_payload; /* Enables deep sanitization for ziplist and listpack in RDB and RESTORE. */
int skip_checksum_validation; /* Disable checksum validation for RDB and RESTORE payload. */
int jemalloc_bg_thread; /* Enable jemalloc background thread */
int active_defrag_configuration_changed; /* defrag configuration has been changed and need to reconsider
* active_defrag_running in computeDefragCycles. */
size_t active_defrag_ignore_bytes; /* minimum amount of fragmentation waste to start active defrag */
int active_defrag_threshold_lower; /* minimum percentage of fragmentation to start active defrag */
int active_defrag_threshold_upper; /* maximum percentage of fragmentation at which we use maximum effort */
int active_defrag_cycle_min; /* minimal effort for defrag in CPU percentage */
int active_defrag_cycle_max; /* maximal effort for defrag in CPU percentage */
int sanitize_dump_payload; /* Enables deep sanitization for ziplist and listpack in RDB and RESTORE. */
int skip_checksum_validation; /* Disable checksum validation for RDB and RESTORE payload. */
int jemalloc_bg_thread; /* Enable jemalloc background thread */
int active_defrag_configuration_changed; /* defrag configuration has been changed and need to reconsider
* active_defrag_running in computeDefragCycles. */
size_t active_defrag_ignore_bytes; /* minimum amount of fragmentation waste to start active defrag */
int active_defrag_threshold_lower; /* minimum percentage of fragmentation to start active defrag */
int active_defrag_threshold_upper; /* maximum percentage of fragmentation at which we use maximum effort */
int active_defrag_cycle_min; /* minimal effort for defrag in CPU percentage */
int active_defrag_cycle_max; /* maximal effort for defrag in CPU percentage */
unsigned long active_defrag_max_scan_fields; /* maximum number of fields of set/hash/zset/list to process from
within the main dict scan */
size_t client_max_querybuf_len; /* Limit for client query buffer length */
@ -2153,14 +2133,14 @@ struct valkeyServer {
unsigned int pubsub_clients; /* # of clients in Pub/Sub mode */
unsigned int watching_clients; /* # of clients are watching keys */
/* Cluster */
int cluster_enabled; /* Is cluster enabled? */
int cluster_port; /* Set the cluster port for a node. */
mstime_t cluster_node_timeout; /* Cluster node timeout. */
mstime_t cluster_ping_interval; /* A debug configuration for setting how often cluster nodes send ping messages. */
char *cluster_configfile; /* Cluster auto-generated config file name. */
struct clusterState *cluster; /* State of the cluster */
int cluster_migration_barrier; /* Cluster replicas migration barrier. */
int cluster_allow_replica_migration; /* Automatic replica migrations to orphaned primaries and from empty primaries */
int cluster_enabled; /* Is cluster enabled? */
int cluster_port; /* Set the cluster port for a node. */
mstime_t cluster_node_timeout; /* Cluster node timeout. */
mstime_t cluster_ping_interval; /* A debug configuration for setting how often cluster nodes send ping messages. */
char *cluster_configfile; /* Cluster auto-generated config file name. */
struct clusterState *cluster; /* State of the cluster */
int cluster_migration_barrier; /* Cluster replicas migration barrier. */
int cluster_allow_replica_migration; /* Automatic replica migrations to orphaned primaries and from empty primaries */
int cluster_replica_validity_factor; /* Replica max data age for failover. */
int cluster_require_full_coverage; /* If true, put the cluster down if
there is at least an uncovered slot.*/
@ -2238,9 +2218,9 @@ struct valkeyServer {
int failover_state; /* Failover state */
int cluster_allow_pubsubshard_when_down; /* Is pubsubshard allowed when the cluster
is down, doesn't affect pubsub global. */
long reply_buffer_peak_reset_time; /* The amount of time (in milliseconds) to wait between reply buffer peak resets */
int reply_buffer_resizing_enabled; /* Is reply buffer resizing enabled (1 by default) */
sds availability_zone; /* When run in a cloud environment we can configure the availability zone it is running in */
long reply_buffer_peak_reset_time; /* The amount of time (in milliseconds) to wait between reply buffer peak resets */
int reply_buffer_resizing_enabled; /* Is reply buffer resizing enabled (1 by default) */
sds availability_zone; /* When run in a cloud environment we can configure the availability zone it is running in */
/* Local environment */
char *locale_collate;
char *debug_context; /* A free-form string that has no impact on server except being included in a crash report. */
@ -3158,7 +3138,12 @@ void ACLInit(void);
#define ACL_ALL_PERMISSION (ACL_READ_PERMISSION | ACL_WRITE_PERMISSION)
/* Return codes for Authentication functions to indicate the result. */
typedef enum { AUTH_OK = 0, AUTH_ERR, AUTH_NOT_HANDLED, AUTH_BLOCKED } AuthResult;
typedef enum {
AUTH_OK = 0,
AUTH_ERR,
AUTH_NOT_HANDLED,
AUTH_BLOCKED
} AuthResult;
int ACLCheckUserCredentials(robj *username, robj *password);
int ACLAuthenticateUser(client *c, robj *username, robj *password, robj **err);
@ -3423,8 +3408,7 @@ sds keyspaceEventsFlagsToString(int flags);
/* Configuration */
/* Configuration Flags */
#define MODIFIABLE_CONFIG \
0 /* This is the implied default for a standard \
#define MODIFIABLE_CONFIG 0 /* This is the implied default for a standard \
* config, which is mutable. */
#define IMMUTABLE_CONFIG (1ULL << 0) /* Can this value only be set at startup? */
#define SENSITIVE_CONFIG (1ULL << 1) /* Does this value contain sensitive information */
@ -3435,11 +3419,10 @@ sds keyspaceEventsFlagsToString(int flags);
#define DENY_LOADING_CONFIG (1ULL << 6) /* This config is forbidden during loading. */
#define ALIAS_CONFIG (1ULL << 7) /* For configs with multiple names, this flag is set on the alias. */
#define MODULE_CONFIG (1ULL << 8) /* This config is a module config */
#define VOLATILE_CONFIG \
(1ULL << 9) /* The config is a reference to the config data and not the config data itself (ex. \
* a file name containing more configuration like a tls key). In this case we want \
* to apply the configuration change even if the new config value is the same as \
* the old. */
#define VOLATILE_CONFIG (1ULL << 9) /* The config is a reference to the config data and not the config data itself (ex. \
* a file name containing more configuration like a tls key). In this case we want \
* to apply the configuration change even if the new config value is the same as \
* the old. */
#define INTEGER_CONFIG 0 /* No flags means a simple integer configuration */
#define MEMORY_CONFIG (1 << 0) /* Indicates if this value can be loaded as a memory value */
@ -3532,7 +3515,7 @@ int objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle, long lo
#define LOOKUP_NOSTATS (1 << 2) /* Don't update keyspace hits/misses counters. */
#define LOOKUP_WRITE (1 << 3) /* Delete expired keys even in replicas. */
#define LOOKUP_NOEXPIRE (1 << 4) /* Avoid deleting lazy expired keys. */
#define LOOKUP_NOEFFECTS \
#define LOOKUP_NOEFFECTS \
(LOOKUP_NONOTIFY | LOOKUP_NOSTATS | LOOKUP_NOTOUCH | LOOKUP_NOEXPIRE) /* Avoid any effects from fetching the key */
void dbAdd(serverDb *db, robj *key, robj *val);
@ -4025,10 +4008,10 @@ void debugPauseProcess(void);
/* Use macro for checking log level to avoid evaluating arguments in cases log
* should be ignored due to low level. */
#define serverLog(level, ...) \
do { \
if (((level) & 0xff) < server.verbosity) break; \
_serverLog(level, __VA_ARGS__); \
#define serverLog(level, ...) \
do { \
if (((level) & 0xff) < server.verbosity) break; \
_serverLog(level, __VA_ARGS__); \
} while (0)
#define serverDebug(fmt, ...) printf("DEBUG %s:%d > " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)

22
src/slowlog.c
View File

@ -131,20 +131,18 @@ void slowlogReset(void) {
* slow log. */
void slowlogCommand(client *c) {
if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr, "help")) {
/* clang-format off */
const char *help[] = {
"GET [<count>]",
" Return top <count> entries from the slowlog (default: 10, -1 mean all).",
" Entries are made of:",
" id, timestamp, time in microseconds, arguments array, client IP and port,",
" client name",
"LEN",
" Return the length of the slowlog.",
"RESET",
" Reset the slowlog.",
NULL
"GET [<count>]",
" Return top <count> entries from the slowlog (default: 10, -1 mean all).",
" Entries are made of:",
" id, timestamp, time in microseconds, arguments array, client IP and port,",
" client name",
"LEN",
" Return the length of the slowlog.",
"RESET",
" Reset the slowlog.",
NULL,
};
/* clang-format on */
addReplyHelp(c, help);
} else if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr, "reset")) {
slowlogReset();

24
src/solarisfixes.h
View File

@ -33,24 +33,24 @@
#if defined(__GNUC__)
#include <math.h>
#undef isnan
#define isnan(x) \
__extension__({ \
__typeof(x) __x_a = (x); \
__builtin_expect(__x_a != __x_a, 0); \
#define isnan(x) \
__extension__({ \
__typeof(x) __x_a = (x); \
__builtin_expect(__x_a != __x_a, 0); \
})
#undef isfinite
#define isfinite(x) \
__extension__({ \
__typeof(x) __x_f = (x); \
__builtin_expect(!isnan(__x_f - __x_f), 1); \
#define isfinite(x) \
__extension__({ \
__typeof(x) __x_f = (x); \
__builtin_expect(!isnan(__x_f - __x_f), 1); \
})
#undef isinf
#define isinf(x) \
__extension__({ \
__typeof(x) __x_i = (x); \
__builtin_expect(!isnan(__x_i) && !isfinite(__x_i), 0); \
#define isinf(x) \
__extension__({ \
__typeof(x) __x_i = (x); \
__builtin_expect(!isnan(__x_i) && !isfinite(__x_i), 0); \
})
#define u_int uint

54
src/t_stream.c
View File

@ -769,7 +769,7 @@ int64_t streamTrim(stream *s, streamAddTrimArgs *args) {
int64_t primary_fields_count = lpGetInteger(p);
p = lpNext(lp, p); /* Skip the first field. */
for (int64_t j = 0; j < primary_fields_count; j++) p = lpNext(lp, p); /* Skip all primary fields. */
p = lpNext(lp, p); /* Skip the zero primary entry terminator. */
p = lpNext(lp, p); /* Skip the zero primary entry terminator. */
/* 'p' is now pointing to the first entry inside the listpack.
* We have to run entry after entry, marking entries as deleted
@ -1641,8 +1641,8 @@ void streamPropagateConsumerCreation(client *c, robj *key, robj *groupname, sds
* flag.
*/
#define STREAM_RWR_NOACK (1 << 0) /* Do not create entries in the PEL. */
#define STREAM_RWR_RAWENTRIES \
(1 << 1) /* Do not emit protocol for array \
#define STREAM_RWR_RAWENTRIES \
(1 << 1) /* Do not emit protocol for array \
boundaries, just the entries. */
#define STREAM_RWR_HISTORY (1 << 2) /* Only serve consumer local PEL. */
size_t streamReplyWithRange(client *c,
@ -2610,25 +2610,23 @@ void xgroupCommand(client *c) {
/* Dispatch the different subcommands. */
if (c->argc == 2 && !strcasecmp(opt, "HELP")) {
/* clang-format off */
const char *help[] = {
"CREATE <key> <groupname> <id|$> [option]",
" Create a new consumer group. Options are:",
" * MKSTREAM",
" Create the empty stream if it does not exist.",
" * ENTRIESREAD entries_read",
" Set the group's entries_read counter (internal use).",
"CREATECONSUMER <key> <groupname> <consumer>",
" Create a new consumer in the specified group.",
"DELCONSUMER <key> <groupname> <consumer>",
" Remove the specified consumer.",
"DESTROY <key> <groupname>",
" Remove the specified group.",
"SETID <key> <groupname> <id|$> [ENTRIESREAD entries_read]",
" Set the current group ID and entries_read counter.",
NULL
"CREATE <key> <groupname> <id|$> [option]",
" Create a new consumer group. Options are:",
" * MKSTREAM",
" Create the empty stream if it does not exist.",
" * ENTRIESREAD entries_read",
" Set the group's entries_read counter (internal use).",
"CREATECONSUMER <key> <groupname> <consumer>",
" Create a new consumer in the specified group.",
"DELCONSUMER <key> <groupname> <consumer>",
" Remove the specified consumer.",
"DESTROY <key> <groupname>",
" Remove the specified group.",
"SETID <key> <groupname> <id|$> [ENTRIESREAD entries_read]",
" Set the current group ID and entries_read counter.",
NULL,
};
/* clang-format on */
addReplyHelp(c, help);
} else if (!strcasecmp(opt, "CREATE") && (c->argc >= 5 && c->argc <= 8)) {
streamID id;
@ -3798,17 +3796,15 @@ void xinfoCommand(client *c) {
/* HELP is special. Handle it ASAP. */
if (!strcasecmp(c->argv[1]->ptr, "HELP")) {
/* clang-format off */
const char *help[] = {
"CONSUMERS <key> <groupname>",
" Show consumers of <groupname>.",
"GROUPS <key>",
" Show the stream consumer groups.",
"STREAM <key> [FULL [COUNT <count>]",
" Show information about the stream.",
NULL
"CONSUMERS <key> <groupname>",
" Show consumers of <groupname>.",
"GROUPS <key>",
" Show the stream consumer groups.",
"STREAM <key> [FULL [COUNT <count>]",
" Show information about the stream.",
NULL,
};
/* clang-format on */
addReplyHelp(c, help);
return;
}

316
src/t_string.c
View File

@ -299,7 +299,7 @@ int parseExtendedStringArgumentsOrReply(client *c, int *flags, int *unit, robj *
addReplyErrorObject(c,shared.syntaxerr);
return C_ERR;
}
/* clang-format off */
/* clang-format on */
}
return C_OK;
}
@ -311,40 +311,40 @@ void setCommand(client *c) {
int unit = UNIT_SECONDS;
int flags = OBJ_NO_FLAGS;
if (parseExtendedStringArgumentsOrReply(c,&flags,&unit,&expire,COMMAND_SET) != C_OK) {
if (parseExtendedStringArgumentsOrReply(c, &flags, &unit, &expire, COMMAND_SET) != C_OK) {
return;
}
c->argv[2] = tryObjectEncoding(c->argv[2]);
setGenericCommand(c,flags,c->argv[1],c->argv[2],expire,unit,NULL,NULL);
setGenericCommand(c, flags, c->argv[1], c->argv[2], expire, unit, NULL, NULL);
}
void setnxCommand(client *c) {
c->argv[2] = tryObjectEncoding(c->argv[2]);
setGenericCommand(c,OBJ_SET_NX,c->argv[1],c->argv[2],NULL,0,shared.cone,shared.czero);
setGenericCommand(c, OBJ_SET_NX, c->argv[1], c->argv[2], NULL, 0, shared.cone, shared.czero);
}
void setexCommand(client *c) {
c->argv[3] = tryObjectEncoding(c->argv[3]);
setGenericCommand(c,OBJ_EX,c->argv[1],c->argv[3],c->argv[2],UNIT_SECONDS,NULL,NULL);
setGenericCommand(c, OBJ_EX, c->argv[1], c->argv[3], c->argv[2], UNIT_SECONDS, NULL, NULL);
}
void psetexCommand(client *c) {
c->argv[3] = tryObjectEncoding(c->argv[3]);
setGenericCommand(c,OBJ_PX,c->argv[1],c->argv[3],c->argv[2],UNIT_MILLISECONDS,NULL,NULL);
setGenericCommand(c, OBJ_PX, c->argv[1], c->argv[3], c->argv[2], UNIT_MILLISECONDS, NULL, NULL);
}
int getGenericCommand(client *c) {
robj *o;
if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.null[c->resp])) == NULL)
if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.null[c->resp])) == NULL)
return C_OK;
if (checkType(c,o,OBJ_STRING)) {
if (checkType(c, o, OBJ_STRING)) {
return C_ERR;
}
addReplyBulk(c,o);
addReplyBulk(c, o);
return C_OK;
}
@ -377,16 +377,16 @@ void getexCommand(client *c) {
int unit = UNIT_SECONDS;
int flags = OBJ_NO_FLAGS;
if (parseExtendedStringArgumentsOrReply(c,&flags,&unit,&expire,COMMAND_GET) != C_OK) {
if (parseExtendedStringArgumentsOrReply(c, &flags, &unit, &expire, COMMAND_GET) != C_OK) {
return;
}
robj *o;
if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.null[c->resp])) == NULL)
if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.null[c->resp])) == NULL)
return;
if (checkType(c,o,OBJ_STRING)) {
if (checkType(c, o, OBJ_STRING)) {
return;
}
@ -397,7 +397,7 @@ void getexCommand(client *c) {
}
/* We need to do this before we expire the key or delete it */
addReplyBulk(c,o);
addReplyBulk(c, o);
/* This command is never propagated as is. It is either propagated as PEXPIRE[AT],DEL,UNLINK or PERSIST.
* This why it doesn't need special handling in feedAppendOnlyFile to convert relative expire time to absolute one. */
@ -406,20 +406,20 @@ void getexCommand(client *c) {
* has already elapsed so delete the key in that case. */
deleteExpiredKeyFromOverwriteAndPropagate(c, c->argv[1]);
} else if (expire) {
setExpire(c,c->db,c->argv[1],milliseconds);
setExpire(c, c->db, c->argv[1], milliseconds);
/* Propagate as PXEXPIREAT millisecond-timestamp if there is
* EX/PX/EXAT/PXAT flag and the key has not expired. */
robj *milliseconds_obj = createStringObjectFromLongLong(milliseconds);
rewriteClientCommandVector(c,3,shared.pexpireat,c->argv[1],milliseconds_obj);
rewriteClientCommandVector(c, 3, shared.pexpireat, c->argv[1], milliseconds_obj);
decrRefCount(milliseconds_obj);
signalModifiedKey(c, c->db, c->argv[1]);
notifyKeyspaceEvent(NOTIFY_GENERIC,"expire",c->argv[1],c->db->id);
notifyKeyspaceEvent(NOTIFY_GENERIC, "expire", c->argv[1], c->db->id);
server.dirty++;
} else if (flags & OBJ_PERSIST) {
if (removeExpire(c->db, c->argv[1])) {
signalModifiedKey(c, c->db, c->argv[1]);
rewriteClientCommandVector(c, 2, shared.persist, c->argv[1]);
notifyKeyspaceEvent(NOTIFY_GENERIC,"persist",c->argv[1],c->db->id);
notifyKeyspaceEvent(NOTIFY_GENERIC, "persist", c->argv[1], c->db->id);
server.dirty++;
}
}
@ -429,7 +429,7 @@ void getdelCommand(client *c) {
if (getGenericCommand(c) == C_ERR) return;
if (dbSyncDelete(c->db, c->argv[1])) {
/* Propagate as DEL command */
rewriteClientCommandVector(c,2,shared.del,c->argv[1]);
rewriteClientCommandVector(c, 2, shared.del, c->argv[1]);
signalModifiedKey(c, c->db, c->argv[1]);
notifyKeyspaceEvent(NOTIFY_GENERIC, "del", c->argv[1], c->db->id);
server.dirty++;
@ -439,12 +439,12 @@ void getdelCommand(client *c) {
void getsetCommand(client *c) {
if (getGenericCommand(c) == C_ERR) return;
c->argv[2] = tryObjectEncoding(c->argv[2]);
setKey(c,c->db,c->argv[1],c->argv[2],0);
notifyKeyspaceEvent(NOTIFY_STRING,"set",c->argv[1],c->db->id);
setKey(c, c->db, c->argv[1], c->argv[2], 0);
notifyKeyspaceEvent(NOTIFY_STRING, "set", c->argv[1], c->db->id);
server.dirty++;
/* Propagate as SET command */
rewriteClientCommandArgument(c,0,shared.set);
rewriteClientCommandArgument(c, 0, shared.set);
}
void setrangeCommand(client *c) {
@ -452,59 +452,59 @@ void setrangeCommand(client *c) {
long offset;
sds value = c->argv[3]->ptr;
if (getLongFromObjectOrReply(c,c->argv[2],&offset,NULL) != C_OK)
if (getLongFromObjectOrReply(c, c->argv[2], &offset, NULL) != C_OK)
return;
if (offset < 0) {
addReplyError(c,"offset is out of range");
addReplyError(c, "offset is out of range");
return;
}
o = lookupKeyWrite(c->db,c->argv[1]);
o = lookupKeyWrite(c->db, c->argv[1]);
if (o == NULL) {
/* Return 0 when setting nothing on a non-existing string */
if (sdslen(value) == 0) {
addReply(c,shared.czero);
addReply(c, shared.czero);
return;
}
/* Return when the resulting string exceeds allowed size */
if (checkStringLength(c,offset,sdslen(value)) != C_OK)
if (checkStringLength(c, offset, sdslen(value)) != C_OK)
return;
o = createObject(OBJ_STRING,sdsnewlen(NULL, offset+sdslen(value)));
dbAdd(c->db,c->argv[1],o);
o = createObject(OBJ_STRING, sdsnewlen(NULL, offset + sdslen(value)));
dbAdd(c->db, c->argv[1], o);
} else {
size_t olen;
/* Key exists, check type */
if (checkType(c,o,OBJ_STRING))
if (checkType(c, o, OBJ_STRING))
return;
/* Return existing string length when setting nothing */
olen = stringObjectLen(o);
if (sdslen(value) == 0) {
addReplyLongLong(c,olen);
addReplyLongLong(c, olen);
return;
}
/* Return when the resulting string exceeds allowed size */
if (checkStringLength(c,offset,sdslen(value)) != C_OK)
if (checkStringLength(c, offset, sdslen(value)) != C_OK)
return;
/* Create a copy when the object is shared or encoded. */
o = dbUnshareStringValue(c->db,c->argv[1],o);
o = dbUnshareStringValue(c->db, c->argv[1], o);
}
if (sdslen(value) > 0) {
o->ptr = sdsgrowzero(o->ptr,offset+sdslen(value));
memcpy((char*)o->ptr+offset,value,sdslen(value));
signalModifiedKey(c,c->db,c->argv[1]);
o->ptr = sdsgrowzero(o->ptr, offset + sdslen(value));
memcpy((char *)o->ptr + offset, value, sdslen(value));
signalModifiedKey(c, c->db, c->argv[1]);
notifyKeyspaceEvent(NOTIFY_STRING,
"setrange",c->argv[1],c->db->id);
"setrange", c->argv[1], c->db->id);
server.dirty++;
}
addReplyLongLong(c,sdslen(o->ptr));
addReplyLongLong(c, sdslen(o->ptr));
}
void getrangeCommand(client *c) {
@ -513,16 +513,16 @@ void getrangeCommand(client *c) {
char *str, llbuf[32];
size_t strlen;
if (getLongLongFromObjectOrReply(c,c->argv[2],&start,NULL) != C_OK)
if (getLongLongFromObjectOrReply(c, c->argv[2], &start, NULL) != C_OK)
return;
if (getLongLongFromObjectOrReply(c,c->argv[3],&end,NULL) != C_OK)
if (getLongLongFromObjectOrReply(c, c->argv[3], &end, NULL) != C_OK)
return;
if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptybulk)) == NULL ||
checkType(c,o,OBJ_STRING)) return;
if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.emptybulk)) == NULL ||
checkType(c, o, OBJ_STRING)) return;
if (o->encoding == OBJ_ENCODING_INT) {
str = llbuf;
strlen = ll2string(llbuf,sizeof(llbuf),(long)o->ptr);
strlen = ll2string(llbuf, sizeof(llbuf), (long)o->ptr);
} else {
str = o->ptr;
strlen = sdslen(str);
@ -530,37 +530,37 @@ void getrangeCommand(client *c) {
/* Convert negative indexes */
if (start < 0 && end < 0 && start > end) {
addReply(c,shared.emptybulk);
addReply(c, shared.emptybulk);
return;
}
if (start < 0) start = strlen+start;
if (end < 0) end = strlen+end;
if (start < 0) start = strlen + start;
if (end < 0) end = strlen + end;
if (start < 0) start = 0;
if (end < 0) end = 0;
if ((unsigned long long)end >= strlen) end = strlen-1;
if ((unsigned long long)end >= strlen) end = strlen - 1;
/* Precondition: end >= 0 && end < strlen, so the only condition where
* nothing can be returned is: start > end. */
if (start > end || strlen == 0) {
addReply(c,shared.emptybulk);
addReply(c, shared.emptybulk);
} else {
addReplyBulkCBuffer(c,(char*)str+start,end-start+1);
addReplyBulkCBuffer(c, (char *)str + start, end - start + 1);
}
}
void mgetCommand(client *c) {
int j;
addReplyArrayLen(c,c->argc-1);
addReplyArrayLen(c, c->argc - 1);
for (j = 1; j < c->argc; j++) {
robj *o = lookupKeyRead(c->db,c->argv[j]);
robj *o = lookupKeyRead(c->db, c->argv[j]);
if (o == NULL) {
addReplyNull(c);
} else {
if (o->type != OBJ_STRING) {
addReplyNull(c);
} else {
addReplyBulk(c,o);
addReplyBulk(c, o);
}
}
}
@ -578,7 +578,7 @@ void msetGenericCommand(client *c, int nx) {
* set anything if at least one key already exists. */
if (nx) {
for (j = 1; j < c->argc; j += 2) {
if (lookupKeyWrite(c->db,c->argv[j]) != NULL) {
if (lookupKeyWrite(c->db, c->argv[j]) != NULL) {
addReply(c, shared.czero);
return;
}
@ -587,74 +587,73 @@ void msetGenericCommand(client *c, int nx) {
int setkey_flags = nx ? SETKEY_DOESNT_EXIST : 0;
for (j = 1; j < c->argc; j += 2) {
c->argv[j+1] = tryObjectEncoding(c->argv[j+1]);
c->argv[j + 1] = tryObjectEncoding(c->argv[j + 1]);
setKey(c, c->db, c->argv[j], c->argv[j + 1], setkey_flags);
notifyKeyspaceEvent(NOTIFY_STRING,"set",c->argv[j],c->db->id);
notifyKeyspaceEvent(NOTIFY_STRING, "set", c->argv[j], c->db->id);
/* In MSETNX, It could be that we're overriding the same key, we can't be sure it doesn't exist. */
if (nx)
setkey_flags = SETKEY_ADD_OR_UPDATE;
}
server.dirty += (c->argc-1)/2;
server.dirty += (c->argc - 1) / 2;
addReply(c, nx ? shared.cone : shared.ok);
}
void msetCommand(client *c) {
msetGenericCommand(c,0);
msetGenericCommand(c, 0);
}
void msetnxCommand(client *c) {
msetGenericCommand(c,1);
msetGenericCommand(c, 1);
}
void incrDecrCommand(client *c, long long incr) {
long long value, oldvalue;
robj *o, *new;
o = lookupKeyWrite(c->db,c->argv[1]);
if (checkType(c,o,OBJ_STRING)) return;
if (getLongLongFromObjectOrReply(c,o,&value,NULL) != C_OK) return;
o = lookupKeyWrite(c->db, c->argv[1]);
if (checkType(c, o, OBJ_STRING)) return;
if (getLongLongFromObjectOrReply(c, o, &value, NULL) != C_OK) return;
oldvalue = value;
if ((incr < 0 && oldvalue < 0 && incr < (LLONG_MIN-oldvalue)) ||
(incr > 0 && oldvalue > 0 && incr > (LLONG_MAX-oldvalue))) {
addReplyError(c,"increment or decrement would overflow");
if ((incr < 0 && oldvalue < 0 && incr < (LLONG_MIN - oldvalue)) ||
(incr > 0 && oldvalue > 0 && incr > (LLONG_MAX - oldvalue))) {
addReplyError(c, "increment or decrement would overflow");
return;
}
value += incr;
if (o && o->refcount == 1 && o->encoding == OBJ_ENCODING_INT &&
(value < 0 || value >= OBJ_SHARED_INTEGERS) &&
value >= LONG_MIN && value <= LONG_MAX)
{
value >= LONG_MIN && value <= LONG_MAX) {
new = o;
o->ptr = (void*)((long)value);
o->ptr = (void *)((long)value);
} else {
new = createStringObjectFromLongLongForValue(value);
if (o) {
dbReplaceValue(c->db,c->argv[1],new);
dbReplaceValue(c->db, c->argv[1], new);
} else {
dbAdd(c->db,c->argv[1],new);
dbAdd(c->db, c->argv[1], new);
}
}
signalModifiedKey(c,c->db,c->argv[1]);
notifyKeyspaceEvent(NOTIFY_STRING,"incrby",c->argv[1],c->db->id);
signalModifiedKey(c, c->db, c->argv[1]);
notifyKeyspaceEvent(NOTIFY_STRING, "incrby", c->argv[1], c->db->id);
server.dirty++;
addReplyLongLong(c, value);
}
void incrCommand(client *c) {
incrDecrCommand(c,1);
incrDecrCommand(c, 1);
}
void decrCommand(client *c) {
incrDecrCommand(c,-1);
incrDecrCommand(c, -1);
}
void incrbyCommand(client *c) {
long long incr;
if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != C_OK) return;
incrDecrCommand(c,incr);
incrDecrCommand(c, incr);
}
void decrbyCommand(client *c) {
@ -666,79 +665,79 @@ void decrbyCommand(client *c) {
addReplyError(c, "decrement would overflow");
return;
}
incrDecrCommand(c,-incr);
incrDecrCommand(c, -incr);
}
void incrbyfloatCommand(client *c) {
long double incr, value;
robj *o, *new;
o = lookupKeyWrite(c->db,c->argv[1]);
if (checkType(c,o,OBJ_STRING)) return;
if (getLongDoubleFromObjectOrReply(c,o,&value,NULL) != C_OK ||
getLongDoubleFromObjectOrReply(c,c->argv[2],&incr,NULL) != C_OK)
o = lookupKeyWrite(c->db, c->argv[1]);
if (checkType(c, o, OBJ_STRING)) return;
if (getLongDoubleFromObjectOrReply(c, o, &value, NULL) != C_OK ||
getLongDoubleFromObjectOrReply(c, c->argv[2], &incr, NULL) != C_OK)
return;
value += incr;
if (isnan(value) || isinf(value)) {
addReplyError(c,"increment would produce NaN or Infinity");
addReplyError(c, "increment would produce NaN or Infinity");
return;
}
new = createStringObjectFromLongDouble(value,1);
new = createStringObjectFromLongDouble(value, 1);
if (o)
dbReplaceValue(c->db,c->argv[1],new);
dbReplaceValue(c->db, c->argv[1], new);
else
dbAdd(c->db,c->argv[1],new);
signalModifiedKey(c,c->db,c->argv[1]);
notifyKeyspaceEvent(NOTIFY_STRING,"incrbyfloat",c->argv[1],c->db->id);
dbAdd(c->db, c->argv[1], new);
signalModifiedKey(c, c->db, c->argv[1]);
notifyKeyspaceEvent(NOTIFY_STRING, "incrbyfloat", c->argv[1], c->db->id);
server.dirty++;
addReplyBulk(c,new);
addReplyBulk(c, new);
/* Always replicate INCRBYFLOAT as a SET command with the final value
* in order to make sure that differences in float precision or formatting
* will not create differences in replicas or after an AOF restart. */
rewriteClientCommandArgument(c,0,shared.set);
rewriteClientCommandArgument(c,2,new);
rewriteClientCommandArgument(c,3,shared.keepttl);
rewriteClientCommandArgument(c, 0, shared.set);
rewriteClientCommandArgument(c, 2, new);
rewriteClientCommandArgument(c, 3, shared.keepttl);
}
void appendCommand(client *c) {
size_t totlen;
robj *o, *append;
o = lookupKeyWrite(c->db,c->argv[1]);
o = lookupKeyWrite(c->db, c->argv[1]);
if (o == NULL) {
/* Create the key */
c->argv[2] = tryObjectEncoding(c->argv[2]);
dbAdd(c->db,c->argv[1],c->argv[2]);
dbAdd(c->db, c->argv[1], c->argv[2]);
incrRefCount(c->argv[2]);
totlen = stringObjectLen(c->argv[2]);
} else {
/* Key exists, check type */
if (checkType(c,o,OBJ_STRING))
if (checkType(c, o, OBJ_STRING))
return;
/* "append" is an argument, so always an sds */
append = c->argv[2];
if (checkStringLength(c,stringObjectLen(o),sdslen(append->ptr)) != C_OK)
if (checkStringLength(c, stringObjectLen(o), sdslen(append->ptr)) != C_OK)
return;
/* Append the value */
o = dbUnshareStringValue(c->db,c->argv[1],o);
o->ptr = sdscatlen(o->ptr,append->ptr,sdslen(append->ptr));
o = dbUnshareStringValue(c->db, c->argv[1], o);
o->ptr = sdscatlen(o->ptr, append->ptr, sdslen(append->ptr));
totlen = sdslen(o->ptr);
}
signalModifiedKey(c,c->db,c->argv[1]);
notifyKeyspaceEvent(NOTIFY_STRING,"append",c->argv[1],c->db->id);
signalModifiedKey(c, c->db, c->argv[1]);
notifyKeyspaceEvent(NOTIFY_STRING, "append", c->argv[1], c->db->id);
server.dirty++;
addReplyLongLong(c,totlen);
addReplyLongLong(c, totlen);
}
void strlenCommand(client *c) {
robj *o;
if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
checkType(c,o,OBJ_STRING)) return;
addReplyLongLong(c,stringObjectLen(o));
if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.czero)) == NULL ||
checkType(c, o, OBJ_STRING)) return;
addReplyLongLong(c, stringObjectLen(o));
}
/* LCS key1 key2 [LEN] [IDX] [MINMATCHLEN <len>] [WITHMATCHLEN] */
@ -749,41 +748,39 @@ void lcsCommand(client *c) {
int getlen = 0, getidx = 0, withmatchlen = 0;
robj *obja = NULL, *objb = NULL;
obja = lookupKeyRead(c->db,c->argv[1]);
objb = lookupKeyRead(c->db,c->argv[2]);
obja = lookupKeyRead(c->db, c->argv[1]);
objb = lookupKeyRead(c->db, c->argv[2]);
if ((obja && obja->type != OBJ_STRING) ||
(objb && objb->type != OBJ_STRING))
{
(objb && objb->type != OBJ_STRING)) {
addReplyError(c,
"The specified keys must contain string values");
"The specified keys must contain string values");
/* Don't cleanup the objects, we need to do that
* only after calling getDecodedObject(). */
obja = NULL;
objb = NULL;
goto cleanup;
}
obja = obja ? getDecodedObject(obja) : createStringObject("",0);
objb = objb ? getDecodedObject(objb) : createStringObject("",0);
obja = obja ? getDecodedObject(obja) : createStringObject("", 0);
objb = objb ? getDecodedObject(objb) : createStringObject("", 0);
a = obja->ptr;
b = objb->ptr;
for (j = 3; j < (uint32_t)c->argc; j++) {
char *opt = c->argv[j]->ptr;
int moreargs = (c->argc-1) - j;
int moreargs = (c->argc - 1) - j;
if (!strcasecmp(opt,"IDX")) {
if (!strcasecmp(opt, "IDX")) {
getidx = 1;
} else if (!strcasecmp(opt,"LEN")) {
} else if (!strcasecmp(opt, "LEN")) {
getlen = 1;
} else if (!strcasecmp(opt,"WITHMATCHLEN")) {
} else if (!strcasecmp(opt, "WITHMATCHLEN")) {
withmatchlen = 1;
} else if (!strcasecmp(opt,"MINMATCHLEN") && moreargs) {
if (getLongLongFromObjectOrReply(c,c->argv[j+1],&minmatchlen,NULL)
!= C_OK) goto cleanup;
} else if (!strcasecmp(opt, "MINMATCHLEN") && moreargs) {
if (getLongLongFromObjectOrReply(c, c->argv[j + 1], &minmatchlen, NULL) != C_OK) goto cleanup;
if (minmatchlen < 0) minmatchlen = 0;
j++;
} else {
addReplyErrorObject(c,shared.syntaxerr);
addReplyErrorObject(c, shared.syntaxerr);
goto cleanup;
}
}
@ -791,12 +788,12 @@ void lcsCommand(client *c) {
/* Complain if the user passed ambiguous parameters. */
if (getlen && getidx) {
addReplyError(c,
"If you want both the length and indexes, please just use IDX.");
"If you want both the length and indexes, please just use IDX.");
goto cleanup;
}
/* Detect string truncation or later overflows. */
if (sdslen(a) >= UINT32_MAX-1 || sdslen(b) >= UINT32_MAX-1) {
if (sdslen(a) >= UINT32_MAX - 1 || sdslen(b) >= UINT32_MAX - 1) {
addReplyError(c, "String too long for LCS");
goto cleanup;
}
@ -806,13 +803,13 @@ void lcsCommand(client *c) {
uint32_t alen = sdslen(a);
uint32_t blen = sdslen(b);
/* Setup an uint32_t array to store at LCS[i,j] the length of the
* LCS A0..i-1, B0..j-1. Note that we have a linear array here, so
* we index it as LCS[j+(blen+1)*i] */
#define LCS(A,B) lcs[(B)+((A)*(blen+1))]
/* Setup an uint32_t array to store at LCS[i,j] the length of the
* LCS A0..i-1, B0..j-1. Note that we have a linear array here, so
* we index it as LCS[j+(blen+1)*i] */
#define LCS(A, B) lcs[(B) + ((A) * (blen + 1))]
/* Try to allocate the LCS table, and abort on overflow or insufficient memory. */
unsigned long long lcssize = (unsigned long long)(alen+1)*(blen+1); /* Can't overflow due to the size limits above. */
unsigned long long lcssize = (unsigned long long)(alen + 1) * (blen + 1); /* Can't overflow due to the size limits above. */
unsigned long long lcsalloc = lcssize * sizeof(uint32_t);
uint32_t *lcs = NULL;
if (lcsalloc < SIZE_MAX && lcsalloc / lcssize == sizeof(uint32_t)) {
@ -833,60 +830,60 @@ void lcsCommand(client *c) {
if (i == 0 || j == 0) {
/* If one substring has length of zero, the
* LCS length is zero. */
LCS(i,j) = 0;
} else if (a[i-1] == b[j-1]) {
LCS(i, j) = 0;
} else if (a[i - 1] == b[j - 1]) {
/* The len LCS (and the LCS itself) of two
* sequences with the same final character, is the
* LCS of the two sequences without the last char
* plus that last char. */
LCS(i,j) = LCS(i-1,j-1)+1;
LCS(i, j) = LCS(i - 1, j - 1) + 1;
} else {
/* If the last character is different, take the longest
* between the LCS of the first string and the second
* minus the last char, and the reverse. */
uint32_t lcs1 = LCS(i-1,j);
uint32_t lcs2 = LCS(i,j-1);
LCS(i,j) = lcs1 > lcs2 ? lcs1 : lcs2;
uint32_t lcs1 = LCS(i - 1, j);
uint32_t lcs2 = LCS(i, j - 1);
LCS(i, j) = lcs1 > lcs2 ? lcs1 : lcs2;
}
}
}
/* Store the actual LCS string in "result" if needed. We create
* it backward, but the length is already known, we store it into idx. */
uint32_t idx = LCS(alen,blen);
sds result = NULL; /* Resulting LCS string. */
void *arraylenptr = NULL; /* Deferred length of the array for IDX. */
uint32_t idx = LCS(alen, blen);
sds result = NULL; /* Resulting LCS string. */
void *arraylenptr = NULL; /* Deferred length of the array for IDX. */
uint32_t arange_start = alen, /* alen signals that values are not set. */
arange_end = 0,
arange_end = 0,
brange_start = 0,
brange_end = 0;
/* Do we need to compute the actual LCS string? Allocate it in that case. */
int computelcs = getidx || !getlen;
if (computelcs) result = sdsnewlen(SDS_NOINIT,idx);
if (computelcs) result = sdsnewlen(SDS_NOINIT, idx);
/* Start with a deferred array if we have to emit the ranges. */
uint32_t arraylen = 0; /* Number of ranges emitted in the array. */
uint32_t arraylen = 0; /* Number of ranges emitted in the array. */
if (getidx) {
addReplyMapLen(c,2);
addReplyBulkCString(c,"matches");
addReplyMapLen(c, 2);
addReplyBulkCString(c, "matches");
arraylenptr = addReplyDeferredLen(c);
}
i = alen, j = blen;
while (computelcs && i > 0 && j > 0) {
int emit_range = 0;
if (a[i-1] == b[j-1]) {
if (a[i - 1] == b[j - 1]) {
/* If there is a match, store the character and reduce
* the indexes to look for a new match. */
result[idx-1] = a[i-1];
result[idx - 1] = a[i - 1];
/* Track the current range. */
if (arange_start == alen) {
arange_start = i-1;
arange_end = i-1;
brange_start = j-1;
brange_end = j-1;
arange_start = i - 1;
arange_end = i - 1;
brange_start = j - 1;
brange_end = j - 1;
} else {
/* Let's see if we can extend the range backward since
* it is contiguous. */
@ -900,12 +897,14 @@ void lcsCommand(client *c) {
/* Emit the range if we matched with the first byte of
* one of the two strings. We'll exit the loop ASAP. */
if (arange_start == 0 || brange_start == 0) emit_range = 1;
idx--; i--; j--;
idx--;
i--;
j--;
} else {
/* Otherwise reduce i and j depending on the largest
* LCS between, to understand what direction we need to go. */
uint32_t lcs1 = LCS(i-1,j);
uint32_t lcs2 = LCS(i,j-1);
uint32_t lcs1 = LCS(i - 1, j);
uint32_t lcs2 = LCS(i, j - 1);
if (lcs1 > lcs2)
i--;
else
@ -918,14 +917,14 @@ void lcsCommand(client *c) {
if (emit_range) {
if (minmatchlen == 0 || match_len >= minmatchlen) {
if (arraylenptr) {
addReplyArrayLen(c,2+withmatchlen);
addReplyArrayLen(c,2);
addReplyLongLong(c,arange_start);
addReplyLongLong(c,arange_end);
addReplyArrayLen(c,2);
addReplyLongLong(c,brange_start);
addReplyLongLong(c,brange_end);
if (withmatchlen) addReplyLongLong(c,match_len);
addReplyArrayLen(c, 2 + withmatchlen);
addReplyArrayLen(c, 2);
addReplyLongLong(c, arange_start);
addReplyLongLong(c, arange_end);
addReplyArrayLen(c, 2);
addReplyLongLong(c, brange_start);
addReplyLongLong(c, brange_end);
if (withmatchlen) addReplyLongLong(c, match_len);
arraylen++;
}
}
@ -937,13 +936,13 @@ void lcsCommand(client *c) {
/* Reply depending on the given options. */
if (arraylenptr) {
addReplyBulkCString(c,"len");
addReplyLongLong(c,LCS(alen,blen));
setDeferredArrayLen(c,arraylenptr,arraylen);
addReplyBulkCString(c, "len");
addReplyLongLong(c, LCS(alen, blen));
setDeferredArrayLen(c, arraylenptr, arraylen);
} else if (getlen) {
addReplyLongLong(c,LCS(alen,blen));
addReplyLongLong(c, LCS(alen, blen));
} else {
addReplyBulkSds(c,result);
addReplyBulkSds(c, result);
result = NULL;
}
@ -956,4 +955,3 @@ cleanup:
if (objb) decrRefCount(objb);
return;
}

11
src/t_zset.c
View File

@ -2857,9 +2857,16 @@ void zdiffCommand(client *c) {
zunionInterDiffGenericCommand(c, NULL, 1, SET_OP_DIFF, 0);
}
typedef enum { ZRANGE_DIRECTION_AUTO = 0, ZRANGE_DIRECTION_FORWARD, ZRANGE_DIRECTION_REVERSE } zrange_direction;
typedef enum {
ZRANGE_DIRECTION_AUTO = 0,
ZRANGE_DIRECTION_FORWARD,
ZRANGE_DIRECTION_REVERSE
} zrange_direction;
typedef enum { ZRANGE_CONSUMER_TYPE_CLIENT = 0, ZRANGE_CONSUMER_TYPE_INTERNAL } zrange_consumer_type;
typedef enum {
ZRANGE_CONSUMER_TYPE_CLIENT = 0,
ZRANGE_CONSUMER_TYPE_INTERNAL
} zrange_consumer_type;
typedef struct zrange_result_handler zrange_result_handler;

34
src/testhelp.h
View File

@ -46,24 +46,24 @@
extern int __failed_tests;
extern int __test_num;
#define test_cond(descr, _c) \
do { \
__test_num++; \
printf("%d - %s: ", __test_num, descr); \
if (_c) \
printf("PASSED\n"); \
else { \
printf("FAILED\n"); \
__failed_tests++; \
} \
#define test_cond(descr, _c) \
do { \
__test_num++; \
printf("%d - %s: ", __test_num, descr); \
if (_c) \
printf("PASSED\n"); \
else { \
printf("FAILED\n"); \
__failed_tests++; \
} \
} while (0)
#define test_report() \
do { \
printf("%d tests, %d passed, %d failed\n", __test_num, __test_num - __failed_tests, __failed_tests); \
if (__failed_tests) { \
printf("=== WARNING === We have failed tests here...\n"); \
exit(1); \
} \
#define test_report() \
do { \
printf("%d tests, %d passed, %d failed\n", __test_num, __test_num - __failed_tests, __failed_tests); \
if (__failed_tests) { \
printf("=== WARNING === We have failed tests here...\n"); \
exit(1); \
} \
} while (0)
#endif

5
src/tls.c
View File

@ -437,7 +437,10 @@ static ConnectionType CT_TLS;
*
*/
typedef enum { WANT_READ = 1, WANT_WRITE } WantIOType;
typedef enum {
WANT_READ = 1,
WANT_WRITE
} WantIOType;
#define TLS_CONN_FLAG_READ_WANT_WRITE (1 << 0)
#define TLS_CONN_FLAG_WRITE_WANT_READ (1 << 1)

8
src/unit/test_dict.c
View File

@ -36,10 +36,10 @@ char *stringFromLongLong(long long value) {
dictType BenchmarkDictType = {hashCallback, NULL, compareCallback, freeCallback, NULL, NULL};
#define start_benchmark() start = timeInMilliseconds()
#define end_benchmark(msg) \
do { \
elapsed = timeInMilliseconds() - start; \
printf(msg ": %ld items in %lld ms\n", count, elapsed); \
#define end_benchmark(msg) \
do { \
elapsed = timeInMilliseconds() - start; \
printf(msg ": %ld items in %lld ms\n", count, elapsed); \
} while (0)
static dict *_dict = NULL;

1
src/unit/test_files.h
View File

@ -1,5 +1,4 @@
/* Do not modify this file, it's automatically generated from utils/generate-unit-test-header.py */
/* clang-format off */
typedef int unitTestProc(int argc, char **argv, int flags);
typedef struct unitTest {

14
src/unit/test_help.h
View File

@ -30,15 +30,15 @@
#define TEST_PRINT_ERROR(descr) printf("[" KRED "%s - %s:%d" KRESET "] %s\n", __func__, __FILE__, __LINE__, descr)
#define TEST_PRINT_INFO(descr, ...) \
#define TEST_PRINT_INFO(descr, ...) \
printf("[" KBLUE "%s - %s:%d" KRESET "] " descr "\n", __func__, __FILE__, __LINE__, __VA_ARGS__)
#define TEST_ASSERT_MESSAGE(descr, _c) \
do { \
if (!(_c)) { \
TEST_PRINT_ERROR(descr); \
return 1; \
} \
#define TEST_ASSERT_MESSAGE(descr, _c) \
do { \
if (!(_c)) { \
TEST_PRINT_ERROR(descr); \
return 1; \
} \
} while (0)
#define TEST_ASSERT(_c) TEST_ASSERT_MESSAGE("Failed assertion: " #_c, _c)

169
src/valkey-benchmark.c
View File

@ -1511,99 +1511,96 @@ invalid:
printf("Invalid option \"%s\" or option argument missing\n\n", argv[i]);
usage:
/* clang-format off */
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"
" --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"
" --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
"";
"";
printf(
"%s%s%s", /* Split to avoid strings longer than 4095 (-Woverlength-strings). */
"Usage: valkey-benchmark [OPTIONS] [COMMAND ARGS...]\n\n"
"Options:\n"
" -h <hostname> Server hostname (default 127.0.0.1)\n"
" -p <port> Server port (default 6379)\n"
" -s <socket> Server socket (overrides host and port)\n"
" -a <password> Password for Valkey Auth\n"
" --user <username> Used to send ACL style 'AUTH username pass'. Needs -a.\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"
" -c <clients> Number of parallel connections (default 50).\n"
" Note: If --cluster is used then number of clients has to be\n"
" the same or higher than the number of nodes.\n"
" -n <requests> Total number of requests (default 100000)\n"
" -d <size> Data size of SET/GET value in bytes (default 3)\n"
" --dbnum <db> SELECT the specified db number (default 0)\n"
" -3 Start session in RESP3 protocol mode.\n"
" --threads <num> Enable multi-thread mode.\n"
" --cluster Enable cluster mode.\n"
" If the command is supplied on the command line in cluster\n"
" mode, the key must contain \"{tag}\". Otherwise, the\n"
" command will not be sent to the right cluster node.\n"
" --enable-tracking Send CLIENT TRACKING on before starting benchmark.\n"
" -k <boolean> 1=keep alive 0=reconnect (default 1)\n"
" -r <keyspacelen> Use random keys for SET/GET/INCR, random values for SADD,\n"
" random members and scores for ZADD.\n"
" Using this option the benchmark will expand the string\n"
" __rand_int__ inside an argument with a 12 digits number in\n"
" the specified range from 0 to keyspacelen-1. The\n"
" substitution changes every time a command is executed.\n"
" Default tests use this to hit random keys in the specified\n"
" range.\n"
" Note: If -r is omitted, all commands in a benchmark will\n"
" use the same key.\n"
" -P <numreq> Pipeline <numreq> requests. Default 1 (no pipeline).\n"
" -q Quiet. Just show query/sec values\n"
" --precision Number of decimal places to display in latency output (default 0)\n"
" --csv Output in CSV format\n"
" -l Loop. Run the tests forever\n"
" -t <tests> Only run the comma separated list of tests. The test\n"
" names are the same as the ones produced as output.\n"
" The -t option is ignored if a specific command is supplied\n"
" on the command line.\n"
" -I Idle mode. Just open N idle connections and wait.\n"
" -x Read last argument from STDIN.\n"
" --seed <num> Set the seed for random number generator. Default seed is based on time.\n",
tls_usage,
" --help Output this help and exit.\n"
" --version Output version and exit.\n\n"
"Examples:\n\n"
" Run the benchmark with the default configuration against 127.0.0.1:6379:\n"
" $ valkey-benchmark\n\n"
" Use 20 parallel clients, for a total of 100k requests, against 192.168.1.1:\n"
" $ valkey-benchmark -h 192.168.1.1 -p 6379 -n 100000 -c 20\n\n"
" Fill 127.0.0.1:6379 with about 1 million keys only using the SET test:\n"
" $ valkey-benchmark -t set -n 1000000 -r 100000000\n\n"
" Benchmark 127.0.0.1:6379 for a few commands producing CSV output:\n"
" $ valkey-benchmark -t ping,set,get -n 100000 --csv\n\n"
" Benchmark a specific command line:\n"
" $ valkey-benchmark -r 10000 -n 10000 eval 'return redis.call(\"ping\")' 0\n\n"
" Fill a list with 10000 random elements:\n"
" $ valkey-benchmark -r 10000 -n 10000 lpush mylist __rand_int__\n\n"
" On user specified command lines __rand_int__ is replaced with a random integer\n"
" with a range of values selected by the -r option.\n"
);
/* clang-format on */
"%s%s%s", /* Split to avoid strings longer than 4095 (-Woverlength-strings). */
"Usage: valkey-benchmark [OPTIONS] [COMMAND ARGS...]\n\n"
"Options:\n"
" -h <hostname> Server hostname (default 127.0.0.1)\n"
" -p <port> Server port (default 6379)\n"
" -s <socket> Server socket (overrides host and port)\n"
" -a <password> Password for Valkey Auth\n"
" --user <username> Used to send ACL style 'AUTH username pass'. Needs -a.\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"
" -c <clients> Number of parallel connections (default 50).\n"
" Note: If --cluster is used then number of clients has to be\n"
" the same or higher than the number of nodes.\n"
" -n <requests> Total number of requests (default 100000)\n"
" -d <size> Data size of SET/GET value in bytes (default 3)\n"
" --dbnum <db> SELECT the specified db number (default 0)\n"
" -3 Start session in RESP3 protocol mode.\n"
" --threads <num> Enable multi-thread mode.\n"
" --cluster Enable cluster mode.\n"
" If the command is supplied on the command line in cluster\n"
" mode, the key must contain \"{tag}\". Otherwise, the\n"
" command will not be sent to the right cluster node.\n"
" --enable-tracking Send CLIENT TRACKING on before starting benchmark.\n"
" -k <boolean> 1=keep alive 0=reconnect (default 1)\n"
" -r <keyspacelen> Use random keys for SET/GET/INCR, random values for SADD,\n"
" random members and scores for ZADD.\n"
" Using this option the benchmark will expand the string\n"
" __rand_int__ inside an argument with a 12 digits number in\n"
" the specified range from 0 to keyspacelen-1. The\n"
" substitution changes every time a command is executed.\n"
" Default tests use this to hit random keys in the specified\n"
" range.\n"
" Note: If -r is omitted, all commands in a benchmark will\n"
" use the same key.\n"
" -P <numreq> Pipeline <numreq> requests. Default 1 (no pipeline).\n"
" -q Quiet. Just show query/sec values\n"
" --precision Number of decimal places to display in latency output (default 0)\n"
" --csv Output in CSV format\n"
" -l Loop. Run the tests forever\n"
" -t <tests> Only run the comma separated list of tests. The test\n"
" names are the same as the ones produced as output.\n"
" The -t option is ignored if a specific command is supplied\n"
" on the command line.\n"
" -I Idle mode. Just open N idle connections and wait.\n"
" -x Read last argument from STDIN.\n"
" --seed <num> Set the seed for random number generator. Default seed is based on time.\n",
tls_usage,
" --help Output this help and exit.\n"
" --version Output version and exit.\n\n"
"Examples:\n\n"
" Run the benchmark with the default configuration against 127.0.0.1:6379:\n"
" $ valkey-benchmark\n\n"
" Use 20 parallel clients, for a total of 100k requests, against 192.168.1.1:\n"
" $ valkey-benchmark -h 192.168.1.1 -p 6379 -n 100000 -c 20\n\n"
" Fill 127.0.0.1:6379 with about 1 million keys only using the SET test:\n"
" $ valkey-benchmark -t set -n 1000000 -r 100000000\n\n"
" Benchmark 127.0.0.1:6379 for a few commands producing CSV output:\n"
" $ valkey-benchmark -t ping,set,get -n 100000 --csv\n\n"
" Benchmark a specific command line:\n"
" $ valkey-benchmark -r 10000 -n 10000 eval 'return redis.call(\"ping\")' 0\n\n"
" Fill a list with 10000 random elements:\n"
" $ valkey-benchmark -r 10000 -n 10000 lpush mylist __rand_int__\n\n"
" On user specified command lines __rand_int__ is replaced with a random integer\n"
" with a range of values selected by the -r option.\n");
exit(exit_status);
}

10
src/valkey-check-aof.c
View File

@ -50,11 +50,11 @@ aofManifest *aofManifestCreate(void);
void aofManifestFree(aofManifest *am);
aofManifest *aofLoadManifestFromFile(sds am_filepath);
#define ERROR(...) \
{ \
char __buf[1024]; \
snprintf(__buf, sizeof(__buf), __VA_ARGS__); \
snprintf(error, sizeof(error), "0x%16llx: %s", (long long)epos, __buf); \
#define ERROR(...) \
{ \
char __buf[1024]; \
snprintf(__buf, sizeof(__buf), __VA_ARGS__); \
snprintf(error, sizeof(error), "0x%16llx: %s", (long long)epos, __buf); \
}
static char error[1044];

14
src/valkey-check-rdb.c
View File

@ -65,8 +65,18 @@ struct {
#define RDB_CHECK_DOING_READ_MODULE_AUX 8
#define RDB_CHECK_DOING_READ_FUNCTIONS 9
char *rdb_check_doing_string[] = {"start", "read-type", "read-expire", "read-key", "read-object-value",
"check-sum", "read-len", "read-aux", "read-module-aux", "read-functions"};
char *rdb_check_doing_string[] = {
"start",
"read-type",
"read-expire",
"read-key",
"read-object-value",
"check-sum",
"read-len",
"read-aux",
"read-module-aux",
"read-functions",
};
char *rdb_type_string[] = {
"string",

282
src/valkey-cli.c
View File

@ -87,9 +87,9 @@
#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 " \
#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))
@ -97,7 +97,7 @@
#define CLUSTER_MANAGER_NODE_ARRAY_FREE(array) zfree((array)->alloc)
#define CLUSTER_MANAGER_PRINT_REPLY_ERROR(n, err) \
#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__)
@ -157,7 +157,7 @@
/* --latency-dist palettes. */
int spectrum_palette_color_size = 19;
int spectrum_palette_color[] = {0, 233, 234, 235, 237, 239, 241, 243, 245, 247,
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;
@ -2872,155 +2872,153 @@ static void parseEnv(void) {
static void usage(int err) {
sds version = cliVersion();
FILE *target = err ? stderr : stdout;
/* clang-format off */
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"
" --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"
" --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);
"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);
" --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");
" --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");
/* clang-format on */
"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);
}

51
src/valkeymodule.h
View File

@ -79,8 +79,8 @@ typedef long long ustime_t;
/* Mask of all VALKEYMODULE_OPEN_KEY_* values. Any new mode should be added to this list.
* Should not be used directly by the module, use RM_GetOpenKeyModesAll instead.
* Located here so when we will add new modes we will not forget to update it. */
#define _VALKEYMODULE_OPEN_KEY_ALL \
VALKEYMODULE_READ | VALKEYMODULE_WRITE | VALKEYMODULE_OPEN_KEY_NOTOUCH | VALKEYMODULE_OPEN_KEY_NONOTIFY | \
#define _VALKEYMODULE_OPEN_KEY_ALL \
VALKEYMODULE_READ | VALKEYMODULE_WRITE | VALKEYMODULE_OPEN_KEY_NOTOUCH | VALKEYMODULE_OPEN_KEY_NONOTIFY | \
VALKEYMODULE_OPEN_KEY_NOSTATS | VALKEYMODULE_OPEN_KEY_NOEXPIRE | VALKEYMODULE_OPEN_KEY_NOEFFECTS
/* List push and pop */
@ -137,11 +137,10 @@ typedef long long ustime_t;
#define VALKEYMODULE_HASH_EXISTS (1 << 3)
#define VALKEYMODULE_HASH_COUNT_ALL (1 << 4)
#define VALKEYMODULE_CONFIG_DEFAULT 0 /* This is the default for a module config. */
#define VALKEYMODULE_CONFIG_IMMUTABLE (1ULL << 0) /* Can this value only be set at startup? */
#define VALKEYMODULE_CONFIG_SENSITIVE (1ULL << 1) /* Does this value contain sensitive information */
#define VALKEYMODULE_CONFIG_HIDDEN \
(1ULL << 4) /* This config is hidden in `config get <pattern>` (used for tests/debugging) */
#define VALKEYMODULE_CONFIG_DEFAULT 0 /* This is the default for a module config. */
#define VALKEYMODULE_CONFIG_IMMUTABLE (1ULL << 0) /* Can this value only be set at startup? */
#define VALKEYMODULE_CONFIG_SENSITIVE (1ULL << 1) /* Does this value contain sensitive information */
#define VALKEYMODULE_CONFIG_HIDDEN (1ULL << 4) /* This config is hidden in `config get <pattern>` (used for tests/debugging) */
#define VALKEYMODULE_CONFIG_PROTECTED (1ULL << 5) /* Becomes immutable if enable-protected-configs is enabled. */
#define VALKEYMODULE_CONFIG_DENY_LOADING (1ULL << 6) /* This config is forbidden during loading. */
@ -231,22 +230,21 @@ This flag should not be used directly by the module.
/* Keyspace changes notification classes. Every class is associated with a
* character for configuration purposes.
* NOTE: These have to be in sync with NOTIFY_* in server.h */
#define VALKEYMODULE_NOTIFY_KEYSPACE (1 << 0) /* K */
#define VALKEYMODULE_NOTIFY_KEYEVENT (1 << 1) /* E */
#define VALKEYMODULE_NOTIFY_GENERIC (1 << 2) /* g */
#define VALKEYMODULE_NOTIFY_STRING (1 << 3) /* $ */
#define VALKEYMODULE_NOTIFY_LIST (1 << 4) /* l */
#define VALKEYMODULE_NOTIFY_SET (1 << 5) /* s */
#define VALKEYMODULE_NOTIFY_HASH (1 << 6) /* h */
#define VALKEYMODULE_NOTIFY_ZSET (1 << 7) /* z */
#define VALKEYMODULE_NOTIFY_EXPIRED (1 << 8) /* x */
#define VALKEYMODULE_NOTIFY_EVICTED (1 << 9) /* e */
#define VALKEYMODULE_NOTIFY_STREAM (1 << 10) /* t */
#define VALKEYMODULE_NOTIFY_KEY_MISS \
(1 << 11) /* m (Note: This one is excluded from VALKEYMODULE_NOTIFY_ALL on purpose) */
#define VALKEYMODULE_NOTIFY_LOADED (1 << 12) /* module only key space notification, indicate a key loaded from rdb */
#define VALKEYMODULE_NOTIFY_MODULE (1 << 13) /* d, module key space notification */
#define VALKEYMODULE_NOTIFY_NEW (1 << 14) /* n, new key notification */
#define VALKEYMODULE_NOTIFY_KEYSPACE (1 << 0) /* K */
#define VALKEYMODULE_NOTIFY_KEYEVENT (1 << 1) /* E */
#define VALKEYMODULE_NOTIFY_GENERIC (1 << 2) /* g */
#define VALKEYMODULE_NOTIFY_STRING (1 << 3) /* $ */
#define VALKEYMODULE_NOTIFY_LIST (1 << 4) /* l */
#define VALKEYMODULE_NOTIFY_SET (1 << 5) /* s */
#define VALKEYMODULE_NOTIFY_HASH (1 << 6) /* h */
#define VALKEYMODULE_NOTIFY_ZSET (1 << 7) /* z */
#define VALKEYMODULE_NOTIFY_EXPIRED (1 << 8) /* x */
#define VALKEYMODULE_NOTIFY_EVICTED (1 << 9) /* e */
#define VALKEYMODULE_NOTIFY_STREAM (1 << 10) /* t */
#define VALKEYMODULE_NOTIFY_KEY_MISS (1 << 11) /* m (Note: This one is excluded from VALKEYMODULE_NOTIFY_ALL on purpose) */
#define VALKEYMODULE_NOTIFY_LOADED (1 << 12) /* module only key space notification, indicate a key loaded from rdb */
#define VALKEYMODULE_NOTIFY_MODULE (1 << 13) /* d, module key space notification */
#define VALKEYMODULE_NOTIFY_NEW (1 << 14) /* n, new key notification */
/* Next notification flag, must be updated when adding new flags above!
This flag should not be used directly by the module.
@ -347,10 +345,9 @@ typedef enum {
} ValkeyModuleCommandArgType;
#define VALKEYMODULE_CMD_ARG_NONE (0)
#define VALKEYMODULE_CMD_ARG_OPTIONAL (1 << 0) /* The argument is optional (like GET in SET command) */
#define VALKEYMODULE_CMD_ARG_MULTIPLE (1 << 1) /* The argument may repeat itself (like key in DEL) */
#define VALKEYMODULE_CMD_ARG_MULTIPLE_TOKEN \
(1 << 2) /* The argument may repeat itself, and so does its token (like `GET pattern` in SORT) */
#define VALKEYMODULE_CMD_ARG_OPTIONAL (1 << 0) /* The argument is optional (like GET in SET command) */
#define VALKEYMODULE_CMD_ARG_MULTIPLE (1 << 1) /* The argument may repeat itself (like key in DEL) */
#define VALKEYMODULE_CMD_ARG_MULTIPLE_TOKEN (1 << 2) /* The argument may repeat itself, and so does its token (like `GET pattern` in SORT) */
#define _VALKEYMODULE_CMD_ARG_NEXT (1 << 3)
typedef enum {

158
src/ziplist.c
View File

@ -191,14 +191,13 @@
#include "endianconv.h"
#include "serverassert.h"
#define ZIP_END 255 /* Special "end of ziplist" entry. */
#define ZIP_BIG_PREVLEN \
254 /* ZIP_BIG_PREVLEN - 1 is the max number of bytes of \
the previous entry, for the "prevlen" field prefixing \
each entry, to be represented with just a single byte. \
Otherwise it is represented as FE AA BB CC DD, where \
AA BB CC DD are a 4 bytes unsigned integer \
representing the previous entry len. */
#define ZIP_END 255 /* Special "end of ziplist" entry. */
#define ZIP_BIG_PREVLEN 254 /* ZIP_BIG_PREVLEN - 1 is the max number of bytes of \
the previous entry, for the "prevlen" field prefixing \
each entry, to be represented with just a single byte. \
Otherwise it is represented as FE AA BB CC DD, where \
AA BB CC DD are a 4 bytes unsigned integer \
representing the previous entry len. */
/* Different encoding/length possibilities */
#define ZIP_STR_MASK 0xc0
@ -214,11 +213,10 @@
/* 4 bit integer immediate encoding |1111xxxx| with xxxx between
* 0001 and 1101. */
#define ZIP_INT_IMM_MASK \
0x0f /* Mask to extract the 4 bits value. To add \
one is needed to reconstruct the value. */
#define ZIP_INT_IMM_MIN 0xf1 /* 11110001 */
#define ZIP_INT_IMM_MAX 0xfd /* 11111101 */
#define ZIP_INT_IMM_MASK 0x0f /* Mask to extract the 4 bits value. To add \
one is needed to reconstruct the value. */
#define ZIP_INT_IMM_MIN 0xf1 /* 11110001 */
#define ZIP_INT_IMM_MAX 0xfd /* 11111101 */
#define INT24_MAX 0x7fffff
#define INT24_MIN (-INT24_MAX - 1)
@ -263,10 +261,10 @@
* always pushed one at a time. When UINT16_MAX is reached we want the count
* to stay there to signal that a full scan is needed to get the number of
* items inside the ziplist. */
#define ZIPLIST_INCR_LENGTH(zl, incr) \
{ \
if (intrev16ifbe(ZIPLIST_LENGTH(zl)) < UINT16_MAX) \
ZIPLIST_LENGTH(zl) = intrev16ifbe(intrev16ifbe(ZIPLIST_LENGTH(zl)) + incr); \
#define ZIPLIST_INCR_LENGTH(zl, incr) \
{ \
if (intrev16ifbe(ZIPLIST_LENGTH(zl)) < UINT16_MAX) \
ZIPLIST_LENGTH(zl) = intrev16ifbe(intrev16ifbe(ZIPLIST_LENGTH(zl)) + incr); \
}
/* Don't let ziplists grow over 1GB in any case, don't wanna risk overflow in
@ -302,20 +300,20 @@ typedef struct zlentry {
is, this points to prev-entry-len field. */
} zlentry;
#define ZIPLIST_ENTRY_ZERO(zle) \
{ \
(zle)->prevrawlensize = (zle)->prevrawlen = 0; \
(zle)->lensize = (zle)->len = (zle)->headersize = 0; \
(zle)->encoding = 0; \
(zle)->p = NULL; \
#define ZIPLIST_ENTRY_ZERO(zle) \
{ \
(zle)->prevrawlensize = (zle)->prevrawlen = 0; \
(zle)->lensize = (zle)->len = (zle)->headersize = 0; \
(zle)->encoding = 0; \
(zle)->p = NULL; \
}
/* Extract the encoding from the byte pointed by 'ptr' and set it into
* 'encoding' field of the zlentry structure. */
#define ZIP_ENTRY_ENCODING(ptr, encoding) \
do { \
(encoding) = ((ptr)[0]); \
if ((encoding) < ZIP_STR_MASK) (encoding) &= ZIP_STR_MASK; \
#define ZIP_ENTRY_ENCODING(ptr, encoding) \
do { \
(encoding) = ((ptr)[0]); \
if ((encoding) < ZIP_STR_MASK) (encoding) &= ZIP_STR_MASK; \
} while (0)
#define ZIP_ENCODING_SIZE_INVALID 0xff
@ -332,9 +330,9 @@ static inline unsigned int zipEncodingLenSize(unsigned char encoding) {
return ZIP_ENCODING_SIZE_INVALID;
}
#define ZIP_ASSERT_ENCODING(encoding) \
do { \
assert(zipEncodingLenSize(encoding) != ZIP_ENCODING_SIZE_INVALID); \
#define ZIP_ASSERT_ENCODING(encoding) \
do { \
assert(zipEncodingLenSize(encoding) != ZIP_ENCODING_SIZE_INVALID); \
} while (0)
/* Return bytes needed to store integer encoded by 'encoding' */
@ -404,41 +402,41 @@ unsigned int zipStoreEntryEncoding(unsigned char *p, unsigned char encoding, uns
* variable will hold the number of bytes required to encode the entry
* length, and the 'len' variable will hold the entry length.
* On invalid encoding error, lensize is set to 0. */
#define ZIP_DECODE_LENGTH(ptr, encoding, lensize, len) \
do { \
if ((encoding) < ZIP_STR_MASK) { \
if ((encoding) == ZIP_STR_06B) { \
(lensize) = 1; \
(len) = (ptr)[0] & 0x3f; \
} else if ((encoding) == ZIP_STR_14B) { \
(lensize) = 2; \
(len) = (((ptr)[0] & 0x3f) << 8) | (ptr)[1]; \
} else if ((encoding) == ZIP_STR_32B) { \
(lensize) = 5; \
(len) = ((uint32_t)(ptr)[1] << 24) | ((uint32_t)(ptr)[2] << 16) | ((uint32_t)(ptr)[3] << 8) | \
((uint32_t)(ptr)[4]); \
} else { \
(lensize) = 0; /* bad encoding, should be covered by a previous */ \
(len) = 0; /* ZIP_ASSERT_ENCODING / zipEncodingLenSize, or */ \
/* match the lensize after this macro with 0. */ \
} \
} else { \
(lensize) = 1; \
if ((encoding) == ZIP_INT_8B) \
(len) = 1; \
else if ((encoding) == ZIP_INT_16B) \
(len) = 2; \
else if ((encoding) == ZIP_INT_24B) \
(len) = 3; \
else if ((encoding) == ZIP_INT_32B) \
(len) = 4; \
else if ((encoding) == ZIP_INT_64B) \
(len) = 8; \
else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) \
(len) = 0; /* 4 bit immediate */ \
else \
(lensize) = (len) = 0; /* bad encoding */ \
} \
#define ZIP_DECODE_LENGTH(ptr, encoding, lensize, len) \
do { \
if ((encoding) < ZIP_STR_MASK) { \
if ((encoding) == ZIP_STR_06B) { \
(lensize) = 1; \
(len) = (ptr)[0] & 0x3f; \
} else if ((encoding) == ZIP_STR_14B) { \
(lensize) = 2; \
(len) = (((ptr)[0] & 0x3f) << 8) | (ptr)[1]; \
} else if ((encoding) == ZIP_STR_32B) { \
(lensize) = 5; \
(len) = ((uint32_t)(ptr)[1] << 24) | ((uint32_t)(ptr)[2] << 16) | ((uint32_t)(ptr)[3] << 8) | \
((uint32_t)(ptr)[4]); \
} else { \
(lensize) = 0; /* bad encoding, should be covered by a previous */ \
(len) = 0; /* ZIP_ASSERT_ENCODING / zipEncodingLenSize, or */ \
/* match the lensize after this macro with 0. */ \
} \
} else { \
(lensize) = 1; \
if ((encoding) == ZIP_INT_8B) \
(len) = 1; \
else if ((encoding) == ZIP_INT_16B) \
(len) = 2; \
else if ((encoding) == ZIP_INT_24B) \
(len) = 3; \
else if ((encoding) == ZIP_INT_32B) \
(len) = 4; \
else if ((encoding) == ZIP_INT_64B) \
(len) = 8; \
else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) \
(len) = 0; /* 4 bit immediate */ \
else \
(lensize) = (len) = 0; /* bad encoding */ \
} \
} while (0)
/* Encode the length of the previous entry and write it to "p". This only
@ -471,13 +469,13 @@ unsigned int zipStorePrevEntryLength(unsigned char *p, unsigned int len) {
/* Return the number of bytes used to encode the length of the previous
* entry. The length is returned by setting the var 'prevlensize'. */
#define ZIP_DECODE_PREVLENSIZE(ptr, prevlensize) \
do { \
if ((ptr)[0] < ZIP_BIG_PREVLEN) { \
(prevlensize) = 1; \
} else { \
(prevlensize) = 5; \
} \
#define ZIP_DECODE_PREVLENSIZE(ptr, prevlensize) \
do { \
if ((ptr)[0] < ZIP_BIG_PREVLEN) { \
(prevlensize) = 1; \
} else { \
(prevlensize) = 5; \
} \
} while (0)
/* Return the length of the previous element, and the number of bytes that
@ -487,14 +485,14 @@ unsigned int zipStorePrevEntryLength(unsigned char *p, unsigned int len) {
* The length of the previous entry is stored in 'prevlen', the number of
* bytes needed to encode the previous entry length are stored in
* 'prevlensize'. */
#define ZIP_DECODE_PREVLEN(ptr, prevlensize, prevlen) \
do { \
ZIP_DECODE_PREVLENSIZE(ptr, prevlensize); \
if ((prevlensize) == 1) { \
(prevlen) = (ptr)[0]; \
} else { /* prevlensize == 5 */ \
(prevlen) = ((ptr)[4] << 24) | ((ptr)[3] << 16) | ((ptr)[2] << 8) | ((ptr)[1]); \
} \
#define ZIP_DECODE_PREVLEN(ptr, prevlensize, prevlen) \
do { \
ZIP_DECODE_PREVLENSIZE(ptr, prevlensize); \
if ((prevlensize) == 1) { \
(prevlen) = (ptr)[0]; \
} else { /* prevlensize == 5 */ \
(prevlen) = ((ptr)[4] << 24) | ((ptr)[3] << 16) | ((ptr)[2] << 8) | ((ptr)[1]); \
} \
} while (0)
/* Given a pointer 'p' to the prevlen info that prefixes an entry, this

2
src/zmalloc.c
View File

@ -99,7 +99,7 @@ static thread_local int thread_index = -1;
* the reader will see the inconsistency memory on non x86 architecture potentially.
* For the ARM and PowerPC platform, we can solve this issue by make the memory aligned.
* For the other architecture, lets fall back to the atomic operation to keep safe. */
#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || defined(__POWERPC__) || defined(__arm__) || \
#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || defined(__POWERPC__) || defined(__arm__) || \
defined(__arm64__)
static __attribute__((aligned(sizeof(size_t)))) size_t used_memory_thread[MAX_THREADS_NUM];
#else

4
src/zmalloc.h
View File

@ -48,7 +48,7 @@
#endif
#elif defined(USE_JEMALLOC)
#define ZMALLOC_LIB \
#define ZMALLOC_LIB \
("jemalloc-" __xstr(JEMALLOC_VERSION_MAJOR) "." __xstr(JEMALLOC_VERSION_MINOR) "." __xstr(JEMALLOC_VERSION_BUGFIX))
#include <jemalloc/jemalloc.h>
#if (JEMALLOC_VERSION_MAJOR == 2 && JEMALLOC_VERSION_MINOR >= 1) || (JEMALLOC_VERSION_MAJOR > 2)
@ -76,7 +76,7 @@
#define ZMALLOC_LIB "libc"
#define USE_LIBC 1
#if !defined(NO_MALLOC_USABLE_SIZE) && (defined(__GLIBC__) || defined(__FreeBSD__) || defined(__DragonFly__) || \
#if !defined(NO_MALLOC_USABLE_SIZE) && (defined(__GLIBC__) || defined(__FreeBSD__) || defined(__DragonFly__) || \
defined(__HAIKU__) || defined(USE_MALLOC_USABLE_SIZE))
/* Includes for malloc_usable_size() */

1
utils/generate-unit-test-header.py
View File

@ -26,7 +26,6 @@ if __name__ == '__main__':
test_suites.append({'file': file, 'tests': tests})
test_suites.sort(key=lambda test_suite: test_suite['file'])
output.write("""/* Do not modify this file, it's automatically generated from utils/generate-unit-test-header.py */
/* clang-format off */
typedef int unitTestProc(int argc, char **argv, int flags);
typedef struct unitTest {