Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <bitcoin-build-config.h> // IWYU pragma: keep
7 : :
8 : : #include <util/fs_helpers.h>
9 : : #include <random.h>
10 : : #include <sync.h>
11 : : #include <tinyformat.h>
12 : : #include <util/byte_units.h>
13 : : #include <util/check.h>
14 : : #include <util/fs.h>
15 : : #include <util/log.h>
16 : : #include <util/syserror.h>
17 : :
18 : : #include <cerrno>
19 : : #include <fstream>
20 : : #include <limits>
21 : : #include <map>
22 : : #include <memory>
23 : : #include <optional>
24 : : #include <stdexcept>
25 : : #include <string>
26 : : #include <system_error>
27 : : #include <utility>
28 : :
29 : : #ifndef WIN32
30 : : #include <fcntl.h>
31 : : #include <sys/resource.h>
32 : : #include <sys/types.h>
33 : : #include <unistd.h>
34 : : #else
35 : : #include <io.h>
36 : : #include <shlobj.h>
37 : : #endif // WIN32
38 : :
39 : : #ifdef __APPLE__
40 : : #include <sys/mount.h>
41 : : #include <sys/param.h>
42 : : #endif
43 : :
44 : : /** Mutex to protect dir_locks. */
45 : : static GlobalMutex cs_dir_locks;
46 : : /** A map that contains all the currently held directory locks. After
47 : : * successful locking, these will be held here until the global destructor
48 : : * cleans them up and thus automatically unlocks them, or ReleaseDirectoryLocks
49 : : * is called.
50 : : */
51 : : static std::map<std::string, std::unique_ptr<fsbridge::FileLock>> dir_locks GUARDED_BY(cs_dir_locks);
52 : : namespace util {
53 : 5124 : LockResult LockDirectory(const fs::path& directory, const fs::path& lockfile_name, bool probe_only)
54 : : {
55 : 5124 : LOCK(cs_dir_locks);
56 [ + - + - ]: 10248 : fs::path pathLockFile = directory / lockfile_name;
57 : :
58 : : // If a lock for this directory already exists in the map, don't try to re-lock it
59 [ - + + + ]: 10248 : if (dir_locks.contains(fs::PathToString(pathLockFile))) {
60 : : return LockResult::Success;
61 : : }
62 : :
63 : : // Create empty lock file if it doesn't exist.
64 [ + - + + ]: 5122 : if (auto created{fsbridge::fopen(pathLockFile, "a")}) {
65 [ + - ]: 5120 : std::fclose(created);
66 : : } else {
67 : : return LockResult::ErrorWrite;
68 : : }
69 [ + - ]: 5120 : auto lock = std::make_unique<fsbridge::FileLock>(pathLockFile);
70 [ + - + + ]: 5120 : if (!lock->TryLock()) {
71 [ - + - + : 12 : LogError("Error while attempting to lock directory %s: %s\n", fs::PathToString(directory), lock->GetReason());
+ - ]
72 : 4 : return LockResult::ErrorLock;
73 : : }
74 [ + + ]: 5116 : if (!probe_only) {
75 : : // Lock successful and we're not just probing, put it into the map
76 [ - + + - ]: 7671 : dir_locks.emplace(fs::PathToString(pathLockFile), std::move(lock));
77 : : }
78 : : return LockResult::Success;
79 [ + - ]: 15368 : }
80 : : } // namespace util
81 : 0 : void UnlockDirectory(const fs::path& directory, const fs::path& lockfile_name)
82 : : {
83 : 0 : LOCK(cs_dir_locks);
84 [ # # # # : 0 : dir_locks.erase(fs::PathToString(directory / lockfile_name));
# # # # ]
85 : 0 : }
86 : :
87 : 3 : void ReleaseDirectoryLocks()
88 : : {
89 : 3 : LOCK(cs_dir_locks);
90 [ + - ]: 3 : dir_locks.clear();
91 : 3 : }
92 : :
93 : 12256 : bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes)
94 : : {
95 : 12256 : constexpr uint64_t min_disk_space{50_MiB};
96 : :
97 : 12256 : uint64_t free_bytes_available = fs::space(dir).available;
98 : 12256 : return free_bytes_available >= min_disk_space + additional_bytes;
99 : : }
100 : :
101 : 0 : std::streampos GetFileSize(const char* path, std::streamsize max)
102 : : {
103 : 0 : std::ifstream file{path, std::ios::binary};
104 [ # # ]: 0 : file.ignore(max);
105 : 0 : return file.gcount();
106 : 0 : }
107 : :
108 : 10794 : bool FileCommit(FILE* file)
109 : : {
110 [ - + ]: 10794 : if (fflush(file) != 0) { // harmless if redundantly called
111 [ # # ]: 0 : LogError("fflush failed: %s", SysErrorString(errno));
112 : 0 : return false;
113 : : }
114 : : #ifdef WIN32
115 : : HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
116 : : if (FlushFileBuffers(hFile) == 0) {
117 : : LogError("FlushFileBuffers failed: %s", Win32ErrorString(GetLastError()));
118 : : return false;
119 : : }
120 : : #elif defined(__APPLE__) && defined(F_FULLFSYNC)
121 : : if (fcntl(fileno(file), F_FULLFSYNC, 0) == -1) { // Manpage says "value other than -1" is returned on success
122 : : LogError("fcntl F_FULLFSYNC failed: %s", SysErrorString(errno));
123 : : return false;
124 : : }
125 : : #elif HAVE_FDATASYNC
126 [ - + - - ]: 10794 : if (fdatasync(fileno(file)) != 0 && errno != EINVAL) { // Ignore EINVAL for filesystems that don't support sync
127 [ # # ]: 0 : LogError("fdatasync failed: %s", SysErrorString(errno));
128 : 0 : return false;
129 : : }
130 : : #else
131 : : if (fsync(fileno(file)) != 0 && errno != EINVAL) {
132 : : LogError("fsync failed: %s", SysErrorString(errno));
133 : : return false;
134 : : }
135 : : #endif
136 : : return true;
137 : : }
138 : :
139 : 7899 : void DirectoryCommit(const fs::path& dirname)
140 : : {
141 : : #ifndef WIN32
142 : 7899 : FILE* file = fsbridge::fopen(dirname, "r");
143 [ + - ]: 7899 : if (file) {
144 : 7899 : fsync(fileno(file));
145 : 7899 : fclose(file);
146 : : }
147 : : #endif
148 : 7899 : }
149 : :
150 : 274 : bool TruncateFile(FILE* file, uint64_t length)
151 : : {
152 : : #if defined(WIN32)
153 : : return _chsize_s(_fileno(file), length) == 0;
154 : : #else
155 : 274 : return ftruncate(fileno(file), length) == 0;
156 : : #endif
157 : : }
158 : :
159 : 2087 : int RaiseFileDescriptorLimit(int min_fd)
160 : : {
161 : 2087 : Assert(min_fd >= 0);
162 : : #if defined(WIN32)
163 : : return 2048;
164 : : #else
165 : 2087 : struct rlimit limitFD;
166 [ + - ]: 2087 : if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
167 : : // If the current soft limit is already higher, don't raise it
168 [ + - + - ]: 2087 : if (limitFD.rlim_cur != RLIM_INFINITY && std::cmp_less(limitFD.rlim_cur, min_fd)) {
169 : 2 : const auto current_limit{limitFD.rlim_cur};
170 : 2 : static_assert(std::in_range<rlim_t>(std::numeric_limits<int>::max()));
171 : 2 : limitFD.rlim_cur = static_cast<rlim_t>(min_fd);
172 : : // Don't raise soft limit beyond hard limit
173 [ + - + - ]: 2 : if ((limitFD.rlim_max != RLIM_INFINITY) && (limitFD.rlim_cur > limitFD.rlim_max)) {
174 : 2 : limitFD.rlim_cur = limitFD.rlim_max;
175 : : }
176 [ - + ]: 2 : if (current_limit != limitFD.rlim_cur) {
177 : 0 : setrlimit(RLIMIT_NOFILE, &limitFD);
178 : 0 : getrlimit(RLIMIT_NOFILE, &limitFD);
179 : : }
180 : : }
181 : : // Check the (possibly raised) current soft limit against the special
182 : : // value of RLIM_INFINITY. Some platforms implement this as the maximum
183 : : // uint64, others as int64 (-1). Avoid casting even if the return type
184 : : // is changed to uint64_t. We also cap unlikely but possible values
185 : : // that would overflow int.
186 [ + - ]: 2087 : if (limitFD.rlim_cur == RLIM_INFINITY ||
187 [ + - ]: 2087 : std::cmp_greater_equal(limitFD.rlim_cur, std::numeric_limits<int>::max())) {
188 : : return std::numeric_limits<int>::max();
189 : : }
190 : 2087 : return static_cast<int>(limitFD.rlim_cur);
191 : : }
192 : : return min_fd; // getrlimit failed, assume it's fine
193 : : #endif
194 : : }
195 : :
196 : : /**
197 : : * this function tries to make a particular range of a file allocated (corresponding to disk space)
198 : : * it is advisory, and the range specified in the arguments will never contain live data
199 : : */
200 : 1795 : void AllocateFileRange(FILE* file, uint64_t offset, uint64_t length)
201 : : {
202 : : #if defined(WIN32)
203 : : // Windows-specific version
204 : : HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
205 : : LARGE_INTEGER nFileSize{.QuadPart = int64_t(offset + length)};
206 : : SetFilePointerEx(hFile, nFileSize, 0, FILE_BEGIN);
207 : : SetEndOfFile(hFile);
208 : : #elif defined(__APPLE__)
209 : : // OSX specific version
210 : : // NOTE: Contrary to other OS versions, the OSX version assumes that
211 : : // NOTE: offset is the size of the file.
212 : : fstore_t fst;
213 : : fst.fst_flags = F_ALLOCATECONTIG;
214 : : fst.fst_posmode = F_PEOFPOSMODE;
215 : : fst.fst_offset = 0;
216 : : fst.fst_length = length; // mac os fst_length takes the # of free bytes to allocate, not desired file size
217 : : fst.fst_bytesalloc = 0;
218 : : if (fcntl(fileno(file), F_PREALLOCATE, &fst) == -1) {
219 : : fst.fst_flags = F_ALLOCATEALL;
220 : : fcntl(fileno(file), F_PREALLOCATE, &fst);
221 : : }
222 : : ftruncate(fileno(file), static_cast<off_t>(offset) + length);
223 : : #else
224 : : #if defined(HAVE_POSIX_FALLOCATE)
225 : : // Version using posix_fallocate
226 : 1795 : off_t nEndPos = (off_t)offset + length;
227 [ - + ]: 1795 : if (0 == posix_fallocate(fileno(file), 0, nEndPos)) return;
228 : : #endif
229 : : // Fallback version
230 : : // TODO: just write one byte per block
231 : 0 : static const char buf[65536] = {};
232 [ # # ]: 0 : if (FileSeek64(file, offset, SEEK_SET)) {
233 : : return;
234 : : }
235 [ # # ]: 0 : while (length > 0) {
236 : 0 : unsigned int now = 65536;
237 [ # # ]: 0 : if (length < now)
238 : 0 : now = length;
239 : 0 : fwrite(buf, 1, now, file); // allowed to fail; this function is advisory anyway
240 : 0 : length -= now;
241 : : }
242 : : #endif
243 : : }
244 : :
245 : : #ifdef WIN32
246 : : fs::path GetSpecialFolderPath(int nFolder, bool fCreate)
247 : : {
248 : : WCHAR pszPath[MAX_PATH] = L"";
249 : :
250 : : if (SHGetSpecialFolderPathW(nullptr, pszPath, nFolder, fCreate)) {
251 : : return fs::path(pszPath);
252 : : }
253 : :
254 : : LogError("SHGetSpecialFolderPathW() failed, could not obtain requested path.");
255 : : return fs::path("");
256 : : }
257 : : #endif
258 : :
259 : 5582 : bool RenameOver(fs::path src, fs::path dest)
260 : : {
261 : 5582 : std::error_code error;
262 : 5582 : fs::rename(src, dest, error);
263 : 5582 : return !error;
264 : : }
265 : :
266 : : /**
267 : : * Ignores exceptions thrown by create_directories if the requested directory exists.
268 : : * Specifically handles case where path p exists, but it wasn't possible for the user to
269 : : * write to the parent directory.
270 : : */
271 : 4909 : bool TryCreateDirectories(const fs::path& p)
272 : : {
273 : 4909 : try {
274 [ + + ]: 4909 : return fs::create_directories(p);
275 [ - + ]: 2 : } catch (const fs::filesystem_error&) {
276 [ + - - + : 2 : if (!fs::exists(p) || !fs::is_directory(p))
- - - - ]
277 : 2 : throw;
278 : 2 : }
279 : :
280 : : // create_directories didn't create the directory, it had to have existed already
281 : 0 : return false;
282 : : }
283 : :
284 : 1257 : std::string PermsToSymbolicString(fs::perms p)
285 : : {
286 [ + - ]: 1257 : std::string perm_str(9, '-');
287 : :
288 : 11313 : auto set_perm = [&](size_t pos, fs::perms required_perm, char letter) {
289 : 11313 : if ((p & required_perm) != fs::perms::none) {
290 : 2517 : perm_str[pos] = letter;
291 : : }
292 : 1257 : };
293 : :
294 [ + - ]: 1257 : set_perm(0, fs::perms::owner_read, 'r');
295 [ + - ]: 1257 : set_perm(1, fs::perms::owner_write, 'w');
296 [ - + ]: 1257 : set_perm(2, fs::perms::owner_exec, 'x');
297 [ + + ]: 1257 : set_perm(3, fs::perms::group_read, 'r');
298 [ - + ]: 1257 : set_perm(4, fs::perms::group_write, 'w');
299 [ - + ]: 1257 : set_perm(5, fs::perms::group_exec, 'x');
300 [ + + ]: 1257 : set_perm(6, fs::perms::others_read, 'r');
301 [ - + ]: 1257 : set_perm(7, fs::perms::others_write, 'w');
302 [ - + ]: 1257 : set_perm(8, fs::perms::others_exec, 'x');
303 : :
304 : 1257 : return perm_str;
305 : : }
306 : :
307 : 3 : std::optional<fs::perms> InterpretPermString(const std::string& s)
308 : : {
309 [ + + ]: 3 : if (s == "owner") {
310 : 1 : return fs::perms::owner_read | fs::perms::owner_write;
311 [ + + ]: 2 : } else if (s == "group") {
312 : 1 : return fs::perms::owner_read | fs::perms::owner_write |
313 : 1 : fs::perms::group_read;
314 [ + - ]: 1 : } else if (s == "all") {
315 : 1 : return fs::perms::owner_read | fs::perms::owner_write |
316 : 1 : fs::perms::group_read |
317 : 1 : fs::perms::others_read;
318 : : } else {
319 : 0 : return std::nullopt;
320 : : }
321 : : }
322 : :
323 : 1254 : bool IsDirWritable(const fs::path& dir_path)
324 : : {
325 : : // Attempt to create a tmp file in the directory
326 [ - + - - : 1254 : if (!fs::is_directory(dir_path)) throw std::runtime_error(strprintf("Path %s is not a directory", fs::PathToString(dir_path)));
- - - - ]
327 : 1254 : FastRandomContext rng;
328 [ + - + - : 6270 : const auto tmp = dir_path / fs::PathFromString(strprintf(".tmp_%d", rng.rand64()));
+ - ]
329 : :
330 [ + - + - ]: 1254 : if (const auto created{fsbridge::fopen(tmp, "wx")}) {
331 [ + - ]: 1254 : std::fclose(created);
332 : 1254 : std::error_code ec;
333 : 1254 : fs::remove(tmp, ec); // clean up, ignore errors
334 : 1254 : return true;
335 : : }
336 : : return false;
337 : 1254 : }
338 : :
339 : : #ifdef __APPLE__
340 : : FSType GetFilesystemType(const fs::path& path)
341 : : {
342 : : if (struct statfs fs_info; statfs(path.c_str(), &fs_info)) {
343 : : return FSType::ERROR;
344 : : } else if (std::string_view{fs_info.f_fstypename} == "exfat") {
345 : : return FSType::EXFAT;
346 : : }
347 : : return FSType::OTHER;
348 : : }
349 : : #endif
|
