1. 24 Aug, 2012 2 commits
    • antirez's avatar
    • antirez's avatar
      Better Out of Memory handling. · 5de75120
      antirez authored
      The previous implementation of zmalloc.c was not able to handle out of
      memory in an application-specific way. It just logged an error on
      standard error, and aborted.
      
      The result was that in the case of an actual out of memory in Redis
      where malloc returned NULL (In Linux this actually happens under
      specific overcommit policy settings and/or with no or little swap
      configured) the error was not properly logged in the Redis log.
      
      This commit fixes this problem, fixing issue #509.
      Now the out of memory is properly reported in the Redis log and a stack
      trace is generated.
      
      The approach used is to provide a configurable out of memory handler
      to zmalloc (otherwise the default one logging the event on the
      standard output is used).
      5de75120
  2. 22 Aug, 2012 4 commits
  3. 02 Aug, 2012 1 commit
  4. 01 Aug, 2012 1 commit
  5. 31 Jul, 2012 3 commits
    • Michael Parker's avatar
      Use correct variable name for value to convert. · 628890e4
      Michael Parker authored
      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
      past.
      
      This should provide a noticeable speed boost when saving certain types
      of databases with many sorted sets inside.
      628890e4
    • Saj Goonatilleke's avatar
      Truncate short write from the AOF · 4c0c1fff
      Saj Goonatilleke authored
      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.
      4c0c1fff
    • Saj Goonatilleke's avatar
      New in INFO: aof_last_bgrewrite_status · f00b0844
      Saj Goonatilleke authored
      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.)
      f00b0844
  6. 22 Jul, 2012 2 commits
    • Steeve Lennmark's avatar
    • antirez's avatar
      Allow Pub/Sub in contexts where other commands are blocked. · 3bb3f125
      antirez authored
      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.
      3bb3f125
  7. 18 Jul, 2012 1 commit
    • antirez's avatar
      Don't assume that "char" is signed. · 82675c86
      antirez authored
      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!
      82675c86
  8. 09 Jul, 2012 1 commit
  9. 07 Jul, 2012 2 commits
    • antirez's avatar
      Typo in comment. · d3d56742
      antirez authored
      d3d56742
    • antirez's avatar
      REPLCONF internal command introduced. · dbd8c753
      antirez authored
      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
      replication.
      
      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
          SYNC
      
      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
      error.
      
      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.
      dbd8c753
  10. 21 Jun, 2012 2 commits
    • antirez's avatar
      b3f28b90
    • antirez's avatar
      Fixed a timing attack on AUTH (Issue #560). · 4b3865cb
      antirez authored
      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
      password.
      
      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.
      4b3865cb
  11. 15 Jun, 2012 3 commits
    • antirez's avatar
      Redis 2.5.11 (2.6 RC5). · 0c9cf452
      antirez authored
      0c9cf452
    • antirez's avatar
      Fix c->reply_bytes computation in setDeferredMultiBulkLength() · 6fe9c402
      antirez authored
      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).
      6fe9c402
    • antirez's avatar
      ziplistFind(): don't assume that entries are comparable by encoding. · 8361d6c4
      antirez authored
      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.
      8361d6c4
  12. 13 Jun, 2012 1 commit
    • Ted Nyman's avatar
      Standardize punctuation in redis-cli help. · e612508d
      Ted Nyman authored
      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.
      e612508d
  13. 12 Jun, 2012 1 commit
    • antirez's avatar
      Added a new hash fuzzy tester. · 1364395f
      antirez authored
      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.
      1364395f
  14. 11 Jun, 2012 2 commits
    • antirez's avatar
      Dump ziplist hex value on failed assertion. · 0b8441c1
      antirez authored
      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.
      0b8441c1
    • antirez's avatar
      New test: hash ziplist -> hashtable encoding conversion. · a85c8985
      antirez authored
      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.
      a85c8985
  15. 07 Jun, 2012 1 commit
  16. 02 Jun, 2012 3 commits
    • antirez's avatar
      EVAL replication test: less false positives. · 3f126567
      antirez authored
      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.
      3f126567
    • Alex Mitrofanov's avatar
      Fixed RESTORE hash failure (Issue #532) · 591c9e65
      Alex Mitrofanov authored
      (additional commit notes by antirez@gmail.com):
      
      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.
      591c9e65
    • antirez's avatar
      RDB type loading functions clarified in comments. · ebdcd723
      antirez authored
      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.
      ebdcd723
  17. 31 May, 2012 1 commit
    • antirez's avatar
      BITOP bug when called against non existing keys fixed. · 8f0658cd
      antirez authored
      In the issue #529 an user reported a bug that can be triggered with the
      following code:
      
      flushdb
      set a
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      bitop or x a b
      
      The bug was introduced with the speed optimization in commit 8bbc0768
      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
      length.
      
      This commit fixes the bug and adds a regression test for it.
      8f0658cd
  18. 27 May, 2012 1 commit
  19. 25 May, 2012 3 commits
    • antirez's avatar
      Tests modified to account for INFO fields renaming. · 473f3090
      antirez authored
      Commit 33e1db36 modified the name of a
      few INFO fields. This commit changes the Redis test to account for this
      changes.
      473f3090
    • antirez's avatar
      Release notes: more info about 2.4 -> 2.6 migration. · 69396249
      antirez authored
      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
      2.6.
      69396249
    • antirez's avatar
      Four new persistence fields in INFO. A few renamed. · 6b4d92e2
      antirez authored
      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
      consistency:
      
       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.
      6b4d92e2
  20. 24 May, 2012 5 commits
    • antirez's avatar
      BITOP command 10x speed improvement. · 8bbc0768
      antirez authored
      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.
      8bbc0768
    • antirez's avatar
      BITOP: handle integer encoded objects correctly. · f0d962c0
      antirez authored
      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.
      f0d962c0
    • antirez's avatar
      BITCOUNT performance improved. · c19bfe9f
      antirez authored
      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:
      
      http://graphics.stanford.edu/~seander/bithacks.html
      c19bfe9f
    • antirez's avatar
      bitop.c renamed bitops.c · e53a1fdd
      antirez authored
      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).
      e53a1fdd
    • antirez's avatar
      Bit operations tests improved. · 951213e2
      antirez authored
      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.
      951213e2