GCC Code Coverage Report

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