GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/cache_posix.h
Date: 2025-07-06 02:35:01
Exec Total Coverage
Lines: 27 31 87.1%
Branches: 6 12 50.0%
Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 */
4
5 #ifndef CVMFS_CACHE_POSIX_H_
6 #define CVMFS_CACHE_POSIX_H_
7
8 #include <stdint.h>
9 #include <sys/types.h>
10
11 #include <map>
12 #include <string>
13 #include <vector>
14
15 #include "backoff.h"
16 #include "cache.h"
17 #include "catalog_mgr.h"
18 #include "crypto/signature.h"
19 #include "fd_refcount_mgr.h"
20 #include "file_chunk.h"
21 #include "gtest/gtest_prod.h"
22 #include "manifest_fetch.h"
23 #include "shortstring.h"
24 #include "statistics.h"
25 #include "util/atomic.h"
26
27 namespace catalog {
28 class DirectoryEntry;
29 class Catalog;
30 } // namespace catalog
31
32 namespace download {
33 class DownloadManager;
34 }
35
36 /**
37 * Cache manager implementation using a file system (cache directory) as a
38 * backing storage.
39 */
40 class PosixCacheManager : public CacheManager {
41 FRIEND_TEST(T_CacheManager, CommitTxnQuotaNotifications);
42 FRIEND_TEST(T_CacheManager, CommitTxnRenameFail);
43 FRIEND_TEST(T_CacheManager, Open);
44 FRIEND_TEST(T_CacheManager, OpenFromTxn);
45 FRIEND_TEST(T_CacheManager, OpenPinned);
46 FRIEND_TEST(T_CacheManager, Rename);
47 FRIEND_TEST(T_CacheManager, StartTxn);
48 FRIEND_TEST(T_CacheManager, TearDown2ReadOnly);
49
50 public:
51 enum CacheModes {
52 kCacheReadWrite = 0,
53 kCacheReadOnly,
54 };
55
56 enum RenameWorkarounds {
57 kRenameNormal = 0,
58 kRenameLink,
59 kRenameSamedir
60 };
61
62 /**
63 * As of 25M, a file is considered a "big file", which means it is dangerous
64 * to apply asynchronous semantics. On start of a transaction with a big file
65 * the cache is cleaned up opportunistically.
66 */
67 static const uint64_t kBigFile;
68
69 1197 virtual CacheManagerIds id() { return kPosixCacheManager; }
70 virtual std::string Describe();
71
72 static PosixCacheManager *Create(
73 const std::string &cache_path,
74 const bool alien_cache,
75 const RenameWorkarounds rename_workaround = kRenameNormal,
76 const bool do_refcount = true);
77 23252 virtual ~PosixCacheManager() { }
78 virtual bool AcquireQuotaManager(QuotaManager *quota_mgr);
79
80 virtual int Open(const LabeledObject &object);
81 virtual int64_t GetSize(int fd);
82 virtual int Close(int fd);
83 virtual int64_t Pread(int fd, void *buf, uint64_t size, uint64_t offset);
84 virtual int Dup(int fd);
85 virtual int Readahead(int fd);
86
87 4159 virtual uint32_t SizeOfTxn() { return sizeof(Transaction); }
88 virtual int StartTxn(const shash::Any &id, uint64_t size, void *txn);
89 virtual void CtrlTxn(const Label &label, const int flags, void *txn);
90 virtual int64_t Write(const void *buf, uint64_t size, void *txn);
91 virtual int Reset(void *txn);
92 virtual int OpenFromTxn(void *txn);
93 virtual int AbortTxn(void *txn);
94 virtual int CommitTxn(void *txn);
95
96 ✗ virtual void Spawn() { }
97
98 virtual manifest::Breadcrumb LoadBreadcrumb(const std::string &fqrn);
99 virtual bool StoreBreadcrumb(const manifest::Manifest &manifest);
100 bool StoreBreadcrumb(std::string fqrn, manifest::Breadcrumb breadcrumb);
101
102 void TearDown2ReadOnly();
103 ✗ CacheModes cache_mode() { return cache_mode_; }
104 ✗ bool alien_cache() { return alien_cache_; }
105 90 std::string cache_path() { return cache_path_; }
106 1053 bool is_tmpfs() { return is_tmpfs_; }
107 ✗ bool do_refcount() const { return do_refcount_; }
108
109 protected:
110 virtual void *DoSaveState();
111 virtual int DoRestoreState(void *data);
112 virtual bool DoFreeState(void *data);
113
114 private:
115 bool InitCacheDirectory(const string &cache_path);
116
117 struct Transaction {
118 4648 Transaction(const shash::Any &id, const std::string &final_path)
119 4648 : buf_pos(0)
120 4648 , size(0)
121 4648 , expected_size(kSizeUnknown)
122 4648 , fd(-1)
123 4648 , label()
124 4648 , tmp_path()
125
1/2
✓ Branch 1 taken 4648 times.
✗ Branch 2 not taken.
 4648 , final_path(final_path)
126 4648 , id(id) { }
127
128 unsigned char buffer[4096];
129 unsigned buf_pos;
130 uint64_t size;
131 uint64_t expected_size;
132 int fd;
133 Label label;
134 std::string tmp_path;
135 std::string final_path;
136 shash::Any id;
137 };
138
139 5822 PosixCacheManager(const std::string &cache_path, const bool alien_cache,
140 const bool do_refcount = true)
141 11644 : cache_path_(cache_path)
142
1/2
✓ Branch 1 taken 5822 times.
✗ Branch 2 not taken.
 5822 , txn_template_path_(cache_path_ + "/txn/fetchXXXXXX")
143 5822 , alien_cache_(alien_cache)
144 5822 , rename_workaround_(kRenameNormal)
145 5822 , cache_mode_(kCacheReadWrite)
146 5822 , reports_correct_filesize_(true)
147 5822 , is_tmpfs_(false)
148 5822 , do_refcount_(do_refcount)
149
4/8
✓ Branch 2 taken 5822 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 5822 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 5822 times.
✗ Branch 9 not taken.
✓ Branch 11 taken 5822 times.
✗ Branch 12 not taken.
 11644 , fd_mgr_(new FdRefcountMgr()) {
150 5822 atomic_init32(&no_inflight_txns_);
151 5822 }
152
153 std::string GetPathInCache(const shash::Any &id);
154 int Rename(const char *oldpath, const char *newpath);
155 int Flush(Transaction *transaction);
156
157
158 std::string cache_path_;
159 std::string txn_template_path_;
160 bool alien_cache_;
161 RenameWorkarounds rename_workaround_;
162 CacheModes cache_mode_;
163
164 /**
165 * The cache can only degrade to a read-only cache once all writable file
166 * descriptors from transactions are closed. This is indicated by a zero
167 * value in this variable.
168 */
169 atomic_int32 no_inflight_txns_;
170
171 static const char kMagicRefcount = 123;
172 static const char kMagicNoRefcount = '\0';
173 struct SavedState {
174 27 SavedState() : magic_number(kMagicRefcount), version(0), fd_mgr(NULL) { }
175 /// this helps to distinguish from the SavedState of the normal
176 /// posix cache manager
177 char magic_number;
178 unsigned int version;
179 UniquePtr<FdRefcountMgr> fd_mgr;
180 };
181
182 /**
183 * Hack for HDFS which writes file sizes asynchronously.
184 */
185 bool reports_correct_filesize_;
186
187 /**
188 * True if posixcache is on tmpfs (and with this already in RAM)
189 */
190 bool is_tmpfs_;
191 /**
192 * Refcount and return only unique file descriptors
193 */
194 bool do_refcount_;
195 UniquePtr<FdRefcountMgr> fd_mgr_;
196 }; // class PosixCacheManager
197
198 #endif // CVMFS_CACHE_POSIX_H_
199