1. 24 Mar, 2014 1 commit
    • Matt Stancliff's avatar
      Fix data loss when save AOF/RDB with no free space · b47b343f
      Matt Stancliff authored
      Previously, the (!fp) would only catch lack of free space
      under OS X.  Linux waits to discover it can't write until
      it actually writes contents to disk.
      
      (fwrite() returns success even if the underlying file
      has no free space to write into.  All the errors
      only show up at flush/sync/close time.)
      
      Fixes antirez/redis#1604
      b47b343f
  2. 13 Feb, 2014 1 commit
    • antirez's avatar
      Update cached time in rdbLoad() callback. · 51bd9da1
      antirez authored
      server.unixtime and server.mstime are cached less precise timestamps
      that we use every time we don't need an accurate time representation and
      a syscall would be too slow for the number of calls we require.
      
      Such an example is the initialization and update process of the last
      interaction time with the client, that is used for timeouts.
      
      However rdbLoad() can take some time to load the DB, but at the same
      time it did not updated the time during DB loading. This resulted in the
      bug described in issue #1535, where in the replication process the slave
      loads the DB, creates the redisClient representation of its master, but
      the timestamp is so old that the master, under certain conditions, is
      sensed as already "timed out".
      
      Thanks to @yoav-steinberg and Redis Labs Inc for the bug report and
      analysis.
      51bd9da1
  3. 10 Dec, 2013 2 commits
    • antirez's avatar
      Slaves heartbeats during sync improved. · 11120689
      antirez authored
      The previous fix for false positive timeout detected by master was not
      complete. There is another blocking stage while loading data for the
      first synchronization with the master, that is, flushing away the
      current data from the DB memory.
      
      This commit uses the newly introduced dict.c callback in order to make
      some incremental work (to send "\n" heartbeats to the master) while
      flushing the old data from memory.
      
      It is hard to write a regression test for this issue unfortunately. More
      support for debugging in the Redis core would be needed in terms of
      functionalities to simulate a slow DB loading / deletion.
      11120689
    • antirez's avatar
      7c531eb5
  4. 09 Dec, 2013 1 commit
    • antirez's avatar
      Slaves heartbeat while loading RDB files. · 27db38d0
      antirez authored
      Starting with Redis 2.8 masters are able to detect timed out slaves,
      while before 2.8 only slaves were able to detect a timed out master.
      
      Now that timeout detection is bi-directional the following problem
      happens as described "in the field" by issue #1449:
      
      1) Master and slave setup with big dataset.
      2) Slave performs the first synchronization, or a full sync
         after a failed partial resync.
      3) Master sends the RDB payload to the slave.
      4) Slave loads this payload.
      5) Master detects the slave as timed out since does not receive back the
         REPLCONF ACK acknowledges.
      
      Here the problem is that the master has no way to know how much the
      slave will take to load the RDB file in memory. The obvious solution is
      to use a greater replication timeout setting, but this is a shame since
      for the 0.1% of operation time we are forced to use a timeout that is
      not what is suited for 99.9% of operation time.
      
      This commit tries to fix this problem with a solution that is a bit of
      an hack, but that modifies little of the replication internals, in order
      to be back ported to 2.8 safely.
      
      During the RDB loading time, we send the master newlines to avoid
      being sensed as timed out. This is the same that the master already does
      while saving the RDB file to still signal its presence to the slave.
      
      The single newline is used because:
      
      1) It can't desync the protocol, as it is only transmitted all or
      nothing.
      2) It can be safely sent while we don't have a client structure for the
      master or in similar situations just with write(2).
      27db38d0
  5. 05 Dec, 2013 1 commit
  6. 07 Nov, 2013 1 commit
  7. 27 Aug, 2013 1 commit
  8. 20 Aug, 2013 1 commit
  9. 22 Jul, 2013 1 commit
    • antirez's avatar
      Introduction of a new string encoding: EMBSTR · 894eba07
      antirez authored
      Previously two string encodings were used for string objects:
      
      1) REDIS_ENCODING_RAW: a string object with obj->ptr pointing to an sds
      stirng.
      
      2) REDIS_ENCODING_INT: a string object where the obj->ptr void pointer
      is casted to a long.
      
      This commit introduces a experimental new encoding called
      REDIS_ENCODING_EMBSTR that implements an object represented by an sds
      string that is not modifiable but allocated in the same memory chunk as
      the robj structure itself.
      
      The chunk looks like the following:
      
      +--------------+-----------+------------+--------+----+
      | robj data... | robj->ptr | sds header | string | \0 |
      +--------------+-----+-----+------------+--------+----+
                           |                       ^
                           +-----------------------+
      
      The robj->ptr points to the contiguous sds string data, so the object
      can be manipulated with the same functions used to manipulate plan
      string objects, however we need just on malloc and one free in order to
      allocate or release this kind of objects. Moreover it has better cache
      locality.
      
      This new allocation strategy should benefit both the memory usage and
      the performances. A performance gain between 60 and 70% was observed
      during micro-benchmarks, however there is more work to do to evaluate
      the performance impact and the memory usage behavior.
      894eba07
  10. 16 Jul, 2013 1 commit
  11. 05 Jul, 2013 1 commit
  12. 02 Apr, 2013 1 commit
    • antirez's avatar
      Throttle BGSAVE attempt on saving error. · b237de33
      antirez authored
      When a BGSAVE fails, Redis used to flood itself trying to BGSAVE at
      every next cron call, that is either 10 or 100 times per second
      depending on configuration and server version.
      
      This commit does not allow a new automatic BGSAVE attempt to be
      performed before a few seconds delay (currently 5).
      
      This avoids both the auto-flood problem and filling the disk with
      logs at a serious rate.
      
      The five seconds limit, considering a log entry of 200 bytes, will use
      less than 4 MB of disk space per day that is reasonable, the sysadmin
      should notice before of catastrofic events especially since by default
      Redis will stop serving write queries after the first failed BGSAVE.
      
      This fixes issue #849
      b237de33
  13. 12 Mar, 2013 2 commits
  14. 27 Feb, 2013 1 commit
  15. 26 Feb, 2013 1 commit
    • antirez's avatar
      Set process name in ps output to make operations safer. · 6356cf68
      antirez authored
      This commit allows Redis to set a process name that includes the binding
      address and the port number in order to make operations simpler.
      
      Redis children processes doing AOF rewrites or RDB saving change the
      name into redis-aof-rewrite and redis-rdb-bgsave respectively.
      
      This in general makes harder to kill the wrong process because of an
      error and makes simpler to identify saving children.
      
      This feature was suggested by Arnaud GRANAL in the Redis Google Group,
      Arnaud also pointed me to the setproctitle.c implementation includeed in
      this commit.
      
      This feature should work on all the Linux, OSX, and all the three major
      BSD systems.
      6356cf68
  16. 19 Jan, 2013 2 commits
    • antirez's avatar
      Whitelist SIGUSR1 to avoid auto-triggering errors. · 79a0ef62
      antirez authored
      This commit fixes issue #875 that was caused by the following events:
      
      1) There is an active child doing BGSAVE.
      2) flushall is called (or any other condition that makes Redis killing
      the saving child process).
      3) An error is sensed by Redis as the child exited with an error (killed
      by a singal), that stops accepting write commands until a BGSAVE happens
      to be executed with success.
      
      Whitelisting SIGUSR1 and making sure Redis always uses this signal in
      order to kill its own children fixes the issue.
      79a0ef62
    • guiquanz's avatar
      Fixed many typos. · 9d09ce39
      guiquanz authored
      9d09ce39
  17. 19 Nov, 2012 1 commit
    • antirez's avatar
      Children creating AOF or RDB files now report memory used by COW. · 49b64523
      antirez authored
      Finally Redis is able to report the amount of memory used by
      copy-on-write while saving an RDB or writing an AOF file in background.
      
      Note that this information is currently only logged (at NOTICE level)
      and not shown in INFO because this is less trivial (but surely doable
      with some minor form of interprocess communication).
      
      The reason we can't capture this information on the parent before we
      call wait3() is that the Linux kernel will release the child memory
      ASAP, and only retain the minimal state for the process that is useful
      to report the child termination to the parent.
      
      The COW size is obtained by summing all the Private_Dirty fields found
      in the "smap" file inside the proc filesystem for the process.
      
      All this is Linux specific and is not available on other systems.
      49b64523
  18. 08 Nov, 2012 1 commit
  19. 24 Oct, 2012 1 commit
  20. 02 Jun, 2012 1 commit
    • antirez's avatar
      RDB type loading functions clarified in comments. · c7a25200
      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.
      c7a25200
  21. 25 May, 2012 1 commit
    • antirez's avatar
      Four new persistence fields in INFO. A few renamed. · 33e1db36
      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.
      33e1db36
  22. 24 Apr, 2012 1 commit
  23. 10 Apr, 2012 1 commit
  24. 09 Apr, 2012 3 commits
  25. 07 Apr, 2012 4 commits
  26. 31 Mar, 2012 1 commit
  27. 23 Mar, 2012 1 commit
  28. 13 Mar, 2012 2 commits
  29. 10 Mar, 2012 1 commit
  30. 07 Mar, 2012 1 commit
    • antirez's avatar
      Refuse writes if can't persist on disk. · c25e7eaf
      antirez authored
      Redis now refuses accepting write queries if RDB persistence is
      configured, but RDB snapshots can't be generated for some reason.
      The status of the latest background save operation is now exposed
      in the INFO output as well. This fixes issue #90.
      c25e7eaf
  31. 16 Feb, 2012 1 commit
    • Pieter Noordhuis's avatar
      Don't expire keys when loading an RDB after a SYNC · cb598cdd
      Pieter Noordhuis authored
      The cron is responsible for expiring keys. When keys are expired at
      load time, it is possible that the snapshot of a master node gets
      modified. This can in turn lead to inconsistencies in the data set.
      
      A more concrete example of this behavior follows. A user reported a
      slave that would show an monotonically increase input buffer length,
      shortly after completing a SYNC. Also, `INFO` output showed a single
      blocked client, which could only be the master link. Investigation
      showed that indeed the `BRPOP` command was fed by the master. This
      command can only end up in the stream of write operations when it did
      NOT block, and effectively executed `RPOP`. However, when the key
      involved in the `BRPOP` is expired BEFORE the command is executed, the
      client executing it will block. The client in this case, is the master
      link.
      cb598cdd