1. 05 Mar, 2020 1 commit
    • antirez's avatar
      Inline protocol: handle empty strings well. · 7569b210
      antirez authored
      This bug is from the first version of Redis. Probably the problem here
      is that before we used an SDS split function that created empty strings
      for additional spaces, like in "SET    foo          bar".
      AFAIK later we replaced it with the curretn sdssplitarg() API that has
      no such a problem. As a result, we introduced a bug, where it is no
      longer possible to do something like:
      
          SET foo ""
      
      Using the inline protocol. Now it is fixed.
      7569b210
  2. 12 Feb, 2020 1 commit
  3. 10 Feb, 2020 1 commit
  4. 08 Jan, 2020 1 commit
  5. 19 Nov, 2019 17 commits
  6. 14 Nov, 2019 9 commits
  7. 06 Nov, 2019 3 commits
    • antirez's avatar
      Update PR #6537: use a fresh time outside call(). · d3f4dec4
      antirez authored
      One problem with the solution proposed so far in #6537 is that key
      lookups outside a command execution via call(), still used a cached
      time. The cached time needed to be refreshed in multiple places,
      especially because of modules callbacks from timers, cluster bus, and
      thread safe contexts, that may use RM_Open().
      
      In order to avoid this problem, this commit introduces the ability to
      detect if we are inside call(): this way we can use the reference fixed
      time only when we are in the context of a command execution or Lua
      script, but for the asynchronous lookups, we can still use mstime() to
      get a fresh time reference.
      d3f4dec4
    • antirez's avatar
      Update PR #6537 patch to for generality. · 33f42665
      antirez authored
      After the thread in #6537 and thanks to the suggestions received, this
      commit updates the original patch in order to:
      
      1. Solve the problem of updating the time in multiple places by updating
      it in call().
      2. Avoid introducing a new field but use our cached time.
      
      This required some minor refactoring to the function updating the time,
      and the introduction of a new cached time in microseconds in order to
      use less gettimeofday() calls.
      33f42665
    • zhaozhao.zz's avatar
      expires: refactoring judgment about whether a key is expired · 68d71d83
      zhaozhao.zz authored
      Calling lookupKey*() many times to search a key in one command
      may get different result.
      
      That's because lookupKey*() calls expireIfNeeded(), and delete
      the key when reach the expire time. So we can get an robj before
      the expire time, but a NULL after the expire time.
      
      The worst is that may lead to Redis crash, for example
      `RPOPLPUSH foo foo` the first time we get a list form `foo` and
      hold the pointer, but when we get `foo` again it's expired and
      deleted. Now we hold a freed memory, when execute rpoplpushHandlePush()
      redis crash.
      
      To fix it, we can refactor the judgment about whether a key is expired,
      using the same basetime `server.cmd_start_mstime` instead of calling
      mstime() everytime.
      68d71d83
  8. 31 Oct, 2019 1 commit
    • antirez's avatar
      Modules: fix thread safe context creation crash. · 62588dbf
      antirez authored
      See #6525, this likely creates a NULL deference if the client was
      terminated by Redis between the creation of the blocked client and the
      creation of the thread safe context.
      62588dbf
  9. 25 Sep, 2019 6 commits