// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors
#include <dirent.h>
+#ifndef ROCKSDB_NO_DYNAMIC_EXTENSION
+#include <dlfcn.h>
+#endif
#include <errno.h>
#include <fcntl.h>
+
#if defined(OS_LINUX)
#include <linux/fs.h>
#endif
+#if defined(ROCKSDB_IOURING_PRESENT)
+#include <liburing.h>
+#endif
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <sys/statvfs.h>
#include <sys/time.h>
#include <sys/types.h>
+#if defined(ROCKSDB_IOURING_PRESENT)
+#include <sys/uio.h>
+#endif
#include <time.h>
#include <algorithm>
// Get nano time includes
#if defined(OS_LINUX) || defined(OS_FREEBSD)
#elif defined(__MACH__)
+#include <Availability.h>
#include <mach/clock.h>
#include <mach/mach.h>
#else
#include <set>
#include <vector>
+#include "env/composite_env_wrapper.h"
#include "env/io_posix.h"
-#include "env/posix_logger.h"
+#include "logging/logging.h"
+#include "logging/posix_logger.h"
#include "monitoring/iostats_context_imp.h"
#include "monitoring/thread_status_updater.h"
#include "port/port.h"
#include "rocksdb/options.h"
#include "rocksdb/slice.h"
+#include "test_util/sync_point.h"
#include "util/coding.h"
#include "util/compression_context_cache.h"
-#include "util/logging.h"
#include "util/random.h"
#include "util/string_util.h"
-#include "util/sync_point.h"
#include "util/thread_local.h"
#include "util/threadpool_imp.h"
#define EXT4_SUPER_MAGIC 0xEF53
#endif
-namespace rocksdb {
+namespace ROCKSDB_NAMESPACE {
+#if defined(OS_WIN)
+static const std::string kSharedLibExt = ".dll";
+static const char kPathSeparator = ';';
+#else
+static const char kPathSeparator = ':';
+#if defined(OS_MACOSX)
+static const std::string kSharedLibExt = ".dylib";
+#else
+static const std::string kSharedLibExt = ".so";
+#endif
+#endif
namespace {
return new ThreadStatusUpdater();
}
-inline mode_t GetDBFileMode(bool allow_non_owner_access) {
- return allow_non_owner_access ? 0644 : 0600;
-}
-
-// list of pathnames that are locked
-static std::set<std::string> lockedFiles;
-static port::Mutex mutex_lockedFiles;
-
-static int LockOrUnlock(int fd, bool lock) {
- errno = 0;
- struct flock f;
- memset(&f, 0, sizeof(f));
- f.l_type = (lock ? F_WRLCK : F_UNLCK);
- f.l_whence = SEEK_SET;
- f.l_start = 0;
- f.l_len = 0; // Lock/unlock entire file
- int value = fcntl(fd, F_SETLK, &f);
+#ifndef ROCKSDB_NO_DYNAMIC_EXTENSION
+class PosixDynamicLibrary : public DynamicLibrary {
+ public:
+ PosixDynamicLibrary(const std::string& name, void* handle)
+ : name_(name), handle_(handle) {}
+ ~PosixDynamicLibrary() override { dlclose(handle_); }
+
+ Status LoadSymbol(const std::string& sym_name, void** func) override {
+ assert(nullptr != func);
+ dlerror(); // Clear any old error
+ *func = dlsym(handle_, sym_name.c_str());
+ if (*func != nullptr) {
+ return Status::OK();
+ } else {
+ char* err = dlerror();
+ return Status::NotFound("Error finding symbol: " + sym_name, err);
+ }
+ }
- return value;
-}
+ const char* Name() const override { return name_.c_str(); }
-class PosixFileLock : public FileLock {
- public:
- int fd_;
- std::string filename;
+ private:
+ std::string name_;
+ void* handle_;
};
+#endif // !ROCKSDB_NO_DYNAMIC_EXTENSION
-int cloexec_flags(int flags, const EnvOptions* options) {
- // If the system supports opening the file with cloexec enabled,
- // do so, as this avoids a race condition if a db is opened around
- // the same time that a child process is forked
-#ifdef O_CLOEXEC
- if (options == nullptr || options->set_fd_cloexec) {
- flags |= O_CLOEXEC;
- }
-#endif
- return flags;
-}
-
-class PosixEnv : public Env {
+class PosixEnv : public CompositeEnvWrapper {
public:
PosixEnv();
}
}
- Status NewSequentialFile(const std::string& fname,
- std::unique_ptr<SequentialFile>* result,
- const EnvOptions& options) override {
- result->reset();
- int fd = -1;
- int flags = cloexec_flags(O_RDONLY, &options);
- FILE* file = nullptr;
-
- if (options.use_direct_reads && !options.use_mmap_reads) {
-#ifdef ROCKSDB_LITE
- return Status::IOError(fname, "Direct I/O not supported in RocksDB lite");
-#endif // !ROCKSDB_LITE
-#if !defined(OS_MACOSX) && !defined(OS_OPENBSD) && !defined(OS_SOLARIS)
- flags |= O_DIRECT;
-#endif
- }
-
- do {
- IOSTATS_TIMER_GUARD(open_nanos);
- fd = open(fname.c_str(), flags, GetDBFileMode(allow_non_owner_access_));
- } while (fd < 0 && errno == EINTR);
- if (fd < 0) {
- return IOError("While opening a file for sequentially reading", fname,
- errno);
- }
-
- SetFD_CLOEXEC(fd, &options);
-
- if (options.use_direct_reads && !options.use_mmap_reads) {
-#ifdef OS_MACOSX
- if (fcntl(fd, F_NOCACHE, 1) == -1) {
- close(fd);
- return IOError("While fcntl NoCache", fname, errno);
- }
-#endif
- } else {
- do {
- IOSTATS_TIMER_GUARD(open_nanos);
- file = fdopen(fd, "r");
- } while (file == nullptr && errno == EINTR);
- if (file == nullptr) {
- close(fd);
- return IOError("While opening file for sequentially read", fname,
- errno);
- }
- }
- result->reset(new PosixSequentialFile(fname, file, fd, options));
- return Status::OK();
- }
-
- Status NewRandomAccessFile(const std::string& fname,
- std::unique_ptr<RandomAccessFile>* result,
- const EnvOptions& options) override {
- result->reset();
- Status s;
- int fd;
- int flags = cloexec_flags(O_RDONLY, &options);
-
- if (options.use_direct_reads && !options.use_mmap_reads) {
-#ifdef ROCKSDB_LITE
- return Status::IOError(fname, "Direct I/O not supported in RocksDB lite");
-#endif // !ROCKSDB_LITE
-#if !defined(OS_MACOSX) && !defined(OS_OPENBSD) && !defined(OS_SOLARIS)
- flags |= O_DIRECT;
- TEST_SYNC_POINT_CALLBACK("NewRandomAccessFile:O_DIRECT", &flags);
-#endif
- }
-
- do {
- IOSTATS_TIMER_GUARD(open_nanos);
- fd = open(fname.c_str(), flags, GetDBFileMode(allow_non_owner_access_));
- } while (fd < 0 && errno == EINTR);
- if (fd < 0) {
- return IOError("While open a file for random read", fname, errno);
- }
- SetFD_CLOEXEC(fd, &options);
-
- if (options.use_mmap_reads && sizeof(void*) >= 8) {
- // Use of mmap for random reads has been removed because it
- // kills performance when storage is fast.
- // Use mmap when virtual address-space is plentiful.
- uint64_t size;
- s = GetFileSize(fname, &size);
- if (s.ok()) {
- void* base = mmap(nullptr, size, PROT_READ, MAP_SHARED, fd, 0);
- if (base != MAP_FAILED) {
- result->reset(new PosixMmapReadableFile(fd, fname, base,
- size, options));
- } else {
- s = IOError("while mmap file for read", fname, errno);
- close(fd);
- }
- }
- } else {
- if (options.use_direct_reads && !options.use_mmap_reads) {
-#ifdef OS_MACOSX
- if (fcntl(fd, F_NOCACHE, 1) == -1) {
- close(fd);
- return IOError("while fcntl NoCache", fname, errno);
- }
-#endif
- }
- result->reset(new PosixRandomAccessFile(fname, fd, options));
- }
- return s;
- }
-
- virtual Status OpenWritableFile(const std::string& fname,
- std::unique_ptr<WritableFile>* result,
- const EnvOptions& options,
- bool reopen = false) {
- result->reset();
- Status s;
- int fd = -1;
- int flags = (reopen) ? (O_CREAT | O_APPEND) : (O_CREAT | O_TRUNC);
- // Direct IO mode with O_DIRECT flag or F_NOCAHCE (MAC OSX)
- if (options.use_direct_writes && !options.use_mmap_writes) {
- // Note: we should avoid O_APPEND here due to ta the following bug:
- // POSIX requires that opening a file with the O_APPEND flag should
- // have no affect on the location at which pwrite() writes data.
- // However, on Linux, if a file is opened with O_APPEND, pwrite()
- // appends data to the end of the file, regardless of the value of
- // offset.
- // More info here: https://linux.die.net/man/2/pwrite
-#ifdef ROCKSDB_LITE
- return Status::IOError(fname, "Direct I/O not supported in RocksDB lite");
-#endif // ROCKSDB_LITE
- flags |= O_WRONLY;
-#if !defined(OS_MACOSX) && !defined(OS_OPENBSD) && !defined(OS_SOLARIS)
- flags |= O_DIRECT;
-#endif
- TEST_SYNC_POINT_CALLBACK("NewWritableFile:O_DIRECT", &flags);
- } else if (options.use_mmap_writes) {
- // non-direct I/O
- flags |= O_RDWR;
- } else {
- flags |= O_WRONLY;
- }
-
- flags = cloexec_flags(flags, &options);
-
- do {
- IOSTATS_TIMER_GUARD(open_nanos);
- fd = open(fname.c_str(), flags, GetDBFileMode(allow_non_owner_access_));
- } while (fd < 0 && errno == EINTR);
-
- if (fd < 0) {
- s = IOError("While open a file for appending", fname, errno);
- return s;
- }
- SetFD_CLOEXEC(fd, &options);
-
- if (options.use_mmap_writes) {
- if (!checkedDiskForMmap_) {
- // this will be executed once in the program's lifetime.
- // do not use mmapWrite on non ext-3/xfs/tmpfs systems.
- if (!SupportsFastAllocate(fname)) {
- forceMmapOff_ = true;
- }
- checkedDiskForMmap_ = true;
- }
- }
- if (options.use_mmap_writes && !forceMmapOff_) {
- result->reset(new PosixMmapFile(fname, fd, page_size_, options));
- } else if (options.use_direct_writes && !options.use_mmap_writes) {
-#ifdef OS_MACOSX
- if (fcntl(fd, F_NOCACHE, 1) == -1) {
- close(fd);
- s = IOError("While fcntl NoCache an opened file for appending", fname,
- errno);
- return s;
- }
-#elif defined(OS_SOLARIS)
- if (directio(fd, DIRECTIO_ON) == -1) {
- if (errno != ENOTTY) { // ZFS filesystems don't support DIRECTIO_ON
- close(fd);
- s = IOError("While calling directio()", fname, errno);
- return s;
- }
+#ifndef ROCKSDB_NO_DYNAMIC_EXTENSION
+ // Loads the named library into the result.
+ // If the input name is empty, the current executable is loaded
+ // On *nix systems, a "lib" prefix is added to the name if one is not supplied
+ // Comparably, the appropriate shared library extension is added to the name
+ // if not supplied. If search_path is not specified, the shared library will
+ // be loaded using the default path (LD_LIBRARY_PATH) If search_path is
+ // specified, the shared library will be searched for in the directories
+ // provided by the search path
+ Status LoadLibrary(const std::string& name, const std::string& path,
+ std::shared_ptr<DynamicLibrary>* result) override {
+ Status status;
+ assert(result != nullptr);
+ if (name.empty()) {
+ void* hndl = dlopen(NULL, RTLD_NOW);
+ if (hndl != nullptr) {
+ result->reset(new PosixDynamicLibrary(name, hndl));
+ return Status::OK();
}
-#endif
- result->reset(new PosixWritableFile(fname, fd, options));
- } else {
- // disable mmap writes
- EnvOptions no_mmap_writes_options = options;
- no_mmap_writes_options.use_mmap_writes = false;
- result->reset(new PosixWritableFile(fname, fd, no_mmap_writes_options));
- }
- return s;
- }
-
- Status NewWritableFile(const std::string& fname,
- std::unique_ptr<WritableFile>* result,
- const EnvOptions& options) override {
- return OpenWritableFile(fname, result, options, false);
- }
-
- Status ReopenWritableFile(const std::string& fname,
- std::unique_ptr<WritableFile>* result,
- const EnvOptions& options) override {
- return OpenWritableFile(fname, result, options, true);
- }
-
- Status ReuseWritableFile(const std::string& fname,
- const std::string& old_fname,
- std::unique_ptr<WritableFile>* result,
- const EnvOptions& options) override {
- result->reset();
- Status s;
- int fd = -1;
-
- int flags = 0;
- // Direct IO mode with O_DIRECT flag or F_NOCAHCE (MAC OSX)
- if (options.use_direct_writes && !options.use_mmap_writes) {
-#ifdef ROCKSDB_LITE
- return Status::IOError(fname, "Direct I/O not supported in RocksDB lite");
-#endif // !ROCKSDB_LITE
- flags |= O_WRONLY;
-#if !defined(OS_MACOSX) && !defined(OS_OPENBSD) && !defined(OS_SOLARIS)
- flags |= O_DIRECT;
-#endif
- TEST_SYNC_POINT_CALLBACK("NewWritableFile:O_DIRECT", &flags);
- } else if (options.use_mmap_writes) {
- // mmap needs O_RDWR mode
- flags |= O_RDWR;
} else {
- flags |= O_WRONLY;
- }
-
- flags = cloexec_flags(flags, &options);
-
- do {
- IOSTATS_TIMER_GUARD(open_nanos);
- fd = open(old_fname.c_str(), flags,
- GetDBFileMode(allow_non_owner_access_));
- } while (fd < 0 && errno == EINTR);
- if (fd < 0) {
- s = IOError("while reopen file for write", fname, errno);
- return s;
- }
-
- SetFD_CLOEXEC(fd, &options);
- // rename into place
- if (rename(old_fname.c_str(), fname.c_str()) != 0) {
- s = IOError("while rename file to " + fname, old_fname, errno);
- close(fd);
- return s;
- }
-
- if (options.use_mmap_writes) {
- if (!checkedDiskForMmap_) {
- // this will be executed once in the program's lifetime.
- // do not use mmapWrite on non ext-3/xfs/tmpfs systems.
- if (!SupportsFastAllocate(fname)) {
- forceMmapOff_ = true;
- }
- checkedDiskForMmap_ = true;
+ std::string library_name = name;
+ if (library_name.find(kSharedLibExt) == std::string::npos) {
+ library_name = library_name + kSharedLibExt;
}
- }
- if (options.use_mmap_writes && !forceMmapOff_) {
- result->reset(new PosixMmapFile(fname, fd, page_size_, options));
- } else if (options.use_direct_writes && !options.use_mmap_writes) {
-#ifdef OS_MACOSX
- if (fcntl(fd, F_NOCACHE, 1) == -1) {
- close(fd);
- s = IOError("while fcntl NoCache for reopened file for append", fname,
- errno);
- return s;
- }
-#elif defined(OS_SOLARIS)
- if (directio(fd, DIRECTIO_ON) == -1) {
- if (errno != ENOTTY) { // ZFS filesystems don't support DIRECTIO_ON
- close(fd);
- s = IOError("while calling directio()", fname, errno);
- return s;
- }
+#if !defined(OS_WIN)
+ if (library_name.find('/') == std::string::npos &&
+ library_name.compare(0, 3, "lib") != 0) {
+ library_name = "lib" + library_name;
}
#endif
- result->reset(new PosixWritableFile(fname, fd, options));
- } else {
- // disable mmap writes
- EnvOptions no_mmap_writes_options = options;
- no_mmap_writes_options.use_mmap_writes = false;
- result->reset(new PosixWritableFile(fname, fd, no_mmap_writes_options));
- }
- return s;
- }
-
- Status NewRandomRWFile(const std::string& fname,
- std::unique_ptr<RandomRWFile>* result,
- const EnvOptions& options) override {
- int fd = -1;
- int flags = cloexec_flags(O_RDWR, &options);
-
- while (fd < 0) {
- IOSTATS_TIMER_GUARD(open_nanos);
-
- fd = open(fname.c_str(), flags, GetDBFileMode(allow_non_owner_access_));
- if (fd < 0) {
- // Error while opening the file
- if (errno == EINTR) {
- continue;
+ if (path.empty()) {
+ void* hndl = dlopen(library_name.c_str(), RTLD_NOW);
+ if (hndl != nullptr) {
+ result->reset(new PosixDynamicLibrary(library_name, hndl));
+ return Status::OK();
}
- return IOError("While open file for random read/write", fname, errno);
- }
- }
-
- SetFD_CLOEXEC(fd, &options);
- result->reset(new PosixRandomRWFile(fname, fd, options));
- return Status::OK();
- }
-
- Status NewMemoryMappedFileBuffer(
- const std::string& fname,
- std::unique_ptr<MemoryMappedFileBuffer>* result) override {
- int fd = -1;
- Status status;
- int flags = cloexec_flags(O_RDWR, nullptr);
-
- while (fd < 0) {
- IOSTATS_TIMER_GUARD(open_nanos);
- fd = open(fname.c_str(), flags, 0644);
- if (fd < 0) {
- // Error while opening the file
- if (errno == EINTR) {
- continue;
+ } else {
+ std::string local_path;
+ std::stringstream ss(path);
+ while (getline(ss, local_path, kPathSeparator)) {
+ if (!path.empty()) {
+ std::string full_name = local_path + "/" + library_name;
+ void* hndl = dlopen(full_name.c_str(), RTLD_NOW);
+ if (hndl != nullptr) {
+ result->reset(new PosixDynamicLibrary(full_name, hndl));
+ return Status::OK();
+ }
+ }
}
- status =
- IOError("While open file for raw mmap buffer access", fname, errno);
- break;
- }
- }
- uint64_t size;
- if (status.ok()) {
- status = GetFileSize(fname, &size);
- }
- void* base = nullptr;
- if (status.ok()) {
- base = mmap(nullptr, static_cast<size_t>(size), PROT_READ | PROT_WRITE,
- MAP_SHARED, fd, 0);
- if (base == MAP_FAILED) {
- status = IOError("while mmap file for read", fname, errno);
- }
- }
- if (status.ok()) {
- result->reset(
- new PosixMemoryMappedFileBuffer(base, static_cast<size_t>(size)));
- }
- if (fd >= 0) {
- // don't need to keep it open after mmap has been called
- close(fd);
- }
- return status;
- }
-
- Status NewDirectory(const std::string& name,
- std::unique_ptr<Directory>* result) override {
- result->reset();
- int fd;
- int flags = cloexec_flags(0, nullptr);
- {
- IOSTATS_TIMER_GUARD(open_nanos);
- fd = open(name.c_str(), flags);
- }
- if (fd < 0) {
- return IOError("While open directory", name, errno);
- } else {
- result->reset(new PosixDirectory(fd));
- }
- return Status::OK();
- }
-
- Status FileExists(const std::string& fname) override {
- int result = access(fname.c_str(), F_OK);
-
- if (result == 0) {
- return Status::OK();
- }
-
- int err = errno;
- switch (err) {
- case EACCES:
- case ELOOP:
- case ENAMETOOLONG:
- case ENOENT:
- case ENOTDIR:
- return Status::NotFound();
- default:
- assert(err == EIO || err == ENOMEM);
- return Status::IOError("Unexpected error(" + ToString(err) +
- ") accessing file `" + fname + "' ");
- }
- }
-
- Status GetChildren(const std::string& dir,
- std::vector<std::string>* result) override {
- result->clear();
- DIR* d = opendir(dir.c_str());
- if (d == nullptr) {
- switch (errno) {
- case EACCES:
- case ENOENT:
- case ENOTDIR:
- return Status::NotFound();
- default:
- return IOError("While opendir", dir, errno);
}
}
- struct dirent* entry;
- while ((entry = readdir(d)) != nullptr) {
- result->push_back(entry->d_name);
- }
- closedir(d);
- return Status::OK();
- }
-
- Status DeleteFile(const std::string& fname) override {
- Status result;
- if (unlink(fname.c_str()) != 0) {
- result = IOError("while unlink() file", fname, errno);
- }
- return result;
- };
-
- Status CreateDir(const std::string& name) override {
- Status result;
- if (mkdir(name.c_str(), 0755) != 0) {
- result = IOError("While mkdir", name, errno);
- }
- return result;
- };
-
- Status CreateDirIfMissing(const std::string& name) override {
- Status result;
- if (mkdir(name.c_str(), 0755) != 0) {
- if (errno != EEXIST) {
- result = IOError("While mkdir if missing", name, errno);
- } else if (!DirExists(name)) { // Check that name is actually a
- // directory.
- // Message is taken from mkdir
- result = Status::IOError("`"+name+"' exists but is not a directory");
- }
- }
- return result;
- };
-
- Status DeleteDir(const std::string& name) override {
- Status result;
- if (rmdir(name.c_str()) != 0) {
- result = IOError("file rmdir", name, errno);
- }
- return result;
- };
-
- Status GetFileSize(const std::string& fname, uint64_t* size) override {
- Status s;
- struct stat sbuf;
- if (stat(fname.c_str(), &sbuf) != 0) {
- *size = 0;
- s = IOError("while stat a file for size", fname, errno);
- } else {
- *size = sbuf.st_size;
- }
- return s;
- }
-
- Status GetFileModificationTime(const std::string& fname,
- uint64_t* file_mtime) override {
- struct stat s;
- if (stat(fname.c_str(), &s) !=0) {
- return IOError("while stat a file for modification time", fname, errno);
- }
- *file_mtime = static_cast<uint64_t>(s.st_mtime);
- return Status::OK();
- }
- Status RenameFile(const std::string& src,
- const std::string& target) override {
- Status result;
- if (rename(src.c_str(), target.c_str()) != 0) {
- result = IOError("While renaming a file to " + target, src, errno);
- }
- return result;
- }
-
- Status LinkFile(const std::string& src, const std::string& target) override {
- Status result;
- if (link(src.c_str(), target.c_str()) != 0) {
- if (errno == EXDEV) {
- return Status::NotSupported("No cross FS links allowed");
- }
- result = IOError("while link file to " + target, src, errno);
- }
- return result;
- }
-
- Status NumFileLinks(const std::string& fname, uint64_t* count) override {
- struct stat s;
- if (stat(fname.c_str(), &s) != 0) {
- return IOError("while stat a file for num file links", fname, errno);
- }
- *count = static_cast<uint64_t>(s.st_nlink);
- return Status::OK();
- }
-
- Status AreFilesSame(const std::string& first, const std::string& second,
- bool* res) override {
- struct stat statbuf[2];
- if (stat(first.c_str(), &statbuf[0]) != 0) {
- return IOError("stat file", first, errno);
- }
- if (stat(second.c_str(), &statbuf[1]) != 0) {
- return IOError("stat file", second, errno);
- }
-
- if (major(statbuf[0].st_dev) != major(statbuf[1].st_dev) ||
- minor(statbuf[0].st_dev) != minor(statbuf[1].st_dev) ||
- statbuf[0].st_ino != statbuf[1].st_ino) {
- *res = false;
- } else {
- *res = true;
- }
- return Status::OK();
- }
-
- Status LockFile(const std::string& fname, FileLock** lock) override {
- *lock = nullptr;
- Status result;
-
- mutex_lockedFiles.Lock();
- // If it already exists in the lockedFiles set, then it is already locked,
- // and fail this lock attempt. Otherwise, insert it into lockedFiles.
- // This check is needed because fcntl() does not detect lock conflict
- // if the fcntl is issued by the same thread that earlier acquired
- // this lock.
- // We must do this check *before* opening the file:
- // Otherwise, we will open a new file descriptor. Locks are associated with
- // a process, not a file descriptor and when *any* file descriptor is closed,
- // all locks the process holds for that *file* are released
- if (lockedFiles.insert(fname).second == false) {
- mutex_lockedFiles.Unlock();
- errno = ENOLCK;
- return IOError("lock ", fname, errno);
- }
-
- int fd;
- int flags = cloexec_flags(O_RDWR | O_CREAT, nullptr);
-
- {
- IOSTATS_TIMER_GUARD(open_nanos);
- fd = open(fname.c_str(), flags, 0644);
- }
- if (fd < 0) {
- result = IOError("while open a file for lock", fname, errno);
- } else if (LockOrUnlock(fd, true) == -1) {
- // if there is an error in locking, then remove the pathname from lockedfiles
- lockedFiles.erase(fname);
- result = IOError("While lock file", fname, errno);
- close(fd);
- } else {
- SetFD_CLOEXEC(fd, nullptr);
- PosixFileLock* my_lock = new PosixFileLock;
- my_lock->fd_ = fd;
- my_lock->filename = fname;
- *lock = my_lock;
- }
-
- mutex_lockedFiles.Unlock();
- return result;
- }
-
- Status UnlockFile(FileLock* lock) override {
- PosixFileLock* my_lock = reinterpret_cast<PosixFileLock*>(lock);
- Status result;
- mutex_lockedFiles.Lock();
- // If we are unlocking, then verify that we had locked it earlier,
- // it should already exist in lockedFiles. Remove it from lockedFiles.
- if (lockedFiles.erase(my_lock->filename) != 1) {
- errno = ENOLCK;
- result = IOError("unlock", my_lock->filename, errno);
- } else if (LockOrUnlock(my_lock->fd_, false) == -1) {
- result = IOError("unlock", my_lock->filename, errno);
- }
- close(my_lock->fd_);
- delete my_lock;
- mutex_lockedFiles.Unlock();
- return result;
+ return Status::IOError(
+ IOErrorMsg("Failed to open shared library: xs", name), dlerror());
}
+#endif // !ROCKSDB_NO_DYNAMIC_EXTENSION
void Schedule(void (*function)(void* arg1), void* arg, Priority pri = LOW,
void* tag = nullptr,
uint64_t GetThreadID() const override { return gettid(pthread_self()); }
- Status GetFreeSpace(const std::string& fname, uint64_t* free_space) override {
- struct statvfs sbuf;
-
- if (statvfs(fname.c_str(), &sbuf) < 0) {
- return IOError("While doing statvfs", fname, errno);
- }
-
- *free_space = ((uint64_t)sbuf.f_bsize * sbuf.f_bfree);
- return Status::OK();
- }
-
Status NewLogger(const std::string& fname,
std::shared_ptr<Logger>* result) override {
FILE* f;
{
IOSTATS_TIMER_GUARD(open_nanos);
- f = fopen(fname.c_str(), "w"
+ f = fopen(fname.c_str(),
+ "w"
#ifdef __GLIBC_PREREQ
#if __GLIBC_PREREQ(2, 7)
- "e" // glibc extension to enable O_CLOEXEC
+ "e" // glibc extension to enable O_CLOEXEC
#endif
#endif
- );
+ );
}
if (f == nullptr) {
result->reset();
uint64_t NowCPUNanos() override {
#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_AIX) || \
- defined(__MACH__)
+ (defined(__MACH__) && defined(__MAC_10_12))
struct timespec ts;
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
return static_cast<uint64_t>(ts.tv_sec) * 1000000000 + ts.tv_nsec;
Status GetHostName(char* name, uint64_t len) override {
int ret = gethostname(name, static_cast<size_t>(len));
if (ret < 0) {
- if (errno == EFAULT || errno == EINVAL)
+ if (errno == EFAULT || errno == EINVAL) {
return Status::InvalidArgument(strerror(errno));
- else
+ } else {
return IOError("GetHostName", name, errno);
+ }
}
return Status::OK();
}
return Status::OK();
}
- Status GetAbsolutePath(const std::string& db_path,
- std::string* output_path) override {
- if (!db_path.empty() && db_path[0] == '/') {
- *output_path = db_path;
- return Status::OK();
- }
-
- char the_path[256];
- char* ret = getcwd(the_path, 256);
- if (ret == nullptr) {
- return Status::IOError(strerror(errno));
- }
-
- *output_path = ret;
- return Status::OK();
+ ThreadStatusUpdater* GetThreadStatusUpdater() const override {
+ return Env::GetThreadStatusUpdater();
}
+ std::string GenerateUniqueId() override { return Env::GenerateUniqueId(); }
+
// Allow increasing the number of worker threads.
void SetBackgroundThreads(int num, Priority pri) override {
assert(pri >= Priority::BOTTOM && pri <= Priority::HIGH);
return dummy;
}
- EnvOptions OptimizeForLogWrite(const EnvOptions& env_options,
- const DBOptions& db_options) const override {
- EnvOptions optimized = env_options;
- optimized.use_mmap_writes = false;
- optimized.use_direct_writes = false;
- optimized.bytes_per_sync = db_options.wal_bytes_per_sync;
- // TODO(icanadi) it's faster if fallocate_with_keep_size is false, but it
- // breaks TransactionLogIteratorStallAtLastRecord unit test. Fix the unit
- // test and make this false
- optimized.fallocate_with_keep_size = true;
- optimized.writable_file_max_buffer_size =
- db_options.writable_file_max_buffer_size;
- return optimized;
- }
-
- EnvOptions OptimizeForManifestWrite(
- const EnvOptions& env_options) const override {
- EnvOptions optimized = env_options;
- optimized.use_mmap_writes = false;
- optimized.use_direct_writes = false;
- optimized.fallocate_with_keep_size = true;
- return optimized;
- }
-
private:
- bool checkedDiskForMmap_;
- bool forceMmapOff_; // do we override Env options?
-
- // Returns true iff the named directory exists and is a directory.
- virtual bool DirExists(const std::string& dname) {
- struct stat statbuf;
- if (stat(dname.c_str(), &statbuf) == 0) {
- return S_ISDIR(statbuf.st_mode);
- }
- return false; // stat() failed return false
- }
-
- bool SupportsFastAllocate(const std::string& path) {
-#ifdef ROCKSDB_FALLOCATE_PRESENT
- struct statfs s;
- if (statfs(path.c_str(), &s)){
- return false;
- }
- switch (s.f_type) {
- case EXT4_SUPER_MAGIC:
- return true;
- case XFS_SUPER_MAGIC:
- return true;
- case TMPFS_MAGIC:
- return true;
- default:
- return false;
- }
-#else
- (void)path;
- return false;
-#endif
- }
-
- size_t page_size_;
-
std::vector<ThreadPoolImpl> thread_pools_;
pthread_mutex_t mu_;
std::vector<pthread_t> threads_to_join_;
};
PosixEnv::PosixEnv()
- : checkedDiskForMmap_(false),
- forceMmapOff_(false),
- page_size_(getpagesize()),
+ : CompositeEnvWrapper(this, FileSystem::Default().get()),
thread_pools_(Priority::TOTAL),
allow_non_owner_access_(true) {
ThreadPoolImpl::PthreadCall("mutex_init", pthread_mutex_init(&mu_, nullptr));
CompressionContextCache::InitSingleton();
INIT_SYNC_POINT_SINGLETONS();
static PosixEnv default_env;
- return &default_env;
+ static CompositeEnvWrapper composite_env(&default_env,
+ FileSystem::Default().get());
+ return &composite_env;
}
-} // namespace rocksdb
+} // namespace ROCKSDB_NAMESPACE
projects / ceph.git / blobdiff