GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/cache.cc
Date: 2025-09-28 02:35:26
Exec Total Coverage
Lines: 95 115 82.6%
Branches: 60 124 48.4%
Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 */
4
5 #include "cache.h"
6
7 #include <alloca.h>
8 #include <errno.h>
9
10 #include <cassert>
11 #include <cstdlib>
12 #include <string>
13
14 #include "compression/compression.h"
15 #include "crypto/hash.h"
16 #include "directory_entry.h"
17 #include "network/download.h"
18 #include "quota.h"
19 #include "util/posix.h"
20 #include "util/smalloc.h"
21
22 using namespace std; // NOLINT
23
24 const uint64_t CacheManager::kSizeUnknown = uint64_t(-1);
25
26
27
1/2
✓ Branch 3 taken 6428 times.
✗ Branch 4 not taken.
 6428 CacheManager::CacheManager() : quota_mgr_(new NoopQuotaManager()) { }
28
29
30
2/2
✓ Branch 0 taken 6201 times.
✓ Branch 1 taken 213 times.
 12828 CacheManager::~CacheManager() { delete quota_mgr_; }
31
32
33 /**
34 * Compresses and checksums the file pointed to by fd. The hash algorithm needs
35 * to be set in id.
36 */
37 176 int CacheManager::ChecksumFd(int fd, shash::Any *id) {
38
1/2
✓ Branch 1 taken 176 times.
✗ Branch 2 not taken.
 176 shash::ContextPtr hash_context(id->algorithm);
39 176 hash_context.buffer = alloca(hash_context.size);
40
1/2
✓ Branch 1 taken 176 times.
✗ Branch 2 not taken.
 176 shash::Init(hash_context);
41
42 z_stream strm;
43
1/2
✓ Branch 1 taken 176 times.
✗ Branch 2 not taken.
 176 zlib::CompressInit(&strm);
44 zlib::StreamStates retval;
45
46 unsigned char buf[4096];
47 176 uint64_t pos = 0;
48 bool eof;
49
50 do {
51
1/2
✓ Branch 1 taken 220 times.
✗ Branch 2 not taken.
 220 const int64_t nbytes = Pread(fd, buf, 4096, pos);
52
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 176 times.
 220 if (nbytes < 0) {
53
1/2
✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
 44 zlib::CompressFini(&strm);
54 44 return nbytes;
55 }
56 176 pos += nbytes;
57 176 eof = nbytes < 4096;
58
1/2
✓ Branch 1 taken 176 times.
✗ Branch 2 not taken.
 176 retval = zlib::CompressZStream2Null(buf, nbytes, eof, &strm, &hash_context);
59
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 176 times.
 176 if (retval == zlib::kStreamDataError) {
60 ✗ zlib::CompressFini(&strm);
61 ✗ return -EINVAL;
62 }
63
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 132 times.
 176 } while (!eof);
64
65
1/2
✓ Branch 1 taken 132 times.
✗ Branch 2 not taken.
 132 zlib::CompressFini(&strm);
66
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 132 times.
 132 if (retval != zlib::kStreamEnd)
67 ✗ return -EINVAL;
68
1/2
✓ Branch 1 taken 132 times.
✗ Branch 2 not taken.
 132 shash::Final(hash_context, id);
69 132 return 0;
70 }
71
72
73 /**
74 * Commits the memory blob buffer to the given chunk id. No checking!
75 * The hash and the memory blob need to match.
76 */
77 6065 bool CacheManager::CommitFromMem(const LabeledObject &object,
78 const unsigned char *buffer,
79 const uint64_t size) {
80 6065 void *txn = alloca(this->SizeOfTxn());
81 6065 const int fd = this->StartTxn(object.id, size, txn);
82
2/2
✓ Branch 0 taken 49 times.
✓ Branch 1 taken 6016 times.
 6065 if (fd < 0)
83 49 return false;
84 6016 this->CtrlTxn(object.label, 0, txn);
85 6016 int64_t retval = this->Write(buffer, size, txn);
86
3/4
✓ Branch 0 taken 5972 times.
✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5972 times.
 6016 if ((retval < 0) || (static_cast<uint64_t>(retval) != size)) {
87 44 this->AbortTxn(txn);
88 44 return false;
89 }
90 5972 retval = this->CommitTxn(txn);
91 5972 return retval == 0;
92 }
93
94
95 180 void CacheManager::FreeState(const int fd_progress, void *data) {
96 180 State *state = reinterpret_cast<State *>(data);
97
2/2
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 98 times.
 180 if (fd_progress >= 0)
98
2/4
✓ Branch 2 taken 82 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 82 times.
✗ Branch 6 not taken.
 82 SendMsg2Socket(fd_progress, "Releasing saved open files table\n");
99
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 180 times.
 180 assert(state->version == kStateVersion);
100
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 180 times.
 180 assert(state->manager_type == id());
101 180 const bool result = DoFreeState(state->concrete_state);
102
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 180 times.
 180 if (!result) {
103 ✗ if (fd_progress >= 0) {
104 ✗ SendMsg2Socket(fd_progress,
105 " *** Releasing open files table failed!\n");
106 }
107 ✗ abort();
108 }
109
1/2
✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.
 180 delete state;
110 180 }
111
112
113 /**
114 * Tries to open a file and copies its contents into a newly malloc'd
115 * memory area. User of the function has to free buffer (if successful).
116 *
117 * @param[in] id content hash of the catalog entry.
118 * @param[out] buffer Contents of the file
119 * @param[out] size Size of the file
120 * \return True if successful, false otherwise.
121 */
122 1054 bool CacheManager::Open2Mem(const LabeledObject &object,
123 unsigned char **buffer,
124 uint64_t *size) {
125 1054 *size = 0;
126 1054 *buffer = NULL;
127
128 1054 const int fd = this->Open(object);
129
2/2
✓ Branch 0 taken 177 times.
✓ Branch 1 taken 877 times.
 1054 if (fd < 0)
130 177 return false;
131
132 877 const int64_t s = this->GetSize(fd);
133
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 828 times.
 828 assert(s >= 0);
134 828 *size = static_cast<uint64_t>(s);
135
136 828 int64_t retval = 0;
137
2/2
✓ Branch 0 taken 736 times.
✓ Branch 1 taken 92 times.
 828 if (*size > 0) {
138 736 *buffer = static_cast<unsigned char *>(smalloc(*size));
139 785 retval = this->Pread(fd, *buffer, *size, 0);
140 } else {
141 92 *buffer = NULL;
142 }
143
144 877 this->Close(fd);
145
3/4
✓ Branch 0 taken 836 times.
✓ Branch 1 taken 41 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 836 times.
 877 if ((retval < 0) || (static_cast<uint64_t>(retval) != *size)) {
146 41 free(*buffer);
147 41 *buffer = NULL;
148 41 *size = 0;
149 41 return false;
150 }
151 836 return true;
152 }
153
154
155 /**
156 * Uses the regular open and, if the file exists in the cache, pins it. There
157 * is a race condition: the file can be removed between the open and the Pin.
158 * This is fixed by the quota manager's unpin method that removes files which
159 * do not exist anymore in the cache. (The quota manager also translates double
160 * pins into a no-op, so that the accounting does not get out of sync.)
161 */
162 1569 int CacheManager::OpenPinned(const LabeledObject &object) {
163 1569 const int fd = this->Open(object);
164
2/2
✓ Branch 0 taken 455 times.
✓ Branch 1 taken 1114 times.
 1569 if (fd >= 0) {
165 455 const int64_t size = this->GetSize(fd);
166
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 455 times.
 455 if (size < 0) {
167 ✗ this->Close(fd);
168 ✗ return size;
169 }
170
1/2
✓ Branch 1 taken 455 times.
✗ Branch 2 not taken.
 455 const bool retval = quota_mgr_->Pin(object.id, static_cast<uint64_t>(size),
171 910 object.label.GetDescription(),
172 455 object.label.IsCatalog());
173
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 411 times.
 455 if (!retval) {
174 44 this->Close(fd);
175 44 return -ENOSPC;
176 }
177 }
178 1525 return fd;
179 }
180
181
182 182 int CacheManager::RestoreState(const int fd_progress, void *data) {
183 182 State *state = reinterpret_cast<State *>(data);
184
2/2
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 98 times.
 182 if (fd_progress >= 0)
185
2/4
✓ Branch 2 taken 84 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 84 times.
✗ Branch 6 not taken.
 84 SendMsg2Socket(fd_progress, "Restoring open files table... ");
186
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 182 times.
 182 if (state->version != kStateVersion) {
187 ✗ if (fd_progress >= 0)
188 ✗ SendMsg2Socket(fd_progress, "unsupported state version!\n");
189 ✗ abort();
190 }
191
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 182 times.
 182 if (state->manager_type != id()) {
192 ✗ if (fd_progress >= 0)
193 ✗ SendMsg2Socket(fd_progress, "switching cache manager unsupported!\n");
194 ✗ abort();
195 }
196 182 const int new_root_fd = DoRestoreState(state->concrete_state);
197
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 182 times.
 182 if (new_root_fd < -1) {
198 ✗ if (fd_progress >= 0)
199 ✗ SendMsg2Socket(fd_progress, "FAILED!\n");
200 ✗ abort();
201 }
202
2/2
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 98 times.
 182 if (fd_progress >= 0)
203
2/4
✓ Branch 2 taken 84 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 84 times.
✗ Branch 6 not taken.
 84 SendMsg2Socket(fd_progress, "done\n");
204 182 return new_root_fd;
205 }
206
207
208 /**
209 * The actual work is done in the concrete cache managers.
210 */
211 182 void *CacheManager::SaveState(const int fd_progress) {
212
2/2
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 98 times.
 182 if (fd_progress >= 0)
213
2/4
✓ Branch 2 taken 84 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 84 times.
✗ Branch 6 not taken.
 84 SendMsg2Socket(fd_progress, "Saving open files table\n");
214 182 State *state = new State();
215 182 state->manager_type = id();
216 182 state->concrete_state = DoSaveState();
217
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 182 times.
 182 if (state->concrete_state == NULL) {
218 ✗ if (fd_progress >= 0) {
219 ✗ SendMsg2Socket(
220 fd_progress,
221 " *** This cache manager does not support saving state!\n");
222 }
223 ✗ abort();
224 }
225 182 return state;
226 }
227