Commits on Aug 1, 2012
  1. Redis 2.5.12 (2.6 RC6).

    committed Aug 1, 2012
Commits on Jul 31, 2012
  1. Use correct variable name for value to convert.

    Note by @antirez: this code was never compiled because utils.c lacked the
    float.h include, so we never noticed this variable was mispelled in the
    This should provide a noticeable speed boost when saving certain types
    of databases with many sorted sets inside.
    mgp committed with Jul 26, 2012
  2. Truncate short write from the AOF

    If Redis only manages to write out a partial buffer, the AOF file won't
    load back into Redis the next time it starts up.  It is better to
    discard the short write than waste time running redis-check-aof.
    saj committed with Jul 16, 2012
  3. New in INFO: aof_last_bgrewrite_status

    Behaves like rdb_last_bgsave_status -- even down to reporting 'ok' when
    no rewrite has been done yet.  (You might want to check that
    aof_last_rewrite_time_sec is not -1.)
    saj committed with Jul 17, 2012
Commits on Jul 22, 2012
  1. Allow Pub/Sub in contexts where other commands are blocked.

    Redis loading data from disk, and a Redis slave disconnected from its
    master with serve-stale-data disabled, are two conditions where
    commands are normally refused by Redis, returning an error.
    However there is no reason to disable Pub/Sub commands as well, given
    that this layer does not interact with the dataset. To allow Pub/Sub in
    as many contexts as possible is especially interesting now that Redis
    Sentinel uses Pub/Sub of a Redis master as a communication channel
    between Sentinels.
    This commit allows Pub/Sub to be used in the above two contexts where
    it was previously denied.
    committed Jul 22, 2012
Commits on Jul 18, 2012
  1. Don't assume that "char" is signed.

    For the C standard char can be either signed or unsigned, it's up to the
    compiler, but Redis assumed that it was signed in a few places.
    The practical effect of this patch is that now Redis 2.6 will run
    correctly in every system where char is unsigned, notably the RaspBerry
    PI and other ARM systems with GCC.
    Thanks to Georgi Marinov (@eesn on twitter) that reported the problem
    and allowed me to use his RaspBerry via SSH to trace and fix the issue!
    committed Jul 18, 2012
Commits on Jul 9, 2012
Commits on Jul 7, 2012
  1. Typo in comment.

    committed Jun 27, 2012
  2. REPLCONF internal command introduced.

    The REPLCONF command is an internal command (not designed to be directly
    used by normal clients) that allows a slave to set some replication
    related state in the master before issuing SYNC to start the
    The initial motivation for this command, and the only reason currently
    it is used by the implementation, is to let the slave instance
    communicate its listening port to the slave, so that the master can
    show all the slaves with their listening ports in the "replication"
    section of the INFO output.
    This allows clients to auto discover and query all the slaves attached
    into a master.
    Currently only a single option of the REPLCONF command is supported, and
    it is called "listening-port", so the slave now starts the replication
    process with something like the following chat:
        REPLCONF listening-prot 6380
    Note that this works even if the master is an older version of Redis and
    does not understand REPLCONF, because the slave ignores the REPLCONF
    In the future REPLCONF can be used for partial replication and other
    replication related features where there is the need to exchange
    information between master and slave.
    NOTE: This commit also fixes a bug: the INFO outout already carried
    information about slaves, but the port was broken, and was obtained
    with getpeername(2), so it was actually just the ephemeral port used
    by the slave to connect to the master as a client.
    committed Jun 26, 2012
Commits on Jun 21, 2012
  1. Fixed a timing attack on AUTH (Issue #560).

    The way we compared the authentication password using strcmp() allowed
    an attacker to gain information about the password using a well known
    class of attacks called "timing attacks".
    The bug appears to be practically not exploitable in most modern systems
    running Redis since even using multiple bytes of differences in the
    input at a time instead of one the difference in running time in in the
    order of 10 nanoseconds, making it hard to exploit even on LAN. However
    attacks always get better so we are providing a fix ASAP.
    The new implementation uses two fixed length buffers and a constant time
    comparison function, with the goal of:
    1) Completely avoid leaking information about the content of the
    password, since the comparison is always performed between 512
    characters and without conditionals.
    2) Partially avoid leaking information about the length of the
    About "2" we still have a stage in the code where the real password and
    the user provided password are copied in the static buffers, we also run
    two strlen() operations against the two inputs, so the running time
    of the comparison is a fixed amount plus a time proportional to
    LENGTH(A)+LENGTH(B). This means that the absolute time of the operation
    performed is still related to the length of the password in some way,
    but there is no way to change the input in order to get a difference in
    the execution time in the comparison that is not just proportional to
    the string provided by the user (because the password length is fixed).
    Thus in practical terms the user should try to discover LENGTH(PASSWORD)
    looking at the whole execution time of the AUTH command and trying to
    guess a proportionality between the whole execution time and the
    password length: this appears to be mostly unfeasible in the real world.
    Also protecting from this attack is not very useful in the case of Redis
    as a brute force attack is anyway feasible if the password is too short,
    while with a long password makes it not an issue that the attacker knows
    the length.
    committed Jun 21, 2012
Commits on Jun 15, 2012
  1. Redis 2.5.11 (2.6 RC5).

    committed Jun 15, 2012
  2. Fix c->reply_bytes computation in setDeferredMultiBulkLength()

    In order to implement reply buffer limits introduced in 2.6 and useful
    to close the connection under user-selected circumastances of big output
    buffers (for instance slow consumers in pub/sub, a blocked slave, and so
    forth) Redis takes a counter with the amount of used memory in objects
    inside the output list stored into c->reply.
    The computation was broken in the function setDeferredMultiBulkLength(),
    in the case the object was glued with the next one. This caused the
    c->reply_bytes field to go out of sync, be subtracted more than needed,
    and wrap back near to ULONG_MAX values.
    This commit fixes this bug and adds an assertion that is able to trap
    this class of problems.
    This problem was discovered looking at the INFO output of an unrelated
    issue (issue #547).
    committed Jun 15, 2012
  3. ziplistFind(): don't assume that entries are comparable by encoding.

    Because Redis 2.6 introduced new integer encodings it is no longer true
    that if two entries have a different encoding they are not equal.
    An old ziplist can be loaded from an RDB file generated with Redis 2.4,
    in this case for instance a small unsigned integers is encoded with a
    16 bit encoding, while in Redis 2.6 a more specific 8 bit encoding
    format is used.
    Because of this bug hashes ended with duplicated values or fields lookup
    failed, causing many bad behaviors.
    This in turn caused a crash while converting the ziplist encoded hash into
    a real hash table because an assertion was raised on duplicated elements.
    This commit fixes issue #547.
    Many thanks to Pinterest's Marty Weiner and colleagues for discovering
    the problem and helping us in the debugging process.
    committed Jun 14, 2012
Commits on Jun 13, 2012
  1. Standardize punctuation in redis-cli help.

    Right there is a mix of help entries ending with periods or
    without periods. This standardizes the end of command as without
    periods, which seems to be the general custom in most unix tools,
    at least.
    tnm committed with Jun 13, 2012
Commits on Jun 12, 2012
  1. Added a new hash fuzzy tester.

    The new fuzzy tester also removes elements from the hash instead of just
    adding random fields. This should increase the probability to find bugs
    in the implementations of the hash type internal representations.
    committed Jun 12, 2012
Commits on Jun 11, 2012
  1. Dump ziplist hex value on failed assertion.

    The ziplist -> hashtable conversion code is triggered every time an hash
    value must be promoted to a full hash table because the number or size of
    elements reached the threshold.
    If a problem in the ziplist causes the same field to be present
    multiple times, the assertion of successful addition of the element
    inside the hash table will fail, crashing server with a failed
    assertion, but providing little information about the problem.
    This code adds a new logging function to perform the hex dump of binary
    data, and makes sure that the ziplist -> hashtable conversion code uses
    this new logging facility to dump the content of the ziplist when the
    assertion fails.
    This change was originally made in order to investigate issue #547.
    committed Jun 11, 2012
  2. New test: hash ziplist -> hashtable encoding conversion.

    A new stress test was added to stress test the code converting a ziplist
    into an hash table.
    In this commit also randomValue helper function was modified to also
    return negative values.
    committed Jun 11, 2012
Commits on Jun 7, 2012
Commits on Jun 2, 2012
  1. EVAL replication test: less false positives.

    wait_for_condition is now used instead of the usual "after 1000" (that
    is the way to sleep in Tcl). This should avoid to find the replica in
    a state where it is loading the RDB in memory, returning -LOADING error.
    This test used to fail when running the test over valgrind, due to the
    added latencies.
    committed Jun 2, 2012
  2. Fixed RESTORE hash failure (Issue #532)

    (additional commit notes by
    The rdbIsObjectType() macro was not updated when the new RDB object type
    of ziplist encoded hashes was added.
    As a result RESTORE, that uses rdbLoadObjectType(), failed when a
    ziplist encoded hash was loaded.
    This does not affected normal RDB loading because in that case we use
    the lower-level function rdbLoadType().
    The commit also adds a regression test.
    Alex Mitrofanov committed with Jun 2, 2012
  3. RDB type loading functions clarified in comments.

    Improved comments to make clear that rdbLoadType() just loads a
    general TYPE in the context of RDB that can be an object type or an
    expire type, end-of-file, and so forth.
    While rdbLoadObjectType() enforces that the type is a valid Object Type
    otherwise it returns -1.
    committed Jun 2, 2012
Commits on May 31, 2012
  1. BITOP bug when called against non existing keys fixed.

    In the issue #529 an user reported a bug that can be triggered with the
    following code:
    set a
    bitop or x a b
    The bug was introduced with the speed optimization in commit 8bbc076
    that specializes every BITOP operation loop up to the minimum length of
    the input strings.
    However the computation of the minimum length contained an error when a
    non existing key was present in the input, after a key that was non zero
    This commit fixes the bug and adds a regression test for it.
    committed May 31, 2012
Commits on May 27, 2012
Commits on May 25, 2012
  1. Tests modified to account for INFO fields renaming.

    Commit 33e1db3 modified the name of a
    few INFO fields. This commit changes the Redis test to account for this
    committed May 25, 2012
  2. Release notes: more info about 2.4 -> 2.6 migration.

    Migration information moved at the end of the file as now they start to
    be too long to stay at the top, but a warning was added at the top of
    the file to remember the user to check.
    Added information about INFO fields that changed name between 2.4 and
    committed May 25, 2012
  3. Four new persistence fields in INFO. A few renamed.

    The 'persistence' section of INFO output now contains additional four
    fields related to RDB and AOF persistence:
     rdb_last_bgsave_time_sec       Duration of latest BGSAVE in sec.
     rdb_current_bgsave_time_sec    Duration of current BGSAVE in sec.
     aof_last_rewrite_time_sec      Duration of latest AOF rewrite in sec.
     aof_current_rewrite_time_sec   Duration of current AOF rewrite in sec.
    The 'current' fields are set to -1 if a BGSAVE / AOF rewrite is not in
    progress. The 'last' fileds are set to -1 if no previous BGSAVE / AOF
    rewrites were performed.
    Additionally a few fields in the persistence section were renamed for
     changes_since_last_save -> rdb_changes_since_last_save
     bgsave_in_progress -> rdb_bgsave_in_progress
     last_save_time -> rdb_last_save_time
     last_bgsave_status -> rdb_last_bgsave_status
     bgrewriteaof_in_progress -> aof_rewrite_in_progress
     bgrewriteaof_scheduled -> aof_rewrite_scheduled
    After the renaming, fields in the persistence section start with rdb_ or
    aof_ prefix depending on the persistence method they describe.
    The field 'loading' and related fields are not prefixed because they are
    unique for both the persistence methods.
    committed May 25, 2012
Commits on May 24, 2012
  1. BITOP command 10x speed improvement.

    This commit adds a fast-path to the BITOP that can be used for all the
    bytes from 0 to the minimal length of the string, and if there are
    at max 16 input keys.
    Often the intersected bitmaps are roughly the same size, so this
    optimization can provide a 10x speed boost to most real world usages
    of the command.
    Bytes are processed four full words at a time, in loops specialized
    for the specific BITOP sub-command, without the need to check for
    length issues with the inputs (since we run this algorithm only as far
    as there is data from all the keys at the same time).
    The remaining part of the string is intersected in the usual way using
    the slow but generic algorith.
    It is possible to do better than this with inputs that are not roughly
    the same size, sorting the input keys by length, by initializing the
    result string in a smarter way, and noticing that the final part of the
    output string composed of only data from the longest string does not
    need any proecessing since AND, OR and XOR against an empty string does
    not alter the output (zero in the first case, and the original string in
    the other two cases).
    More implementations will be implemented later likely, but this should
    be enough to release Redis 2.6-RC4 with bitops merged in.
    Note: this commit also adds better testing for BITOP NOT command, that
    is currently the faster and hard to optimize further since it just
    flips the bits of a single input string.
    committed May 23, 2012
  2. BITOP: handle integer encoded objects correctly.

    A bug in the implementation caused BITOP to crash the server if at least
    one one of the source objects was integer encoded.
    The new implementation takes an additional array of Redis objects
    pointers and calls getDecodedObject() to get a reference to a string
    encoded object, and then uses decrRefCount() to release the object.
    Tests modified to cover the regression and improve coverage.
    committed May 22, 2012
  3. BITCOUNT performance improved.

    At Redis's default optimization level the command is now much faster,
    always using a constant-time bit manipualtion technique to count bits
    instead of GCC builtin popcount, and unrolling the loop.
    The current implementation performance is 1.5GB/s in a MBA 11" (1.8 Ghz
    i7) compiled with both GCC and clang.
    The algorithm used is described here:
    committed May 20, 2012
  4. bitop.c renamed bitops.c

    bitop.c contains the "Bit related string operations" so it seems more
    logical to call it bitops instead of bitop.
    This also makes it matching the name of the test (unit/bitops.tcl).
    committed May 20, 2012
  5. Bit operations tests improved.

    Fuzzing tests of BITCOUNT / BITOP are iterated multiple times.
    The new BITCOUNT fuzzing test uses random strings in a wider interval of
    lengths including zero-len strings.
    committed May 20, 2012
  6. popcount() optimization for speed.

    We run the array by 32 bit words instead of processing it byte per byte.
    If the code is compiled using GCC __builtin_popcount() builtin function
    is used instead.
    committed May 19, 2012
  7. BITCOUNT refactoring.

    The low level popualtion counting function is now separated from the
    BITCOUNT command implementation, so that the low level function can be
    further optimized and eventually used in other contexts if needed.
    committed May 19, 2012