GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/cache_ram.cc
Date: 2026-01-25 02:35:50
Exec Total Coverage
Lines: 191 229 83.4%
Branches: 100 208 48.1%
Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 */
4
5 #include "cache_ram.h"
6
7 #include <errno.h>
8
9 #include <algorithm>
10 #include <cassert>
11 #include <cstring>
12 #include <new>
13
14 #include "kvstore.h"
15 #include "util/concurrency.h"
16 #include "util/logging.h"
17 #include "util/posix.h"
18 #include "util/string.h"
19
20 using namespace std; // NOLINT
21
22 const shash::Any RamCacheManager::kInvalidHandle;
23
24 ✗ string RamCacheManager::Describe() {
25 return "Internal in-memory cache manager (size "
26 ✗ + StringifyInt(max_size_ / (1024 * 1024)) + "MB)\n";
27 }
28
29
30 1074 RamCacheManager::RamCacheManager(uint64_t max_size,
31 unsigned max_entries,
32 MemoryKvStore::MemoryAllocator alloc,
33 1074 perf::StatisticsTemplate statistics)
34 1074 : max_size_(max_size)
35
1/2
✓ Branch 1 taken 1074 times.
✗ Branch 2 not taken.
 1074 , fd_table_(max_entries, ReadOnlyHandle())
36 // TODO(jblomer): the number of slots in the kv-stores should _not_ be the
37 // number of open files.
38
1/2
✓ Branch 1 taken 1074 times.
✗ Branch 2 not taken.
 1074 , regular_entries_(max_entries,
39 alloc,
40 max_size,
41
2/4
✓ Branch 2 taken 1074 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 1074 times.
✗ Branch 6 not taken.
 2148 perf::StatisticsTemplate("kv.regular", statistics))
42
1/2
✓ Branch 1 taken 1074 times.
✗ Branch 2 not taken.
 1074 , volatile_entries_(max_entries,
43 alloc,
44 max_size,
45
2/4
✓ Branch 2 taken 1074 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 1074 times.
✗ Branch 6 not taken.
 2148 perf::StatisticsTemplate("kv.volatile", statistics))
46
2/4
✓ Branch 3 taken 1074 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 1074 times.
✗ Branch 7 not taken.
 2148 , counters_(statistics) {
47 1074 const int retval = pthread_rwlock_init(&rwlock_, NULL);
48
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1074 times.
 1074 assert(retval == 0);
49
1/2
✓ Branch 1 taken 1074 times.
✗ Branch 2 not taken.
 1074 LogCvmfs(kLogCache, kLogDebug, "max %lu B, %u entries", max_size,
50 max_entries);
51
1/2
✓ Branch 1 taken 1074 times.
✗ Branch 2 not taken.
 1074 LogCvmfs(kLogCache, kLogDebug | kLogSyslogWarn,
52 "DEPRECATION WARNING: The RAM cache manager is depcreated and "
53 "will be removed from future releases.");
54 1074 }
55
56
57 3456 RamCacheManager::~RamCacheManager() { pthread_rwlock_destroy(&rwlock_); }
58
59
60 386596 int RamCacheManager::AddFd(const ReadOnlyHandle &handle) {
61 386596 const int result = fd_table_.OpenFd(handle);
62
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 386561 times.
 386596 if (result == -ENFILE) {
63 35 LogCvmfs(kLogCache, kLogDebug, "too many open files");
64 35 perf::Inc(counters_.n_enfile);
65 }
66 386596 return result;
67 }
68
69
70 270 bool RamCacheManager::AcquireQuotaManager(QuotaManager *quota_mgr) {
71
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 270 times.
 270 assert(quota_mgr != NULL);
72 270 quota_mgr_ = quota_mgr;
73 270 LogCvmfs(kLogCache, kLogDebug, "set quota manager");
74 270 return true;
75 }
76
77
78 1013 int RamCacheManager::Open(const LabeledObject &object) {
79 1013 const WriteLockGuard guard(rwlock_);
80
1/2
✓ Branch 1 taken 1013 times.
✗ Branch 2 not taken.
 2026 return DoOpen(object.id);
81 1013 }
82
83
84 1341 int RamCacheManager::DoOpen(const shash::Any &id) {
85 bool ok;
86 bool is_volatile;
87
1/2
✓ Branch 1 taken 1341 times.
✗ Branch 2 not taken.
 1341 const MemoryBuffer buf;
88
89
3/4
✓ Branch 1 taken 1341 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 625 times.
✓ Branch 4 taken 716 times.
 1341 if (regular_entries_.Contains(id)) {
90 625 is_volatile = false;
91
3/4
✓ Branch 1 taken 716 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 96 times.
✓ Branch 4 taken 620 times.
 716 } else if (volatile_entries_.Contains(id)) {
92 96 is_volatile = true;
93 } else {
94
2/4
✓ Branch 1 taken 620 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 620 times.
✗ Branch 6 not taken.
 620 LogCvmfs(kLogCache, kLogDebug, "miss for %s", id.ToString().c_str());
95 620 perf::Inc(counters_.n_openmiss);
96 620 return -ENOENT;
97 }
98 721 const ReadOnlyHandle generic_handle(id, is_volatile);
99
1/2
✓ Branch 1 taken 721 times.
✗ Branch 2 not taken.
 721 const int fd = AddFd(generic_handle);
100
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 721 times.
 721 if (fd < 0) {
101 ✗ LogCvmfs(kLogCache, kLogDebug, "error while opening %s: %s",
102 ✗ id.ToString().c_str(), strerror(-fd));
103 ✗ return fd;
104 }
105
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 625 times.
 721 if (is_volatile) {
106
1/2
✓ Branch 2 taken 96 times.
✗ Branch 3 not taken.
 96 LogCvmfs(kLogCache, kLogDebug, "hit in volatile entries for %s",
107
1/2
✓ Branch 1 taken 96 times.
✗ Branch 2 not taken.
 192 id.ToString().c_str());
108 96 perf::Inc(counters_.n_openvolatile);
109 } else {
110
1/2
✓ Branch 2 taken 625 times.
✗ Branch 3 not taken.
 625 LogCvmfs(kLogCache, kLogDebug, "hit in regular entries for %s",
111
1/2
✓ Branch 1 taken 625 times.
✗ Branch 2 not taken.
 1250 id.ToString().c_str());
112 625 perf::Inc(counters_.n_openregular);
113 }
114
1/2
✓ Branch 2 taken 721 times.
✗ Branch 3 not taken.
 721 ok = GetStore(generic_handle)->IncRef(id);
115
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 721 times.
 721 assert(ok);
116 721 return fd;
117 }
118
119
120 249 int64_t RamCacheManager::GetSize(int fd) {
121 249 const ReadLockGuard guard(rwlock_);
122
1/2
✓ Branch 1 taken 249 times.
✗ Branch 2 not taken.
 249 const ReadOnlyHandle generic_handle = fd_table_.GetHandle(fd);
123
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 249 times.
 249 if (generic_handle.handle == kInvalidHandle) {
124 ✗ LogCvmfs(kLogCache, kLogDebug, "bad fd %d on GetSize", fd);
125 ✗ return -EBADF;
126 }
127 249 perf::Inc(counters_.n_getsize);
128
1/2
✓ Branch 2 taken 249 times.
✗ Branch 3 not taken.
 249 return GetStore(generic_handle)->GetSize(generic_handle.handle);
129 249 }
130
131
132 386351 int RamCacheManager::Close(int fd) {
133 bool rc;
134
135 386351 const WriteLockGuard guard(rwlock_);
136
1/2
✓ Branch 1 taken 386351 times.
✗ Branch 2 not taken.
 386351 const ReadOnlyHandle generic_handle = fd_table_.GetHandle(fd);
137
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 386351 times.
 386351 if (generic_handle.handle == kInvalidHandle) {
138 ✗ LogCvmfs(kLogCache, kLogDebug, "bad fd %d on Close", fd);
139 ✗ return -EBADF;
140 }
141
1/2
✓ Branch 2 taken 386351 times.
✗ Branch 3 not taken.
 386351 rc = GetStore(generic_handle)->Unref(generic_handle.handle);
142
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 386351 times.
 386351 assert(rc);
143
144
1/2
✓ Branch 1 taken 386351 times.
✗ Branch 2 not taken.
 386351 const int rc_int = fd_table_.CloseFd(fd);
145
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 386351 times.
 386351 assert(rc_int == 0);
146
1/2
✓ Branch 1 taken 386351 times.
✗ Branch 2 not taken.
 386351 LogCvmfs(kLogCache, kLogDebug, "closed fd %d", fd);
147 386351 perf::Inc(counters_.n_close);
148 386351 return 0;
149 386351 }
150
151
152 179 int64_t RamCacheManager::Pread(int fd,
153 void *buf,
154 uint64_t size,
155 uint64_t offset) {
156 179 const ReadLockGuard guard(rwlock_);
157
1/2
✓ Branch 1 taken 179 times.
✗ Branch 2 not taken.
 179 const ReadOnlyHandle generic_handle = fd_table_.GetHandle(fd);
158
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 179 times.
 179 if (generic_handle.handle == kInvalidHandle) {
159 ✗ LogCvmfs(kLogCache, kLogDebug, "bad fd %d on Pread", fd);
160 ✗ return -EBADF;
161 }
162 179 perf::Inc(counters_.n_pread);
163 return GetStore(generic_handle)
164
1/2
✓ Branch 2 taken 179 times.
✗ Branch 3 not taken.
 179 ->Read(generic_handle.handle, buf, size, offset);
165 179 }
166
167
168 385910 int RamCacheManager::Dup(int fd) {
169 bool ok;
170 int rc;
171 385910 const WriteLockGuard guard(rwlock_);
172
1/2
✓ Branch 1 taken 385910 times.
✗ Branch 2 not taken.
 385910 const ReadOnlyHandle generic_handle = fd_table_.GetHandle(fd);
173
2/2
✓ Branch 1 taken 35 times.
✓ Branch 2 taken 385875 times.
 385910 if (generic_handle.handle == kInvalidHandle) {
174
1/2
✓ Branch 1 taken 35 times.
✗ Branch 2 not taken.
 35 LogCvmfs(kLogCache, kLogDebug, "bad fd %d on Dup", fd);
175 35 return -EBADF;
176 }
177
1/2
✓ Branch 1 taken 385875 times.
✗ Branch 2 not taken.
 385875 rc = AddFd(generic_handle);
178
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 385840 times.
 385875 if (rc < 0)
179 35 return rc;
180
1/2
✓ Branch 2 taken 385840 times.
✗ Branch 3 not taken.
 385840 ok = GetStore(generic_handle)->IncRef(generic_handle.handle);
181
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 385840 times.
 385840 assert(ok);
182
1/2
✓ Branch 1 taken 385840 times.
✗ Branch 2 not taken.
 385840 LogCvmfs(kLogCache, kLogDebug, "dup fd %d", fd);
183 385840 perf::Inc(counters_.n_dup);
184 385840 return rc;
185 385910 }
186
187
188 /**
189 * For a RAM cache, read-ahead is a no-op.
190 */
191 ✗ int RamCacheManager::Readahead(int fd) {
192 ✗ const ReadLockGuard guard(rwlock_);
193 ✗ const ReadOnlyHandle generic_handle = fd_table_.GetHandle(fd);
194 ✗ if (generic_handle.handle == kInvalidHandle) {
195 ✗ LogCvmfs(kLogCache, kLogDebug, "bad fd %d on Readahead", fd);
196 ✗ return -EBADF;
197 }
198 ✗ LogCvmfs(kLogCache, kLogDebug, "readahead (no-op) on %d", fd);
199 ✗ perf::Inc(counters_.n_readahead);
200 ✗ return 0;
201 }
202
203
204 1386 int RamCacheManager::StartTxn(const shash::Any &id, uint64_t size, void *txn) {
205
1/2
✓ Branch 2 taken 1386 times.
✗ Branch 3 not taken.
 1386 LogCvmfs(kLogCache, kLogDebug, "new transaction with id %s",
206 2772 id.ToString().c_str());
207 1386 Transaction *transaction = new (txn) Transaction();
208 1386 transaction->buffer.id = id;
209 1386 transaction->pos = 0;
210 1386 transaction->expected_size = size;
211
1/2
✓ Branch 0 taken 1386 times.
✗ Branch 1 not taken.
 1386 transaction->buffer.size = (size == kSizeUnknown) ? kPageSize : size;
212 1386 transaction->buffer.address = malloc(transaction->buffer.size);
213
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1386 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1386 if (!transaction->buffer.address && size > 0) {
214 ✗ LogCvmfs(kLogCache, kLogDebug, "failed to allocate %lu B for %s", size,
215 ✗ id.ToString().c_str());
216 ✗ return -errno;
217 }
218 1386 perf::Inc(counters_.n_starttxn);
219 1386 return 0;
220 }
221
222
223 358 void RamCacheManager::CtrlTxn(const Label &label, const int /* flags */,
224 void *txn) {
225 358 Transaction *transaction = reinterpret_cast<Transaction *>(txn);
226 358 transaction->description = label.GetDescription();
227 358 transaction->buffer.object_flags = label.flags;
228
1/2
✓ Branch 2 taken 358 times.
✗ Branch 3 not taken.
 358 LogCvmfs(kLogCache, kLogDebug, "modified transaction %s",
229 716 transaction->buffer.id.ToString().c_str());
230 358 }
231
232
233 1408 int64_t RamCacheManager::Write(const void *buf, uint64_t size, void *txn) {
234 1408 Transaction *transaction = reinterpret_cast<Transaction *>(txn);
235
236
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1408 times.
 1408 assert(transaction->pos <= transaction->buffer.size);
237
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 1373 times.
 1408 if (transaction->pos + size > transaction->buffer.size) {
238
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
 35 if (transaction->expected_size == kSizeUnknown) {
239 ✗ perf::Inc(counters_.n_realloc);
240 ✗ const size_t new_size = max(2 * transaction->buffer.size,
241 ✗ static_cast<size_t>(size + transaction->pos));
242 ✗ LogCvmfs(kLogCache, kLogDebug, "reallocate transaction for %s to %lu B",
243 ✗ transaction->buffer.id.ToString().c_str(),
244 transaction->buffer.size);
245 ✗ void *new_ptr = realloc(transaction->buffer.address, new_size);
246 ✗ if (!new_ptr) {
247 ✗ LogCvmfs(kLogCache, kLogDebug, "failed to allocate %lu B for %s",
248 ✗ new_size, transaction->buffer.id.ToString().c_str());
249 ✗ return -EIO;
250 }
251 ✗ transaction->buffer.address = new_ptr;
252 ✗ transaction->buffer.size = new_size;
253 } else {
254 35 LogCvmfs(kLogCache, kLogDebug,
255 "attempted to write more than requested (%lu>%zu)", size,
256 transaction->buffer.size);
257 35 return -EFBIG;
258 }
259 }
260
261
2/4
✓ Branch 0 taken 1373 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1373 times.
✗ Branch 3 not taken.
 1373 if (transaction->buffer.address && buf) {
262 // LogCvmfs(kLogCache, kLogDebug, "copy %u bytes of transaction %s",
263 // size, transaction->id.ToString().c_str());
264 1373 memcpy(static_cast<char *>(transaction->buffer.address) + transaction->pos,
265 buf, size);
266 }
267 1373 transaction->pos += size;
268 1373 perf::Inc(counters_.n_write);
269 1373 return size;
270 }
271
272
273 83 int RamCacheManager::Reset(void *txn) {
274 83 Transaction *transaction = reinterpret_cast<Transaction *>(txn);
275 83 transaction->pos = 0;
276
1/2
✓ Branch 2 taken 83 times.
✗ Branch 3 not taken.
 83 LogCvmfs(kLogCache, kLogDebug, "reset transaction %s",
277 166 transaction->buffer.id.ToString().c_str());
278 83 perf::Inc(counters_.n_reset);
279 83 return 0;
280 }
281
282
283 363 int RamCacheManager::OpenFromTxn(void *txn) {
284 363 const WriteLockGuard guard(rwlock_);
285 363 Transaction *transaction = reinterpret_cast<Transaction *>(txn);
286
1/2
✓ Branch 1 taken 363 times.
✗ Branch 2 not taken.
 363 const int64_t retval = CommitToKvStore(transaction);
287
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 328 times.
 363 if (retval < 0) {
288
1/2
✓ Branch 3 taken 35 times.
✗ Branch 4 not taken.
 70 LogCvmfs(kLogCache, kLogDebug,
289 "error while committing transaction on %s: %s",
290
1/2
✓ Branch 1 taken 35 times.
✗ Branch 2 not taken.
 70 transaction->buffer.id.ToString().c_str(), strerror(-retval));
291 35 return retval;
292 }
293
1/2
✓ Branch 2 taken 328 times.
✗ Branch 3 not taken.
 328 LogCvmfs(kLogCache, kLogDebug, "open pending transaction for %s",
294
1/2
✓ Branch 1 taken 328 times.
✗ Branch 2 not taken.
 656 transaction->buffer.id.ToString().c_str());
295 328 perf::Inc(counters_.n_committxn);
296
1/2
✓ Branch 1 taken 328 times.
✗ Branch 2 not taken.
 328 return DoOpen(transaction->buffer.id);
297 363 }
298
299
300 83 int RamCacheManager::AbortTxn(void *txn) {
301 83 Transaction *transaction = reinterpret_cast<Transaction *>(txn);
302 83 free(transaction->buffer.address);
303
1/2
✓ Branch 2 taken 83 times.
✗ Branch 3 not taken.
 83 LogCvmfs(kLogCache, kLogDebug, "abort transaction %s",
304 166 transaction->buffer.id.ToString().c_str());
305 83 perf::Inc(counters_.n_aborttxn);
306 83 return 0;
307 }
308
309
310 1093 int RamCacheManager::CommitTxn(void *txn) {
311 1093 const WriteLockGuard guard(rwlock_);
312 1093 Transaction *transaction = reinterpret_cast<Transaction *>(txn);
313 1093 perf::Inc(counters_.n_committxn);
314
1/2
✓ Branch 1 taken 1093 times.
✗ Branch 2 not taken.
 1093 const int64_t rc = CommitToKvStore(transaction);
315
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 1058 times.
 1093 if (rc < 0)
316 35 return rc;
317 1058 free(transaction->buffer.address);
318 1058 return rc;
319 1093 }
320
321
322 1456 int64_t RamCacheManager::CommitToKvStore(Transaction *transaction) {
323 MemoryKvStore *store;
324
325
2/2
✓ Branch 0 taken 131 times.
✓ Branch 1 taken 1325 times.
 1456 if (transaction->buffer.object_flags & CacheManager::kLabelVolatile) {
326 131 store = &volatile_entries_;
327 } else {
328 1325 store = &regular_entries_;
329 }
330
2/2
✓ Branch 0 taken 1421 times.
✓ Branch 1 taken 35 times.
 1456 if ((transaction->buffer.object_flags & CacheManager::kLabelPinned)
331
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1421 times.
 1421 || (transaction->buffer.object_flags & CacheManager::kLabelCatalog)) {
332 35 transaction->buffer.refcount = 1;
333 } else {
334 1421 transaction->buffer.refcount = 0;
335 }
336
337 1456 const int64_t regular_size = regular_entries_.GetUsed();
338 1456 const int64_t volatile_size = volatile_entries_.GetUsed();
339 1456 int64_t overrun = regular_size + volatile_size + transaction->buffer.size
340 1456 - max_size_;
341
342
2/2
✓ Branch 0 taken 210 times.
✓ Branch 1 taken 1246 times.
 1456 if (overrun > 0) {
343 // if we're going to clean the cache, try to remove at least 25%
344 210 overrun = max(overrun, (int64_t)max_size_ >> 2);
345 210 perf::Inc(counters_.n_overrun);
346
1/2
✓ Branch 2 taken 210 times.
✗ Branch 3 not taken.
 210 volatile_entries_.ShrinkTo(max((int64_t)0, volatile_size - overrun));
347 }
348 1456 overrun -= volatile_size - volatile_entries_.GetUsed();
349
2/2
✓ Branch 0 taken 175 times.
✓ Branch 1 taken 1281 times.
 1456 if (overrun > 0) {
350
1/2
✓ Branch 2 taken 175 times.
✗ Branch 3 not taken.
 175 regular_entries_.ShrinkTo(max((int64_t)0, regular_size - overrun));
351 }
352 1456 overrun -= regular_size - regular_entries_.GetUsed();
353
2/2
✓ Branch 0 taken 70 times.
✓ Branch 1 taken 1386 times.
 1456 if (overrun > 0) {
354
1/2
✓ Branch 2 taken 70 times.
✗ Branch 3 not taken.
 70 LogCvmfs(kLogCache, kLogDebug,
355 "transaction for %s would overrun the cache limit by %ld",
356
1/2
✓ Branch 1 taken 70 times.
✗ Branch 2 not taken.
 140 transaction->buffer.id.ToString().c_str(), overrun);
357 70 perf::Inc(counters_.n_full);
358 70 return -ENOSPC;
359 }
360
361
1/2
✓ Branch 1 taken 1386 times.
✗ Branch 2 not taken.
 1386 const int rc = store->Commit(transaction->buffer);
362
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1386 times.
 1386 if (rc < 0) {
363 ✗ LogCvmfs(kLogCache, kLogDebug, "commit on %s failed",
364 ✗ transaction->buffer.id.ToString().c_str());
365 ✗ return rc;
366 }
367
1/2
✓ Branch 2 taken 1386 times.
✗ Branch 3 not taken.
 1386 LogCvmfs(kLogCache, kLogDebug, "committed %s to cache",
368
1/2
✓ Branch 1 taken 1386 times.
✗ Branch 2 not taken.
 2772 transaction->buffer.id.ToString().c_str());
369 1386 return 0;
370 }
371