GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/kvstore.cc
Date: 2025-09-28 02:35:26
Exec Total Coverage
Lines: 193 249 77.5%
Branches: 112 258 43.4%
Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 */
4
5 #include "kvstore.h"
6
7 #include <assert.h>
8 #include <errno.h>
9 #include <limits.h>
10 #include <string.h>
11 #include <unistd.h>
12
13 #include <algorithm>
14
15 #include "util/async.h"
16 #include "util/concurrency.h"
17 #include "util/logging.h"
18
19 using namespace std; // NOLINT
20
21 namespace {
22
23 3466010 static inline uint32_t hasher_any(const shash::Any &key) {
24 // We'll just do the same thing as hasher_md5, since every hash is at
25 // least as large.
26 return static_cast<uint32_t>(
27 3466010 *(reinterpret_cast<const uint32_t *>(key.digest) + 1));
28 }
29
30 } // anonymous namespace
31
32 const double MemoryKvStore::kCompactThreshold = 0.8;
33
34
35 2209 MemoryKvStore::MemoryKvStore(unsigned int cache_entries,
36 MemoryAllocator alloc,
37 unsigned alloc_size,
38 2209 perf::StatisticsTemplate statistics)
39 2209 : allocator_(alloc)
40 2209 , used_bytes_(0)
41 2209 , entry_count_(0)
42 2209 , max_entries_(cache_entries)
43
2/4
✓ Branch 1 taken 2209 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 2209 times.
✗ Branch 5 not taken.
 2209 , entries_(cache_entries, shash::Any(), hasher_any,
44
2/4
✓ Branch 2 taken 2209 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 2209 times.
✗ Branch 6 not taken.
 4418 perf::StatisticsTemplate("lru", statistics))
45 2209 , heap_(NULL)
46
2/4
✓ Branch 2 taken 2209 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 2209 times.
✗ Branch 6 not taken.
 4418 , counters_(statistics) {
47 2209 const int retval = pthread_rwlock_init(&rwlock_, NULL);
48
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2209 times.
 2209 assert(retval == 0);
49
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 2161 times.
 2209 switch (alloc) {
50 48 case kMallocHeap:
51 48 heap_ = new MallocHeap(
52
3/6
✓ Branch 1 taken 48 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 48 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 48 times.
✗ Branch 8 not taken.
 48 alloc_size, this->MakeCallback(&MemoryKvStore::OnBlockMove, this));
53 48 break;
54 2161 default:
55 2161 break;
56 }
57 2209 }
58
59
60 2209 MemoryKvStore::~MemoryKvStore() {
61
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 2161 times.
 2209 delete heap_;
62 2209 pthread_rwlock_destroy(&rwlock_);
63 2209 }
64
65
66 ✗ void MemoryKvStore::OnBlockMove(const MallocHeap::BlockPtr &ptr) {
67 bool ok;
68 ✗ struct AllocHeader a;
69 ✗ MemoryBuffer buf;
70
71 // must be locked by caller
72 ✗ assert(ptr.pointer);
73 ✗ memcpy(&a, ptr.pointer, sizeof(a));
74 ✗ LogCvmfs(kLogKvStore, kLogDebug, "compaction moved %s to %p",
75 ✗ a.id.ToString().c_str(), ptr.pointer);
76 ✗ assert(a.version == 0);
77 ✗ const bool update_lru = false;
78 ✗ ok = entries_.Lookup(a.id, &buf, update_lru);
79 ✗ assert(ok);
80 ✗ buf.address = static_cast<char *>(ptr.pointer) + sizeof(a);
81 ✗ ok = entries_.UpdateValue(buf.id, buf);
82 ✗ assert(ok);
83 }
84
85
86 2352 bool MemoryKvStore::Contains(const shash::Any &id) {
87
1/2
✓ Branch 1 taken 2352 times.
✗ Branch 2 not taken.
 2352 MemoryBuffer buf;
88 // LogCvmfs(kLogKvStore, kLogDebug, "check buffer %s", id.ToString().c_str());
89 2352 const bool update_lru = false;
90
1/2
✓ Branch 1 taken 2352 times.
✗ Branch 2 not taken.
 4704 return entries_.Lookup(id, &buf, update_lru);
91 }
92
93
94 5947 int MemoryKvStore::DoMalloc(MemoryBuffer *buf) {
95
1/2
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
 5947 MemoryBuffer tmp;
96
1/2
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
 5947 AllocHeader a;
97
98
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5947 times.
 5947 assert(buf);
99 5947 memcpy(&tmp, buf, sizeof(tmp));
100
101 5947 tmp.address = NULL;
102
1/2
✓ Branch 0 taken 5947 times.
✗ Branch 1 not taken.
 5947 if (tmp.size > 0) {
103
1/3
✓ Branch 0 taken 5947 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 5947 switch (allocator_) {
104 5947 case kMallocLibc:
105 5947 tmp.address = malloc(tmp.size);
106
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5947 times.
 5947 if (!tmp.address)
107 ✗ return -errno;
108 5947 break;
109 ✗ case kMallocHeap:
110 ✗ assert(heap_);
111 ✗ a.id = tmp.id;
112 ✗ tmp.address = heap_->Allocate(tmp.size + sizeof(a), &a, sizeof(a));
113 ✗ if (!tmp.address)
114 ✗ return -ENOMEM;
115 ✗ tmp.address = static_cast<char *>(tmp.address) + sizeof(a);
116 ✗ break;
117 ✗ default:
118 ✗ abort();
119 }
120 }
121
122 5947 memcpy(buf, &tmp, sizeof(*buf));
123 5947 return 0;
124 }
125
126
127 4399 void MemoryKvStore::DoFree(MemoryBuffer *buf) {
128
1/2
✓ Branch 1 taken 4399 times.
✗ Branch 2 not taken.
 4399 const AllocHeader a;
129
130
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4399 times.
 4399 assert(buf);
131
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4399 times.
 4399 if (!buf->address)
132 ✗ return;
133
1/3
✓ Branch 0 taken 4399 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 4399 switch (allocator_) {
134 4399 case kMallocLibc:
135 4399 free(buf->address);
136 4399 return;
137 ✗ case kMallocHeap:
138 ✗ heap_->MarkFree(static_cast<char *>(buf->address) - sizeof(a));
139 ✗ return;
140 ✗ default:
141 ✗ abort();
142 }
143 }
144
145
146 5947 bool MemoryKvStore::CompactMemory() {
147 double utilization;
148
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5947 times.
 5947 switch (allocator_) {
149 ✗ case kMallocHeap:
150 ✗ utilization = heap_->utilization();
151 ✗ LogCvmfs(kLogKvStore, kLogDebug, "compact requested (%f)", utilization);
152 ✗ if (utilization < kCompactThreshold) {
153 ✗ LogCvmfs(kLogKvStore, kLogDebug, "compacting heap");
154 ✗ heap_->Compact();
155 ✗ if (heap_->utilization() > utilization)
156 ✗ return true;
157 }
158 ✗ return false;
159 5947 default:
160 // the others can't do any compact, so just ignore
161 5947 LogCvmfs(kLogKvStore, kLogDebug, "compact requested");
162 5947 return false;
163 }
164 }
165
166
167 372 int64_t MemoryKvStore::GetSize(const shash::Any &id) {
168
1/2
✓ Branch 1 taken 372 times.
✗ Branch 2 not taken.
 372 MemoryBuffer mem;
169 372 perf::Inc(counters_.n_getsize);
170 372 const bool update_lru = false;
171
3/4
✓ Branch 1 taken 372 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 333 times.
✓ Branch 4 taken 39 times.
 372 if (entries_.Lookup(id, &mem, update_lru)) {
172 // LogCvmfs(kLogKvStore, kLogDebug, "%s is %u B", id.ToString().c_str(),
173 // mem.size);
174 333 return mem.size;
175 } else {
176
1/2
✓ Branch 2 taken 39 times.
✗ Branch 3 not taken.
 39 LogCvmfs(kLogKvStore, kLogDebug, "miss %s on GetSize",
177
1/2
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
 78 id.ToString().c_str());
178 39 return -ENOENT;
179 }
180 }
181
182
183 195 int64_t MemoryKvStore::GetRefcount(const shash::Any &id) {
184
1/2
✓ Branch 1 taken 195 times.
✗ Branch 2 not taken.
 195 MemoryBuffer mem;
185 195 perf::Inc(counters_.n_getrefcount);
186 195 const bool update_lru = false;
187
2/4
✓ Branch 1 taken 195 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 195 times.
✗ Branch 4 not taken.
 195 if (entries_.Lookup(id, &mem, update_lru)) {
188 // LogCvmfs(kLogKvStore, kLogDebug, "%s has refcount %u",
189 // id.ToString().c_str(), mem.refcount);
190 195 return mem.refcount;
191 } else {
192 ✗ LogCvmfs(kLogKvStore, kLogDebug, "miss %s on GetRefcount",
193 ✗ id.ToString().c_str());
194 ✗ return -ENOENT;
195 }
196 }
197
198
199 541214 bool MemoryKvStore::IncRef(const shash::Any &id) {
200 541214 perf::Inc(counters_.n_incref);
201 541214 const WriteLockGuard guard(rwlock_);
202
1/2
✓ Branch 1 taken 541214 times.
✗ Branch 2 not taken.
 541214 MemoryBuffer mem;
203
3/4
✓ Branch 1 taken 541214 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 541175 times.
✓ Branch 4 taken 39 times.
 541214 if (entries_.Lookup(id, &mem)) {
204
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 541175 times.
 541175 assert(mem.refcount < UINT_MAX);
205 541175 ++mem.refcount;
206
1/2
✓ Branch 1 taken 541175 times.
✗ Branch 2 not taken.
 541175 entries_.Insert(id, mem);
207
1/2
✓ Branch 2 taken 541175 times.
✗ Branch 3 not taken.
 541175 LogCvmfs(kLogKvStore, kLogDebug, "increased refcount of %s to %u",
208
1/2
✓ Branch 1 taken 541175 times.
✗ Branch 2 not taken.
 1082350 id.ToString().c_str(), mem.refcount);
209 541175 return true;
210 } else {
211
1/2
✓ Branch 2 taken 39 times.
✗ Branch 3 not taken.
 39 LogCvmfs(kLogKvStore, kLogDebug, "miss %s on IncRef",
212
1/2
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
 78 id.ToString().c_str());
213 39 return false;
214 }
215 541214 }
216
217
218 540920 bool MemoryKvStore::Unref(const shash::Any &id) {
219 540920 perf::Inc(counters_.n_unref);
220 540920 const WriteLockGuard guard(rwlock_);
221
1/2
✓ Branch 1 taken 540920 times.
✗ Branch 2 not taken.
 540920 MemoryBuffer mem;
222
3/4
✓ Branch 1 taken 540920 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 540881 times.
✓ Branch 4 taken 39 times.
 540920 if (entries_.Lookup(id, &mem)) {
223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 540881 times.
 540881 assert(mem.refcount > 0);
224 540881 --mem.refcount;
225
1/2
✓ Branch 1 taken 540881 times.
✗ Branch 2 not taken.
 540881 entries_.Insert(id, mem);
226
1/2
✓ Branch 2 taken 540881 times.
✗ Branch 3 not taken.
 540881 LogCvmfs(kLogKvStore, kLogDebug, "decreased refcount of %s to %u",
227
1/2
✓ Branch 1 taken 540881 times.
✗ Branch 2 not taken.
 1081762 id.ToString().c_str(), mem.refcount);
228 540881 return true;
229 } else {
230
2/4
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 39 times.
✗ Branch 6 not taken.
 39 LogCvmfs(kLogKvStore, kLogDebug, "miss %s on Unref", id.ToString().c_str());
231 39 return false;
232 }
233 540920 }
234
235
236 313 int64_t MemoryKvStore::Read(const shash::Any &id,
237 void *buf,
238 size_t size,
239 size_t offset) {
240
1/2
✓ Branch 1 taken 313 times.
✗ Branch 2 not taken.
 313 MemoryBuffer mem;
241 313 perf::Inc(counters_.n_read);
242 313 const ReadLockGuard guard(rwlock_);
243
2/4
✓ Branch 1 taken 313 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 313 times.
 313 if (!entries_.Lookup(id, &mem)) {
244 ✗ LogCvmfs(kLogKvStore, kLogDebug, "miss %s on Read", id.ToString().c_str());
245 ✗ return -ENOENT;
246 }
247
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 313 times.
 313 if (offset > mem.size) {
248 ✗ LogCvmfs(kLogKvStore, kLogDebug, "out of bounds read (%zu>%zu) on %s",
249 ✗ offset, mem.size, id.ToString().c_str());
250 ✗ return 0;
251 }
252 313 const uint64_t copy_size = std::min(mem.size - offset, size);
253 // LogCvmfs(kLogKvStore, kLogDebug, "copy %u B from offset %u of %s",
254 // copy_size, offset, id.ToString().c_str());
255 313 memcpy(buf, static_cast<char *>(mem.address) + offset, copy_size);
256 313 perf::Xadd(counters_.sz_read, copy_size);
257 313 return copy_size;
258 313 }
259
260
261 5947 int MemoryKvStore::Commit(const MemoryBuffer &buf) {
262 5947 const WriteLockGuard guard(rwlock_);
263
1/2
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
 11894 return DoCommit(buf);
264 5947 }
265
266
267 5947 int MemoryKvStore::DoCommit(const MemoryBuffer &buf) {
268 // we need to be careful about refcounts. If another thread wants to read
269 // a cache entry while it's being written (OpenFromTxn put partial data in
270 // the kvstore, will be committed again later) the refcount in the kvstore
271 // will differ from the refcount in the cache transaction. To avoid leaks,
272 // either the caller needs to fetch the cache entry before every write to
273 // find the current refcount, or the kvstore can ignore the passed-in
274 // refcount if the entry already exists. This implementation does the latter,
275 // and as a result it's not possible to directly modify the refcount
276 // without a race condition. This is a hint that callers should use the
277 // refcount like a lock and not directly modify the numeric value.
278
279
1/2
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
 5947 CompactMemory();
280
281
1/2
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
 5947 MemoryBuffer mem;
282 5947 perf::Inc(counters_.n_commit);
283
2/4
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 5947 times.
✗ Branch 6 not taken.
 5947 LogCvmfs(kLogKvStore, kLogDebug, "commit %s", buf.id.ToString().c_str());
284
3/4
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 137 times.
✓ Branch 4 taken 5810 times.
 5947 if (entries_.Lookup(buf.id, &mem)) {
285
1/2
✓ Branch 1 taken 137 times.
✗ Branch 2 not taken.
 137 LogCvmfs(kLogKvStore, kLogDebug, "commit overwrites existing entry");
286 137 const size_t old_size = mem.size;
287
1/2
✓ Branch 1 taken 137 times.
✗ Branch 2 not taken.
 137 DoFree(&mem);
288 137 used_bytes_ -= old_size;
289 137 counters_.sz_size->Set(used_bytes_);
290 137 --entry_count_;
291 } else {
292 // since this is a new entry, the caller can choose the starting
293 // refcount (starting at 1 for pinning, for example)
294 5810 mem.refcount = buf.refcount;
295 }
296 5947 mem.object_flags = buf.object_flags;
297 5947 mem.id = buf.id;
298 5947 mem.size = buf.size;
299
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5947 times.
 5947 if (entry_count_ == max_entries_) {
300 ✗ LogCvmfs(kLogKvStore, kLogDebug, "too many entries in kvstore");
301 ✗ return -ENFILE;
302 }
303
2/4
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 5947 times.
 5947 if (DoMalloc(&mem) < 0) {
304 ✗ LogCvmfs(kLogKvStore, kLogDebug, "failed to allocate %s",
305 ✗ buf.id.ToString().c_str());
306 ✗ return -EIO;
307 }
308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5947 times.
 5947 assert(SSIZE_MAX - mem.size > used_bytes_);
309 5947 memcpy(mem.address, buf.address, mem.size);
310
1/2
✓ Branch 1 taken 5947 times.
✗ Branch 2 not taken.
 5947 entries_.Insert(buf.id, mem);
311 5947 ++entry_count_;
312 5947 used_bytes_ += mem.size;
313 5947 counters_.sz_size->Set(used_bytes_);
314 5947 perf::Xadd(counters_.sz_committed, mem.size);
315 5947 return 0;
316 }
317
318
319 234 bool MemoryKvStore::Delete(const shash::Any &id) {
320 234 perf::Inc(counters_.n_delete);
321 234 const WriteLockGuard guard(rwlock_);
322
1/2
✓ Branch 1 taken 234 times.
✗ Branch 2 not taken.
 468 return DoDelete(id);
323 234 }
324
325
326 234 bool MemoryKvStore::DoDelete(const shash::Any &id) {
327
1/2
✓ Branch 1 taken 234 times.
✗ Branch 2 not taken.
 234 MemoryBuffer buf;
328
3/4
✓ Branch 1 taken 234 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 78 times.
✓ Branch 4 taken 156 times.
 234 if (!entries_.Lookup(id, &buf)) {
329
1/2
✓ Branch 2 taken 78 times.
✗ Branch 3 not taken.
 78 LogCvmfs(kLogKvStore, kLogDebug, "miss %s on Delete",
330
1/2
✓ Branch 1 taken 78 times.
✗ Branch 2 not taken.
 156 id.ToString().c_str());
331 78 return false;
332 }
333
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 156 times.
 156 if (buf.refcount > 0) {
334 ✗ LogCvmfs(kLogKvStore, kLogDebug, "can't delete %s, nonzero refcount",
335 ✗ id.ToString().c_str());
336 ✗ return false;
337 }
338
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 156 times.
 156 assert(entry_count_ > 0);
339 156 --entry_count_;
340 156 used_bytes_ -= buf.size;
341 156 counters_.sz_size->Set(used_bytes_);
342 156 perf::Xadd(counters_.sz_deleted, buf.size);
343
1/2
✓ Branch 1 taken 156 times.
✗ Branch 2 not taken.
 156 DoFree(&buf);
344
1/2
✓ Branch 1 taken 156 times.
✗ Branch 2 not taken.
 156 entries_.Forget(id);
345
2/4
✓ Branch 1 taken 156 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 156 times.
✗ Branch 6 not taken.
 156 LogCvmfs(kLogKvStore, kLogDebug, "deleted %s", id.ToString().c_str());
346 156 return true;
347 }
348
349
350 773 bool MemoryKvStore::ShrinkTo(size_t size) {
351 773 perf::Inc(counters_.n_shrinkto);
352 773 const WriteLockGuard guard(rwlock_);
353
1/2
✓ Branch 1 taken 773 times.
✗ Branch 2 not taken.
 773 shash::Any key;
354
1/2
✓ Branch 1 taken 773 times.
✗ Branch 2 not taken.
 773 MemoryBuffer buf;
355
356
2/2
✓ Branch 0 taken 323 times.
✓ Branch 1 taken 450 times.
 773 if (used_bytes_ <= size) {
357
1/2
✓ Branch 1 taken 323 times.
✗ Branch 2 not taken.
 323 LogCvmfs(kLogKvStore, kLogDebug, "no need to shrink");
358 323 return true;
359 }
360
361
1/2
✓ Branch 1 taken 450 times.
✗ Branch 2 not taken.
 450 LogCvmfs(kLogKvStore, kLogDebug, "shrinking to %zu B", size);
362
1/2
✓ Branch 1 taken 450 times.
✗ Branch 2 not taken.
 450 entries_.FilterBegin();
363
3/4
✓ Branch 1 taken 5006 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4771 times.
✓ Branch 4 taken 235 times.
 5006 while (entries_.FilterNext()) {
364
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 4556 times.
 4771 if (used_bytes_ <= size)
365 215 break;
366
1/2
✓ Branch 1 taken 4556 times.
✗ Branch 2 not taken.
 4556 entries_.FilterGet(&key, &buf);
367
2/2
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 4106 times.
 4556 if (buf.refcount > 0) {
368
1/2
✓ Branch 2 taken 450 times.
✗ Branch 3 not taken.
 450 LogCvmfs(kLogKvStore, kLogDebug, "skip %s, nonzero refcount",
369
1/2
✓ Branch 1 taken 450 times.
✗ Branch 2 not taken.
 900 key.ToString().c_str());
370 450 continue;
371 }
372
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4106 times.
 4106 assert(entry_count_ > 0);
373 4106 --entry_count_;
374
1/2
✓ Branch 1 taken 4106 times.
✗ Branch 2 not taken.
 4106 entries_.FilterDelete();
375 4106 used_bytes_ -= buf.size;
376 4106 perf::Xadd(counters_.sz_shrunk, buf.size);
377 4106 counters_.sz_size->Set(used_bytes_);
378
1/2
✓ Branch 1 taken 4106 times.
✗ Branch 2 not taken.
 4106 DoFree(&buf);
379
2/4
✓ Branch 1 taken 4106 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 4106 times.
✗ Branch 6 not taken.
 4106 LogCvmfs(kLogKvStore, kLogDebug, "delete %s", key.ToString().c_str());
380 }
381
1/2
✓ Branch 1 taken 450 times.
✗ Branch 2 not taken.
 450 entries_.FilterEnd();
382
1/2
✓ Branch 1 taken 450 times.
✗ Branch 2 not taken.
 450 LogCvmfs(kLogKvStore, kLogDebug, "shrunk to %zu B", used_bytes_);
383 450 return used_bytes_ <= size;
384 773 }
385