aboutsummaryrefslogtreecommitdiff
path: root/gnu/packages/patches/ceph-rocksdb-compat.patch
blob: 9fb9b0caebf81731a612389b442516cea9b5d0d4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
Adjust for newer versions of RocksDB.

Taken from upstream:

  https://github.com/ceph/ceph/pull/42815
  https://github.com/ceph/ceph/commit/ff7f192ea3cf88ca1098bcf9396ff4f8ed1e8792.diff

diff --git a/src/kv/rocksdb_cache/BinnedLRUCache.cc b/src/kv/rocksdb_cache/BinnedLRUCache.cc
index 0d657883e92de..47c56e2ddd769 100644
--- a/src/kv/rocksdb_cache/BinnedLRUCache.cc
+++ b/src/kv/rocksdb_cache/BinnedLRUCache.cc
@@ -151,13 +151,20 @@ void BinnedLRUCacheShard::EraseUnRefEntries() {
   }
 }
 
-void BinnedLRUCacheShard::ApplyToAllCacheEntries(void (*callback)(void*, size_t),
-                                           bool thread_safe) {
+void BinnedLRUCacheShard::ApplyToAllCacheEntries(
+  const std::function<void(const rocksdb::Slice& key,
+                           void* value,
+                           size_t charge,
+                           DeleterFn)>& callback,
+  bool thread_safe)
+{
   if (thread_safe) {
     mutex_.lock();
   }
   table_.ApplyToAllCacheEntries(
-      [callback](BinnedLRUHandle* h) { callback(h->value, h->charge); });
+    [callback](BinnedLRUHandle* h) {
+      callback(h->key(), h->value, h->charge, h->deleter);
+    });
   if (thread_safe) {
     mutex_.unlock();
   }
@@ -345,7 +352,7 @@ bool BinnedLRUCacheShard::Release(rocksdb::Cache::Handle* handle, bool force_era
 
 rocksdb::Status BinnedLRUCacheShard::Insert(const rocksdb::Slice& key, uint32_t hash, void* value,
                              size_t charge,
-                             void (*deleter)(const rocksdb::Slice& key, void* value),
+                             DeleterFn deleter,
                              rocksdb::Cache::Handle** handle, rocksdb::Cache::Priority priority) {
   auto e = new BinnedLRUHandle();
   rocksdb::Status s;
@@ -464,6 +471,12 @@ std::string BinnedLRUCacheShard::GetPrintableOptions() const {
   return std::string(buffer);
 }
 
+DeleterFn BinnedLRUCacheShard::GetDeleter(rocksdb::Cache::Handle* h) const
+{
+  auto* handle = reinterpret_cast<BinnedLRUHandle*>(h);
+  return handle->deleter;
+}
+
 BinnedLRUCache::BinnedLRUCache(CephContext *c, 
                                size_t capacity, 
                                int num_shard_bits,
@@ -519,6 +532,13 @@ void BinnedLRUCache::DisownData() {
 #endif  // !__SANITIZE_ADDRESS__
 }
 
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+DeleterFn BinnedLRUCache::GetDeleter(Handle* handle) const
+{
+  return reinterpret_cast<const BinnedLRUHandle*>(handle)->deleter;
+}
+#endif
+
 size_t BinnedLRUCache::TEST_GetLRUSize() {
   size_t lru_size_of_all_shards = 0;
   for (int i = 0; i < num_shards_; i++) {
diff --git a/src/kv/rocksdb_cache/BinnedLRUCache.h b/src/kv/rocksdb_cache/BinnedLRUCache.h
index 85608be0e5734..88bf4502e8927 100644
--- a/src/kv/rocksdb_cache/BinnedLRUCache.h
+++ b/src/kv/rocksdb_cache/BinnedLRUCache.h
@@ -56,7 +56,7 @@ std::shared_ptr<rocksdb::Cache> NewBinnedLRUCache(
 
 struct BinnedLRUHandle {
   void* value;
-  void (*deleter)(const rocksdb::Slice&, void* value);
+  DeleterFn deleter;
   BinnedLRUHandle* next_hash;
   BinnedLRUHandle* next;
   BinnedLRUHandle* prev;
@@ -189,7 +189,7 @@ class alignas(CACHE_LINE_SIZE) BinnedLRUCacheShard : public CacheShard {
   // Like Cache methods, but with an extra "hash" parameter.
   virtual rocksdb::Status Insert(const rocksdb::Slice& key, uint32_t hash, void* value,
                         size_t charge,
-                        void (*deleter)(const rocksdb::Slice& key, void* value),
+                        DeleterFn deleter,
                         rocksdb::Cache::Handle** handle,
                         rocksdb::Cache::Priority priority) override;
   virtual rocksdb::Cache::Handle* Lookup(const rocksdb::Slice& key, uint32_t hash) override;
@@ -205,13 +205,19 @@ class alignas(CACHE_LINE_SIZE) BinnedLRUCacheShard : public CacheShard {
   virtual size_t GetUsage() const override;
   virtual size_t GetPinnedUsage() const override;
 
-  virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
-                                      bool thread_safe) override;
+  virtual void ApplyToAllCacheEntries(
+    const std::function<void(const rocksdb::Slice& key,
+                             void* value,
+                             size_t charge,
+                             DeleterFn)>& callback,
+    bool thread_safe) override;
 
   virtual void EraseUnRefEntries() override;
 
   virtual std::string GetPrintableOptions() const override;
 
+  virtual DeleterFn GetDeleter(rocksdb::Cache::Handle* handle) const override;
+
   void TEST_GetLRUList(BinnedLRUHandle** lru, BinnedLRUHandle** lru_low_pri);
 
   //  Retrieves number of elements in LRU, for unit test purpose only
@@ -304,7 +310,9 @@ class BinnedLRUCache : public ShardedCache {
   virtual size_t GetCharge(Handle* handle) const override;
   virtual uint32_t GetHash(Handle* handle) const override;
   virtual void DisownData() override;
-
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+  virtual DeleterFn GetDeleter(Handle* handle) const override;
+#endif
   //  Retrieves number of elements in LRU, for unit test purpose only
   size_t TEST_GetLRUSize();
   // Sets the high pri pool ratio
diff --git a/src/kv/rocksdb_cache/ShardedCache.cc b/src/kv/rocksdb_cache/ShardedCache.cc
index 367140a94d8be..6cbd89ad6472c 100644
--- a/src/kv/rocksdb_cache/ShardedCache.cc
+++ b/src/kv/rocksdb_cache/ShardedCache.cc
@@ -44,7 +44,7 @@ void ShardedCache::SetStrictCapacityLimit(bool strict_capacity_limit) {
 }
 
 rocksdb::Status ShardedCache::Insert(const rocksdb::Slice& key, void* value, size_t charge,
-                            void (*deleter)(const rocksdb::Slice& key, void* value),
+                            DeleterFn deleter,
                             rocksdb::Cache::Handle** handle, Priority priority) {
   uint32_t hash = HashSlice(key);
   return GetShard(Shard(hash))
@@ -109,13 +109,36 @@ size_t ShardedCache::GetPinnedUsage() const {
   return usage;
 }
 
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+DeleterFn ShardedCache::GetDeleter(Handle* handle) const
+{
+  uint32_t hash = GetHash(handle);
+  return GetShard(Shard(hash))->GetDeleter(handle);
+}
+
+void ShardedCache::ApplyToAllEntries(
+    const std::function<void(const rocksdb::Slice& key, void* value, size_t charge,
+                             DeleterFn deleter)>& callback,
+    const ApplyToAllEntriesOptions& opts)
+{
+  int num_shards = 1 << num_shard_bits_;
+  for (int s = 0; s < num_shards; s++) {
+    GetShard(s)->ApplyToAllCacheEntries(callback, true /* thread_safe */);
+  }
+}
+#else
 void ShardedCache::ApplyToAllCacheEntries(void (*callback)(void*, size_t),
                                           bool thread_safe) {
   int num_shards = 1 << num_shard_bits_;
   for (int s = 0; s < num_shards; s++) {
-    GetShard(s)->ApplyToAllCacheEntries(callback, thread_safe);
+    GetShard(s)->ApplyToAllCacheEntries(
+      [callback](const rocksdb::Slice&, void* value, size_t charge, DeleterFn) {
+        callback(value, charge);
+      },
+      thread_safe);
   }
 }
+#endif
 
 void ShardedCache::EraseUnRefEntries() {
   int num_shards = 1 << num_shard_bits_;
@@ -131,7 +154,7 @@ std::string ShardedCache::GetPrintableOptions() const {
   char buffer[kBufferSize];
   {
     std::lock_guard<std::mutex> l(capacity_mutex_);
-    snprintf(buffer, kBufferSize, "    capacity : %" ROCKSDB_PRIszt "\n",
+    snprintf(buffer, kBufferSize, "    capacity : %zu\n",
              capacity_);
     ret.append(buffer);
     snprintf(buffer, kBufferSize, "    num_shard_bits : %d\n", num_shard_bits_);
diff --git a/src/kv/rocksdb_cache/ShardedCache.h b/src/kv/rocksdb_cache/ShardedCache.h
index 4d64893ab1c7b..f98421a09a33a 100644
--- a/src/kv/rocksdb_cache/ShardedCache.h
+++ b/src/kv/rocksdb_cache/ShardedCache.h
@@ -14,6 +14,7 @@
 #include <string>
 #include <mutex>
 
+#include "rocksdb/version.h"
 #include "rocksdb/cache.h"
 #include "include/ceph_hash.h"
 #include "common/PriorityCache.h"
@@ -22,10 +23,11 @@
 #ifndef CACHE_LINE_SIZE
 #define CACHE_LINE_SIZE 64 // XXX arch-specific define 
 #endif
-#define ROCKSDB_PRIszt "zu"
 
 namespace rocksdb_cache {
 
+using DeleterFn = void (*)(const rocksdb::Slice& key, void* value);
+
 // Single cache shard interface.
 class CacheShard {
  public:
@@ -34,7 +36,7 @@ class CacheShard {
 
   virtual rocksdb::Status Insert(const rocksdb::Slice& key, uint32_t hash, void* value,
                                  size_t charge,
-                                 void (*deleter)(const rocksdb::Slice& key, void* value),
+                                 DeleterFn deleter,
                                  rocksdb::Cache::Handle** handle, rocksdb::Cache::Priority priority) = 0;
   virtual rocksdb::Cache::Handle* Lookup(const rocksdb::Slice& key, uint32_t hash) = 0;
   virtual bool Ref(rocksdb::Cache::Handle* handle) = 0;
@@ -44,10 +46,15 @@ class CacheShard {
   virtual void SetStrictCapacityLimit(bool strict_capacity_limit) = 0;
   virtual size_t GetUsage() const = 0;
   virtual size_t GetPinnedUsage() const = 0;
-  virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
-                                      bool thread_safe) = 0;
+  virtual void ApplyToAllCacheEntries(
+    const std::function<void(const rocksdb::Slice& key,
+                             void* value,
+                             size_t charge,
+                             DeleterFn)>& callback,
+    bool thread_safe) = 0;
   virtual void EraseUnRefEntries() = 0;
   virtual std::string GetPrintableOptions() const { return ""; }
+  virtual DeleterFn GetDeleter(rocksdb::Cache::Handle* handle) const = 0;
 };
 
 // Generic cache interface which shards cache by hash of keys. 2^num_shard_bits
@@ -57,34 +64,43 @@ class ShardedCache : public rocksdb::Cache, public PriorityCache::PriCache {
  public:
   ShardedCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit);
   virtual ~ShardedCache() = default;
+  // rocksdb::Cache
   virtual const char* Name() const override = 0;
-  virtual CacheShard* GetShard(int shard) = 0;
-  virtual const CacheShard* GetShard(int shard) const = 0;
-  virtual void* Value(Handle* handle) override = 0;
-  virtual size_t GetCharge(Handle* handle) const = 0;
-  virtual uint32_t GetHash(Handle* handle) const = 0;
-  virtual void DisownData() override = 0;
-
-  virtual void SetCapacity(size_t capacity) override;
-  virtual void SetStrictCapacityLimit(bool strict_capacity_limit) override;
-
   virtual rocksdb::Status Insert(const rocksdb::Slice& key, void* value, size_t charge,
-                                 void (*deleter)(const rocksdb::Slice& key, void* value),
+                                 DeleterFn,
                                  rocksdb::Cache::Handle** handle, Priority priority) override;
   virtual rocksdb::Cache::Handle* Lookup(const rocksdb::Slice& key, rocksdb::Statistics* stats) override;
   virtual bool Ref(rocksdb::Cache::Handle* handle) override;
   virtual bool Release(rocksdb::Cache::Handle* handle, bool force_erase = false) override;
+  virtual void* Value(Handle* handle) override = 0;
   virtual void Erase(const rocksdb::Slice& key) override;
   virtual uint64_t NewId() override;
-  virtual size_t GetCapacity() const override;
+  virtual void SetCapacity(size_t capacity) override;
+  virtual void SetStrictCapacityLimit(bool strict_capacity_limit) override;
   virtual bool HasStrictCapacityLimit() const override;
+  virtual size_t GetCapacity() const override;
   virtual size_t GetUsage() const override;
   virtual size_t GetUsage(rocksdb::Cache::Handle* handle) const override;
   virtual size_t GetPinnedUsage() const override;
+  virtual size_t GetCharge(Handle* handle) const = 0;
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+  virtual DeleterFn GetDeleter(Handle* handle) const override;
+#endif
+  virtual void DisownData() override = 0;
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+  virtual void ApplyToAllEntries(
+      const std::function<void(const rocksdb::Slice& key, void* value, size_t charge,
+                               DeleterFn deleter)>& callback,
+      const ApplyToAllEntriesOptions& opts) override;
+#else
   virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
                                       bool thread_safe) override;
+#endif
   virtual void EraseUnRefEntries() override;
   virtual std::string GetPrintableOptions() const override;
+  virtual CacheShard* GetShard(int shard) = 0;
+  virtual const CacheShard* GetShard(int shard) const = 0;
+  virtual uint32_t GetHash(Handle* handle) const = 0;
 
   int GetNumShardBits() const { return num_shard_bits_; }
 
@@ -120,7 +136,7 @@ class ShardedCache : public rocksdb::Cache, public PriorityCache::PriCache {
 //    return Hash(s.data(), s.size(), 0);
   }
 
-  uint32_t Shard(uint32_t hash) {
+  uint32_t Shard(uint32_t hash) const {
     // Note, hash >> 32 yields hash in gcc, not the zero we expect!
     return (num_shard_bits_ > 0) ? (hash >> (32 - num_shard_bits_)) : 0;
   }