mirror of https://github.com/bitcoin/bitcoin
Merge bitcoin/bitcoin#27254: refactor: Extract util/fs from util/system
pull/26832/head00e9b97f37refactor: Move fs.* to util/fs.* (TheCharlatan)106b46d9d2Add missing fs.h includes (TheCharlatan)b202b3dd63Add missing cstddef include in assumptions.h (TheCharlatan)18fb36367arefactor: Extract util/fs_helpers from util/system (Ben Woosley) Pull request description: This pull request is part of the `libbitcoinkernel` project https://github.com/bitcoin/bitcoin/issues/24303 https://github.com/bitcoin/bitcoin/projects/18 and more specifically its "Step 2: Decouple most non-consensus code from libbitcoinkernel". This commit was originally authored by empact and is taken from its parent PR #25152. #### Context There is an ongoing effort to decouple the `ArgsManager` used for command line parsing user-provided arguments from the libbitcoinkernel library (https://github.com/bitcoin/bitcoin/pull/25290, https://github.com/bitcoin/bitcoin/pull/25487, https://github.com/bitcoin/bitcoin/pull/25527, https://github.com/bitcoin/bitcoin/pull/25862, https://github.com/bitcoin/bitcoin/pull/26177, and https://github.com/bitcoin/bitcoin/pull/27125). The `ArgsManager` is defined in `system.h`. A similar pull request extracting functionality from `system.h` has been merged in https://github.com/bitcoin/bitcoin/pull/27238. #### Changes Next to providing better code organization, this PR removes some reliance of the tree of libbitcoinkernel header includes on `system.h` (and thus the `ArgsManager` definition) by moving filesystem related functions out of the `system.*` files. There is already a pair of `fs.h` / `fs.cpp` in the top-level `src/` directory. They were not combined with the files introduced here, to keep the patch cleaner and more importantly because they are often included without the utility functions. The new files are therefore named `fs_helpers` and the existing `fs` files are moved into the util directory. Further commits splitting more functionality out of `system.h` are still in #25152 and will be submitted in separate PRs once this PR has been processed. ACKs for top commit: hebasto: ACK00e9b97f37Tree-SHA512: 31422f148d14ba3c843b99b1550a6fd77c77f350905ca324f93d4f97b652246bc58fa9696c64d1201979cf88733e40be02d262739bb7d417cf22bf506fdb7666
fanquake
1 year ago
commit
369d4c03b7
@ -0,0 +1,295 @@
|
||||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2009-2023 The Bitcoin Core developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include <util/fs_helpers.h>
|
||||
|
||||
#if defined(HAVE_CONFIG_H)
|
||||
#include <config/bitcoin-config.h>
|
||||
#endif
|
||||
|
||||
#include <logging.h>
|
||||
#include <sync.h>
|
||||
#include <tinyformat.h>
|
||||
#include <util/fs.h>
|
||||
#include <util/getuniquepath.h>
|
||||
|
||||
#include <cerrno>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <system_error>
|
||||
#include <utility>
|
||||
|
||||
#ifndef WIN32
|
||||
// for posix_fallocate, in configure.ac we check if it is present after this
|
||||
#ifdef __linux__
|
||||
|
||||
#ifdef _POSIX_C_SOURCE
|
||||
#undef _POSIX_C_SOURCE
|
||||
#endif
|
||||
|
||||
#define _POSIX_C_SOURCE 200112L
|
||||
|
||||
#endif // __linux__
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <sys/resource.h>
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <io.h> /* For _get_osfhandle, _chsize */
|
||||
#include <shlobj.h> /* For SHGetSpecialFolderPathW */
|
||||
#endif // WIN32
|
||||
|
||||
/** Mutex to protect dir_locks. */
|
||||
static GlobalMutex cs_dir_locks;
|
||||
/** A map that contains all the currently held directory locks. After
|
||||
* successful locking, these will be held here until the global destructor
|
||||
* cleans them up and thus automatically unlocks them, or ReleaseDirectoryLocks
|
||||
* is called.
|
||||
*/
|
||||
static std::map<std::string, std::unique_ptr<fsbridge::FileLock>> dir_locks GUARDED_BY(cs_dir_locks);
|
||||
|
||||
bool LockDirectory(const fs::path& directory, const fs::path& lockfile_name, bool probe_only)
|
||||
{
|
||||
LOCK(cs_dir_locks);
|
||||
fs::path pathLockFile = directory / lockfile_name;
|
||||
|
||||
// If a lock for this directory already exists in the map, don't try to re-lock it
|
||||
if (dir_locks.count(fs::PathToString(pathLockFile))) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Create empty lock file if it doesn't exist.
|
||||
FILE* file = fsbridge::fopen(pathLockFile, "a");
|
||||
if (file) fclose(file);
|
||||
auto lock = std::make_unique<fsbridge::FileLock>(pathLockFile);
|
||||
if (!lock->TryLock()) {
|
||||
return error("Error while attempting to lock directory %s: %s", fs::PathToString(directory), lock->GetReason());
|
||||
}
|
||||
if (!probe_only) {
|
||||
// Lock successful and we're not just probing, put it into the map
|
||||
dir_locks.emplace(fs::PathToString(pathLockFile), std::move(lock));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void UnlockDirectory(const fs::path& directory, const fs::path& lockfile_name)
|
||||
{
|
||||
LOCK(cs_dir_locks);
|
||||
dir_locks.erase(fs::PathToString(directory / lockfile_name));
|
||||
}
|
||||
|
||||
void ReleaseDirectoryLocks()
|
||||
{
|
||||
LOCK(cs_dir_locks);
|
||||
dir_locks.clear();
|
||||
}
|
||||
|
||||
bool DirIsWritable(const fs::path& directory)
|
||||
{
|
||||
fs::path tmpFile = GetUniquePath(directory);
|
||||
|
||||
FILE* file = fsbridge::fopen(tmpFile, "a");
|
||||
if (!file) return false;
|
||||
|
||||
fclose(file);
|
||||
remove(tmpFile);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes)
|
||||
{
|
||||
constexpr uint64_t min_disk_space = 52428800; // 50 MiB
|
||||
|
||||
uint64_t free_bytes_available = fs::space(dir).available;
|
||||
return free_bytes_available >= min_disk_space + additional_bytes;
|
||||
}
|
||||
|
||||
std::streampos GetFileSize(const char* path, std::streamsize max)
|
||||
{
|
||||
std::ifstream file{path, std::ios::binary};
|
||||
file.ignore(max);
|
||||
return file.gcount();
|
||||
}
|
||||
|
||||
bool FileCommit(FILE* file)
|
||||
{
|
||||
if (fflush(file) != 0) { // harmless if redundantly called
|
||||
LogPrintf("%s: fflush failed: %d\n", __func__, errno);
|
||||
return false;
|
||||
}
|
||||
#ifdef WIN32
|
||||
HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
|
||||
if (FlushFileBuffers(hFile) == 0) {
|
||||
LogPrintf("%s: FlushFileBuffers failed: %d\n", __func__, GetLastError());
|
||||
return false;
|
||||
}
|
||||
#elif defined(MAC_OSX) && defined(F_FULLFSYNC)
|
||||
if (fcntl(fileno(file), F_FULLFSYNC, 0) == -1) { // Manpage says "value other than -1" is returned on success
|
||||
LogPrintf("%s: fcntl F_FULLFSYNC failed: %d\n", __func__, errno);
|
||||
return false;
|
||||
}
|
||||
#elif HAVE_FDATASYNC
|
||||
if (fdatasync(fileno(file)) != 0 && errno != EINVAL) { // Ignore EINVAL for filesystems that don't support sync
|
||||
LogPrintf("%s: fdatasync failed: %d\n", __func__, errno);
|
||||
return false;
|
||||
}
|
||||
#else
|
||||
if (fsync(fileno(file)) != 0 && errno != EINVAL) {
|
||||
LogPrintf("%s: fsync failed: %d\n", __func__, errno);
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
void DirectoryCommit(const fs::path& dirname)
|
||||
{
|
||||
#ifndef WIN32
|
||||
FILE* file = fsbridge::fopen(dirname, "r");
|
||||
if (file) {
|
||||
fsync(fileno(file));
|
||||
fclose(file);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
bool TruncateFile(FILE* file, unsigned int length)
|
||||
{
|
||||
#if defined(WIN32)
|
||||
return _chsize(_fileno(file), length) == 0;
|
||||
#else
|
||||
return ftruncate(fileno(file), length) == 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* this function tries to raise the file descriptor limit to the requested number.
|
||||
* It returns the actual file descriptor limit (which may be more or less than nMinFD)
|
||||
*/
|
||||
int RaiseFileDescriptorLimit(int nMinFD)
|
||||
{
|
||||
#if defined(WIN32)
|
||||
return 2048;
|
||||
#else
|
||||
struct rlimit limitFD;
|
||||
if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
|
||||
if (limitFD.rlim_cur < (rlim_t)nMinFD) {
|
||||
limitFD.rlim_cur = nMinFD;
|
||||
if (limitFD.rlim_cur > limitFD.rlim_max)
|
||||
limitFD.rlim_cur = limitFD.rlim_max;
|
||||
setrlimit(RLIMIT_NOFILE, &limitFD);
|
||||
getrlimit(RLIMIT_NOFILE, &limitFD);
|
||||
}
|
||||
return limitFD.rlim_cur;
|
||||
}
|
||||
return nMinFD; // getrlimit failed, assume it's fine
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* this function tries to make a particular range of a file allocated (corresponding to disk space)
|
||||
* it is advisory, and the range specified in the arguments will never contain live data
|
||||
*/
|
||||
void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length)
|
||||
{
|
||||
#if defined(WIN32)
|
||||
// Windows-specific version
|
||||
HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
|
||||
LARGE_INTEGER nFileSize;
|
||||
int64_t nEndPos = (int64_t)offset + length;
|
||||
nFileSize.u.LowPart = nEndPos & 0xFFFFFFFF;
|
||||
nFileSize.u.HighPart = nEndPos >> 32;
|
||||
SetFilePointerEx(hFile, nFileSize, 0, FILE_BEGIN);
|
||||
SetEndOfFile(hFile);
|
||||
#elif defined(MAC_OSX)
|
||||
// OSX specific version
|
||||
// NOTE: Contrary to other OS versions, the OSX version assumes that
|
||||
// NOTE: offset is the size of the file.
|
||||
fstore_t fst;
|
||||
fst.fst_flags = F_ALLOCATECONTIG;
|
||||
fst.fst_posmode = F_PEOFPOSMODE;
|
||||
fst.fst_offset = 0;
|
||||
fst.fst_length = length; // mac os fst_length takes the # of free bytes to allocate, not desired file size
|
||||
fst.fst_bytesalloc = 0;
|
||||
if (fcntl(fileno(file), F_PREALLOCATE, &fst) == -1) {
|
||||
fst.fst_flags = F_ALLOCATEALL;
|
||||
fcntl(fileno(file), F_PREALLOCATE, &fst);
|
||||
}
|
||||
ftruncate(fileno(file), static_cast<off_t>(offset) + length);
|
||||
#else
|
||||
#if defined(HAVE_POSIX_FALLOCATE)
|
||||
// Version using posix_fallocate
|
||||
off_t nEndPos = (off_t)offset + length;
|
||||
if (0 == posix_fallocate(fileno(file), 0, nEndPos)) return;
|
||||
#endif
|
||||
// Fallback version
|
||||
// TODO: just write one byte per block
|
||||
static const char buf[65536] = {};
|
||||
if (fseek(file, offset, SEEK_SET)) {
|
||||
return;
|
||||
}
|
||||
while (length > 0) {
|
||||
unsigned int now = 65536;
|
||||
if (length < now)
|
||||
now = length;
|
||||
fwrite(buf, 1, now, file); // allowed to fail; this function is advisory anyway
|
||||
length -= now;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
fs::path GetSpecialFolderPath(int nFolder, bool fCreate)
|
||||
{
|
||||
WCHAR pszPath[MAX_PATH] = L"";
|
||||
|
||||
if (SHGetSpecialFolderPathW(nullptr, pszPath, nFolder, fCreate)) {
|
||||
return fs::path(pszPath);
|
||||
}
|
||||
|
||||
LogPrintf("SHGetSpecialFolderPathW() failed, could not obtain requested path.\n");
|
||||
return fs::path("");
|
||||
}
|
||||
#endif
|
||||
|
||||
bool RenameOver(fs::path src, fs::path dest)
|
||||
{
|
||||
#ifdef __MINGW64__
|
||||
// This is a workaround for a bug in libstdc++ which
|
||||
// implements std::filesystem::rename with _wrename function.
|
||||
// This bug has been fixed in upstream:
|
||||
// - GCC 10.3: 8dd1c1085587c9f8a21bb5e588dfe1e8cdbba79e
|
||||
// - GCC 11.1: 1dfd95f0a0ca1d9e6cbc00e6cbfd1fa20a98f312
|
||||
// For more details see the commits mentioned above.
|
||||
return MoveFileExW(src.wstring().c_str(), dest.wstring().c_str(),
|
||||
MOVEFILE_REPLACE_EXISTING) != 0;
|
||||
#else
|
||||
std::error_code error;
|
||||
fs::rename(src, dest, error);
|
||||
return !error;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Ignores exceptions thrown by create_directories if the requested directory exists.
|
||||
* Specifically handles case where path p exists, but it wasn't possible for the user to
|
||||
* write to the parent directory.
|
||||
*/
|
||||
bool TryCreateDirectories(const fs::path& p)
|
||||
{
|
||||
try {
|
||||
return fs::create_directories(p);
|
||||
} catch (const fs::filesystem_error&) {
|
||||
if (!fs::exists(p) || !fs::is_directory(p))
|
||||
throw;
|
||||
}
|
||||
|
||||
// create_directories didn't create the directory, it had to have existed already
|
||||
return false;
|
||||
}
|
||||
@ -0,0 +1,63 @@
|
||||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2009-2023 The Bitcoin Core developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#ifndef BITCOIN_UTIL_FS_HELPERS_H
|
||||
#define BITCOIN_UTIL_FS_HELPERS_H
|
||||
|
||||
#include <util/fs.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <iosfwd>
|
||||
#include <limits>
|
||||
|
||||
/**
|
||||
* Ensure file contents are fully committed to disk, using a platform-specific
|
||||
* feature analogous to fsync().
|
||||
*/
|
||||
bool FileCommit(FILE* file);
|
||||
|
||||
/**
|
||||
* Sync directory contents. This is required on some environments to ensure that
|
||||
* newly created files are committed to disk.
|
||||
*/
|
||||
void DirectoryCommit(const fs::path& dirname);
|
||||
|
||||
bool TruncateFile(FILE* file, unsigned int length);
|
||||
int RaiseFileDescriptorLimit(int nMinFD);
|
||||
void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length);
|
||||
|
||||
/**
|
||||
* Rename src to dest.
|
||||
* @return true if the rename was successful.
|
||||
*/
|
||||
[[nodiscard]] bool RenameOver(fs::path src, fs::path dest);
|
||||
|
||||
bool LockDirectory(const fs::path& directory, const fs::path& lockfile_name, bool probe_only = false);
|
||||
void UnlockDirectory(const fs::path& directory, const fs::path& lockfile_name);
|
||||
bool DirIsWritable(const fs::path& directory);
|
||||
bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes = 0);
|
||||
|
||||
/** Get the size of a file by scanning it.
|
||||
*
|
||||
* @param[in] path The file path
|
||||
* @param[in] max Stop seeking beyond this limit
|
||||
* @return The file size or max
|
||||
*/
|
||||
std::streampos GetFileSize(const char* path, std::streamsize max = std::numeric_limits<std::streamsize>::max());
|
||||
|
||||
/** Release all directory locks. This is used for unit testing only, at runtime
|
||||
* the global destructor will take care of the locks.
|
||||
*/
|
||||
void ReleaseDirectoryLocks();
|
||||
|
||||
bool TryCreateDirectories(const fs::path& p);
|
||||
fs::path GetDefaultDataDir();
|
||||
|
||||
#ifdef WIN32
|
||||
fs::path GetSpecialFolderPath(int nFolder, bool fCreate = true);
|
||||
#endif
|
||||
|
||||
#endif // BITCOIN_UTIL_FS_HELPERS_H
|
||||
Loading…
Reference in new issue