Vasili Svirski
9 years ago
commit
3d56d868c7
@ -0,0 +1,215 @@ |
||||
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
||||
// This source code is licensed under the BSD-style license found in the
|
||||
// LICENSE file in the root directory of this source tree. An additional grant
|
||||
// of patent rights can be found in the PATENTS file in the same directory.
|
||||
//
|
||||
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
||||
// 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.
|
||||
#pragma once |
||||
#include <deque> |
||||
#include <set> |
||||
#include <dirent.h> |
||||
#include <pthread.h> |
||||
#include <string.h> |
||||
#include <sys/time.h> |
||||
#include <time.h> |
||||
#include <signal.h> |
||||
#include <algorithm> |
||||
#include <fcntl.h> |
||||
#include <unistd.h> |
||||
#include <stdio.h> |
||||
#include <errno.h> |
||||
#include <stdlib.h> |
||||
#include <sys/ioctl.h> |
||||
#include <sys/stat.h> |
||||
#include <sys/types.h> |
||||
#include <sys/mman.h> |
||||
#ifdef OS_LINUX |
||||
#include <sys/statfs.h> |
||||
#include <sys/syscall.h> |
||||
#endif |
||||
#if defined(OS_LINUX) |
||||
#include <linux/fs.h> |
||||
#endif |
||||
#include "rocksdb/env.h" |
||||
#include "util/sync_point.h" |
||||
#include "util/iostats_context_imp.h" |
||||
#include "util/coding.h" |
||||
#include "rocksdb/slice.h" |
||||
#include "port/port.h" |
||||
#include "util/logging.h" |
||||
#include "util/posix_logger.h" |
||||
#include "util/random.h" |
||||
#include "util/string_util.h" |
||||
#include "util/thread_status_updater.h" |
||||
#include "util/thread_status_util.h" |
||||
|
||||
// For non linux platform, the following macros are used only as place
|
||||
// holder.
|
||||
#if !(defined OS_LINUX) && !(defined CYGWIN) |
||||
#define POSIX_FADV_NORMAL 0 /* [MC1] no further special treatment */ |
||||
#define POSIX_FADV_RANDOM 1 /* [MC1] expect random page refs */ |
||||
#define POSIX_FADV_SEQUENTIAL 2 /* [MC1] expect sequential page refs */ |
||||
#define POSIX_FADV_WILLNEED 3 /* [MC1] will need these pages */ |
||||
#define POSIX_FADV_DONTNEED 4 /* [MC1] dont need these pages */ |
||||
#endif |
||||
|
||||
namespace rocksdb { |
||||
|
||||
static Status IOError(const std::string& context, int err_number) { |
||||
return Status::IOError(context, strerror(err_number)); |
||||
} |
||||
|
||||
class PosixSequentialFile : public SequentialFile { |
||||
private: |
||||
std::string filename_; |
||||
FILE* file_; |
||||
int fd_; |
||||
bool use_os_buffer_; |
||||
|
||||
public: |
||||
PosixSequentialFile(const std::string& fname, FILE* f, |
||||
const EnvOptions& options); |
||||
virtual ~PosixSequentialFile(); |
||||
|
||||
virtual Status Read(size_t n, Slice* result, char* scratch) override; |
||||
virtual Status Skip(uint64_t n) override; |
||||
virtual Status InvalidateCache(size_t offset, size_t length) override; |
||||
}; |
||||
|
||||
class PosixRandomAccessFile : public RandomAccessFile { |
||||
private: |
||||
std::string filename_; |
||||
int fd_; |
||||
bool use_os_buffer_; |
||||
|
||||
public: |
||||
PosixRandomAccessFile(const std::string& fname, int fd, |
||||
const EnvOptions& options); |
||||
virtual ~PosixRandomAccessFile(); |
||||
|
||||
virtual Status Read(uint64_t offset, size_t n, Slice* result, |
||||
char* scratch) const override; |
||||
#ifdef OS_LINUX |
||||
virtual size_t GetUniqueId(char* id, size_t max_size) const override; |
||||
#endif |
||||
virtual void Hint(AccessPattern pattern) override; |
||||
virtual Status InvalidateCache(size_t offset, size_t length) override; |
||||
}; |
||||
|
||||
class PosixWritableFile : public WritableFile { |
||||
private: |
||||
const std::string filename_; |
||||
int fd_; |
||||
uint64_t filesize_; |
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
bool allow_fallocate_; |
||||
bool fallocate_with_keep_size_; |
||||
#endif |
||||
|
||||
public: |
||||
PosixWritableFile(const std::string& fname, int fd, |
||||
const EnvOptions& options); |
||||
~PosixWritableFile(); |
||||
|
||||
// Means Close() will properly take care of truncate
|
||||
// and it does not need any additional information
|
||||
virtual Status Truncate(uint64_t size) override { return Status::OK(); } |
||||
virtual Status Close() override; |
||||
virtual Status Append(const Slice& data) override; |
||||
virtual Status Flush() override; |
||||
virtual Status Sync() override; |
||||
virtual Status Fsync() override; |
||||
virtual bool IsSyncThreadSafe() const override; |
||||
virtual uint64_t GetFileSize() override; |
||||
virtual Status InvalidateCache(size_t offset, size_t length) override; |
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
virtual Status Allocate(off_t offset, off_t len) override; |
||||
virtual Status RangeSync(off_t offset, off_t nbytes) override; |
||||
virtual size_t GetUniqueId(char* id, size_t max_size) const override; |
||||
#endif |
||||
}; |
||||
|
||||
class PosixMmapReadableFile : public RandomAccessFile { |
||||
private: |
||||
int fd_; |
||||
std::string filename_; |
||||
void* mmapped_region_; |
||||
size_t length_; |
||||
|
||||
public: |
||||
PosixMmapReadableFile(const int fd, const std::string& fname, void* base, |
||||
size_t length, const EnvOptions& options); |
||||
virtual ~PosixMmapReadableFile(); |
||||
virtual Status Read(uint64_t offset, size_t n, Slice* result, |
||||
char* scratch) const override; |
||||
virtual Status InvalidateCache(size_t offset, size_t length) override; |
||||
}; |
||||
|
||||
class PosixMmapFile : public WritableFile { |
||||
private: |
||||
std::string filename_; |
||||
int fd_; |
||||
size_t page_size_; |
||||
size_t map_size_; // How much extra memory to map at a time
|
||||
char* base_; // The mapped region
|
||||
char* limit_; // Limit of the mapped region
|
||||
char* dst_; // Where to write next (in range [base_,limit_])
|
||||
char* last_sync_; // Where have we synced up to
|
||||
uint64_t file_offset_; // Offset of base_ in file
|
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
bool allow_fallocate_; // If false, fallocate calls are bypassed
|
||||
bool fallocate_with_keep_size_; |
||||
#endif |
||||
|
||||
// Roundup x to a multiple of y
|
||||
static size_t Roundup(size_t x, size_t y) { return ((x + y - 1) / y) * y; } |
||||
|
||||
size_t TruncateToPageBoundary(size_t s) { |
||||
s -= (s & (page_size_ - 1)); |
||||
assert((s % page_size_) == 0); |
||||
return s; |
||||
} |
||||
|
||||
Status MapNewRegion(); |
||||
Status UnmapCurrentRegion(); |
||||
Status Msync(); |
||||
|
||||
public: |
||||
PosixMmapFile(const std::string& fname, int fd, size_t page_size, |
||||
const EnvOptions& options); |
||||
~PosixMmapFile(); |
||||
|
||||
// Means Close() will properly take care of truncate
|
||||
// and it does not need any additional information
|
||||
virtual Status Truncate(uint64_t size) override { return Status::OK(); } |
||||
virtual Status Close() override; |
||||
virtual Status Append(const Slice& data) override; |
||||
virtual Status Flush() override; |
||||
virtual Status Sync() override; |
||||
virtual Status Fsync() override; |
||||
virtual uint64_t GetFileSize() override; |
||||
virtual Status InvalidateCache(size_t offset, size_t length) override; |
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
virtual Status Allocate(off_t offset, off_t len) override; |
||||
#endif |
||||
}; |
||||
|
||||
class PosixDirectory : public Directory { |
||||
public: |
||||
explicit PosixDirectory(int fd) : fd_(fd) {} |
||||
~PosixDirectory() { close(fd_); } |
||||
|
||||
virtual Status Fsync() override { |
||||
if (fsync(fd_) == -1) { |
||||
return IOError("directory", errno); |
||||
} |
||||
return Status::OK(); |
||||
} |
||||
|
||||
private: |
||||
int fd_; |
||||
}; |
||||
|
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,614 @@ |
||||
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
||||
// This source code is licensed under the BSD-style license found in the
|
||||
// LICENSE file in the root directory of this source tree. An additional grant
|
||||
// of patent rights can be found in the PATENTS file in the same directory.
|
||||
//
|
||||
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
||||
// 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.
|
||||
|
||||
#ifdef ROCKSDB_LIB_IO_POSIX |
||||
|
||||
#include "posix/io_posix.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
// A wrapper for fadvise, if the platform doesn't support fadvise,
|
||||
// it will simply return Status::NotSupport.
|
||||
int Fadvise(int fd, off_t offset, size_t len, int advice) { |
||||
#ifdef OS_LINUX |
||||
return posix_fadvise(fd, offset, len, advice); |
||||
#else |
||||
return 0; // simply do nothing.
|
||||
#endif |
||||
} |
||||
|
||||
/*
|
||||
* PosixSequentialFile |
||||
*/ |
||||
PosixSequentialFile::PosixSequentialFile(const std::string& fname, FILE* f, |
||||
const EnvOptions& options) |
||||
: filename_(fname), |
||||
file_(f), |
||||
fd_(fileno(f)), |
||||
use_os_buffer_(options.use_os_buffer) {} |
||||
|
||||
PosixSequentialFile::~PosixSequentialFile() { fclose(file_); } |
||||
|
||||
Status PosixSequentialFile::Read(size_t n, Slice* result, char* scratch) { |
||||
Status s; |
||||
size_t r = 0; |
||||
do { |
||||
r = fread_unlocked(scratch, 1, n, file_); |
||||
} while (r == 0 && ferror(file_) && errno == EINTR); |
||||
*result = Slice(scratch, r); |
||||
if (r < n) { |
||||
if (feof(file_)) { |
||||
// We leave status as ok if we hit the end of the file
|
||||
// We also clear the error so that the reads can continue
|
||||
// if a new data is written to the file
|
||||
clearerr(file_); |
||||
} else { |
||||
// A partial read with an error: return a non-ok status
|
||||
s = IOError(filename_, errno); |
||||
} |
||||
} |
||||
if (!use_os_buffer_) { |
||||
// we need to fadvise away the entire range of pages because
|
||||
// we do not want readahead pages to be cached.
|
||||
Fadvise(fd_, 0, 0, POSIX_FADV_DONTNEED); // free OS pages
|
||||
} |
||||
return s; |
||||
} |
||||
|
||||
Status PosixSequentialFile::Skip(uint64_t n) { |
||||
if (fseek(file_, static_cast<long int>(n), SEEK_CUR)) { |
||||
return IOError(filename_, errno); |
||||
} |
||||
return Status::OK(); |
||||
} |
||||
|
||||
Status PosixSequentialFile::InvalidateCache(size_t offset, size_t length) { |
||||
#ifndef OS_LINUX |
||||
return Status::OK(); |
||||
#else |
||||
// free OS pages
|
||||
int ret = Fadvise(fd_, offset, length, POSIX_FADV_DONTNEED); |
||||
if (ret == 0) { |
||||
return Status::OK(); |
||||
} |
||||
return IOError(filename_, errno); |
||||
#endif |
||||
} |
||||
|
||||
#if defined(OS_LINUX) |
||||
namespace { |
||||
static size_t GetUniqueIdFromFile(int fd, char* id, size_t max_size) { |
||||
if (max_size < kMaxVarint64Length * 3) { |
||||
return 0; |
||||
} |
||||
|
||||
struct stat buf; |
||||
int result = fstat(fd, &buf); |
||||
if (result == -1) { |
||||
return 0; |
||||
} |
||||
|
||||
long version = 0; |
||||
result = ioctl(fd, FS_IOC_GETVERSION, &version); |
||||
if (result == -1) { |
||||
return 0; |
||||
} |
||||
uint64_t uversion = (uint64_t)version; |
||||
|
||||
char* rid = id; |
||||
rid = EncodeVarint64(rid, buf.st_dev); |
||||
rid = EncodeVarint64(rid, buf.st_ino); |
||||
rid = EncodeVarint64(rid, uversion); |
||||
assert(rid >= id); |
||||
return static_cast<size_t>(rid - id); |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
/*
|
||||
* PosixRandomAccessFile |
||||
* |
||||
* pread() based random-access |
||||
*/ |
||||
PosixRandomAccessFile::PosixRandomAccessFile(const std::string& fname, int fd, |
||||
const EnvOptions& options) |
||||
: filename_(fname), fd_(fd), use_os_buffer_(options.use_os_buffer) { |
||||
assert(!options.use_mmap_reads || sizeof(void*) < 8); |
||||
} |
||||
|
||||
PosixRandomAccessFile::~PosixRandomAccessFile() { close(fd_); } |
||||
|
||||
Status PosixRandomAccessFile::Read(uint64_t offset, size_t n, Slice* result, |
||||
char* scratch) const { |
||||
Status s; |
||||
ssize_t r = -1; |
||||
size_t left = n; |
||||
char* ptr = scratch; |
||||
while (left > 0) { |
||||
r = pread(fd_, ptr, left, static_cast<off_t>(offset)); |
||||
|
||||
if (r <= 0) { |
||||
if (errno == EINTR) { |
||||
continue; |
||||
} |
||||
break; |
||||
} |
||||
ptr += r; |
||||
offset += r; |
||||
left -= r; |
||||
} |
||||
|
||||
*result = Slice(scratch, (r < 0) ? 0 : n - left); |
||||
if (r < 0) { |
||||
// An error: return a non-ok status
|
||||
s = IOError(filename_, errno); |
||||
} |
||||
if (!use_os_buffer_) { |
||||
// we need to fadvise away the entire range of pages because
|
||||
// we do not want readahead pages to be cached.
|
||||
Fadvise(fd_, 0, 0, POSIX_FADV_DONTNEED); // free OS pages
|
||||
} |
||||
return s; |
||||
} |
||||
|
||||
#ifdef OS_LINUX |
||||
size_t PosixRandomAccessFile::GetUniqueId(char* id, size_t max_size) const { |
||||
return GetUniqueIdFromFile(fd_, id, max_size); |
||||
} |
||||
#endif |
||||
|
||||
void PosixRandomAccessFile::Hint(AccessPattern pattern) { |
||||
switch (pattern) { |
||||
case NORMAL: |
||||
Fadvise(fd_, 0, 0, POSIX_FADV_NORMAL); |
||||
break; |
||||
case RANDOM: |
||||
Fadvise(fd_, 0, 0, POSIX_FADV_RANDOM); |
||||
break; |
||||
case SEQUENTIAL: |
||||
Fadvise(fd_, 0, 0, POSIX_FADV_SEQUENTIAL); |
||||
break; |
||||
case WILLNEED: |
||||
Fadvise(fd_, 0, 0, POSIX_FADV_WILLNEED); |
||||
break; |
||||
case DONTNEED: |
||||
Fadvise(fd_, 0, 0, POSIX_FADV_DONTNEED); |
||||
break; |
||||
default: |
||||
assert(false); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
Status PosixRandomAccessFile::InvalidateCache(size_t offset, size_t length) { |
||||
#ifndef OS_LINUX |
||||
return Status::OK(); |
||||
#else |
||||
// free OS pages
|
||||
int ret = Fadvise(fd_, offset, length, POSIX_FADV_DONTNEED); |
||||
if (ret == 0) { |
||||
return Status::OK(); |
||||
} |
||||
return IOError(filename_, errno); |
||||
#endif |
||||
} |
||||
|
||||
/*
|
||||
* PosixMmapReadableFile |
||||
* |
||||
* mmap() based random-access |
||||
*/ |
||||
// base[0,length-1] contains the mmapped contents of the file.
|
||||
PosixMmapReadableFile::PosixMmapReadableFile(const int fd, |
||||
const std::string& fname, |
||||
void* base, size_t length, |
||||
const EnvOptions& options) |
||||
: fd_(fd), filename_(fname), mmapped_region_(base), length_(length) { |
||||
fd_ = fd_ + 0; // suppress the warning for used variables
|
||||
assert(options.use_mmap_reads); |
||||
assert(options.use_os_buffer); |
||||
} |
||||
|
||||
PosixMmapReadableFile::~PosixMmapReadableFile() { |
||||
int ret = munmap(mmapped_region_, length_); |
||||
if (ret != 0) { |
||||
fprintf(stdout, "failed to munmap %p length %" ROCKSDB_PRIszt " \n", |
||||
mmapped_region_, length_); |
||||
} |
||||
} |
||||
|
||||
Status PosixMmapReadableFile::Read(uint64_t offset, size_t n, Slice* result, |
||||
char* scratch) const { |
||||
Status s; |
||||
if (offset > length_) { |
||||
*result = Slice(); |
||||
return IOError(filename_, EINVAL); |
||||
} else if (offset + n > length_) { |
||||
n = static_cast<size_t>(length_ - offset); |
||||
} |
||||
*result = Slice(reinterpret_cast<char*>(mmapped_region_) + offset, n); |
||||
return s; |
||||
} |
||||
|
||||
Status PosixMmapReadableFile::InvalidateCache(size_t offset, size_t length) { |
||||
#ifndef OS_LINUX |
||||
return Status::OK(); |
||||
#else |
||||
// free OS pages
|
||||
int ret = Fadvise(fd_, offset, length, POSIX_FADV_DONTNEED); |
||||
if (ret == 0) { |
||||
return Status::OK(); |
||||
} |
||||
return IOError(filename_, errno); |
||||
#endif |
||||
} |
||||
|
||||
/*
|
||||
* PosixMmapFile |
||||
* |
||||
* We preallocate up to an extra megabyte and use memcpy to append new |
||||
* data to the file. This is safe since we either properly close the |
||||
* file before reading from it, or for log files, the reading code |
||||
* knows enough to skip zero suffixes. |
||||
*/ |
||||
Status PosixMmapFile::UnmapCurrentRegion() { |
||||
TEST_KILL_RANDOM("PosixMmapFile::UnmapCurrentRegion:0", rocksdb_kill_odds); |
||||
if (base_ != nullptr) { |
||||
int munmap_status = munmap(base_, limit_ - base_); |
||||
if (munmap_status != 0) { |
||||
return IOError(filename_, munmap_status); |
||||
} |
||||
file_offset_ += limit_ - base_; |
||||
base_ = nullptr; |
||||
limit_ = nullptr; |
||||
last_sync_ = nullptr; |
||||
dst_ = nullptr; |
||||
|
||||
// Increase the amount we map the next time, but capped at 1MB
|
||||
if (map_size_ < (1 << 20)) { |
||||
map_size_ *= 2; |
||||
} |
||||
} |
||||
return Status::OK(); |
||||
} |
||||
|
||||
Status PosixMmapFile::MapNewRegion() { |
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
assert(base_ == nullptr); |
||||
|
||||
TEST_KILL_RANDOM("PosixMmapFile::UnmapCurrentRegion:0", rocksdb_kill_odds); |
||||
// we can't fallocate with FALLOC_FL_KEEP_SIZE here
|
||||
if (allow_fallocate_) { |
||||
IOSTATS_TIMER_GUARD(allocate_nanos); |
||||
int alloc_status = fallocate(fd_, 0, file_offset_, map_size_); |
||||
if (alloc_status != 0) { |
||||
// fallback to posix_fallocate
|
||||
alloc_status = posix_fallocate(fd_, file_offset_, map_size_); |
||||
} |
||||
if (alloc_status != 0) { |
||||
return Status::IOError("Error allocating space to file : " + filename_ + |
||||
"Error : " + strerror(alloc_status)); |
||||
} |
||||
} |
||||
|
||||
TEST_KILL_RANDOM("PosixMmapFile::Append:1", rocksdb_kill_odds); |
||||
void* ptr = mmap(nullptr, map_size_, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, |
||||
file_offset_); |
||||
if (ptr == MAP_FAILED) { |
||||
return Status::IOError("MMap failed on " + filename_); |
||||
} |
||||
TEST_KILL_RANDOM("PosixMmapFile::Append:2", rocksdb_kill_odds); |
||||
|
||||
base_ = reinterpret_cast<char*>(ptr); |
||||
limit_ = base_ + map_size_; |
||||
dst_ = base_; |
||||
last_sync_ = base_; |
||||
return Status::OK(); |
||||
#else |
||||
return Status::NotSupported("This platform doesn't support fallocate()"); |
||||
#endif |
||||
} |
||||
|
||||
Status PosixMmapFile::Msync() { |
||||
if (dst_ == last_sync_) { |
||||
return Status::OK(); |
||||
} |
||||
// Find the beginnings of the pages that contain the first and last
|
||||
// bytes to be synced.
|
||||
size_t p1 = TruncateToPageBoundary(last_sync_ - base_); |
||||
size_t p2 = TruncateToPageBoundary(dst_ - base_ - 1); |
||||
last_sync_ = dst_; |
||||
TEST_KILL_RANDOM("PosixMmapFile::Msync:0", rocksdb_kill_odds); |
||||
if (msync(base_ + p1, p2 - p1 + page_size_, MS_SYNC) < 0) { |
||||
return IOError(filename_, errno); |
||||
} |
||||
return Status::OK(); |
||||
} |
||||
|
||||
PosixMmapFile::PosixMmapFile(const std::string& fname, int fd, size_t page_size, |
||||
const EnvOptions& options) |
||||
: filename_(fname), |
||||
fd_(fd), |
||||
page_size_(page_size), |
||||
map_size_(Roundup(65536, page_size)), |
||||
base_(nullptr), |
||||
limit_(nullptr), |
||||
dst_(nullptr), |
||||
last_sync_(nullptr), |
||||
file_offset_(0) { |
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
allow_fallocate_ = options.allow_fallocate; |
||||
fallocate_with_keep_size_ = options.fallocate_with_keep_size; |
||||
#endif |
||||
assert((page_size & (page_size - 1)) == 0); |
||||
assert(options.use_mmap_writes); |
||||
} |
||||
|
||||
PosixMmapFile::~PosixMmapFile() { |
||||
if (fd_ >= 0) { |
||||
PosixMmapFile::Close(); |
||||
} |
||||
} |
||||
|
||||
Status PosixMmapFile::Append(const Slice& data) { |
||||
const char* src = data.data(); |
||||
size_t left = data.size(); |
||||
while (left > 0) { |
||||
assert(base_ <= dst_); |
||||
assert(dst_ <= limit_); |
||||
size_t avail = limit_ - dst_; |
||||
if (avail == 0) { |
||||
Status s = UnmapCurrentRegion(); |
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
s = MapNewRegion(); |
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
TEST_KILL_RANDOM("PosixMmapFile::Append:0", rocksdb_kill_odds); |
||||
} |
||||
|
||||
size_t n = (left <= avail) ? left : avail; |
||||
memcpy(dst_, src, n); |
||||
dst_ += n; |
||||
src += n; |
||||
left -= n; |
||||
} |
||||
return Status::OK(); |
||||
} |
||||
|
||||
Status PosixMmapFile::Close() { |
||||
Status s; |
||||
size_t unused = limit_ - dst_; |
||||
|
||||
s = UnmapCurrentRegion(); |
||||
if (!s.ok()) { |
||||
s = IOError(filename_, errno); |
||||
} else if (unused > 0) { |
||||
// Trim the extra space at the end of the file
|
||||
if (ftruncate(fd_, file_offset_ - unused) < 0) { |
||||
s = IOError(filename_, errno); |
||||
} |
||||
} |
||||
|
||||
if (close(fd_) < 0) { |
||||
if (s.ok()) { |
||||
s = IOError(filename_, errno); |
||||
} |
||||
} |
||||
|
||||
fd_ = -1; |
||||
base_ = nullptr; |
||||
limit_ = nullptr; |
||||
return s; |
||||
} |
||||
|
||||
Status PosixMmapFile::Flush() { return Status::OK(); } |
||||
|
||||
Status PosixMmapFile::Sync() { |
||||
if (fdatasync(fd_) < 0) { |
||||
return IOError(filename_, errno); |
||||
} |
||||
|
||||
return Msync(); |
||||
} |
||||
|
||||
/**
|
||||
* Flush data as well as metadata to stable storage. |
||||
*/ |
||||
Status PosixMmapFile::Fsync() { |
||||
if (fsync(fd_) < 0) { |
||||
return IOError(filename_, errno); |
||||
} |
||||
|
||||
return Msync(); |
||||
} |
||||
|
||||
/**
|
||||
* Get the size of valid data in the file. This will not match the |
||||
* size that is returned from the filesystem because we use mmap |
||||
* to extend file by map_size every time. |
||||
*/ |
||||
uint64_t PosixMmapFile::GetFileSize() { |
||||
size_t used = dst_ - base_; |
||||
return file_offset_ + used; |
||||
} |
||||
|
||||
Status PosixMmapFile::InvalidateCache(size_t offset, size_t length) { |
||||
#ifndef OS_LINUX |
||||
return Status::OK(); |
||||
#else |
||||
// free OS pages
|
||||
int ret = Fadvise(fd_, offset, length, POSIX_FADV_DONTNEED); |
||||
if (ret == 0) { |
||||
return Status::OK(); |
||||
} |
||||
return IOError(filename_, errno); |
||||
#endif |
||||
} |
||||
|
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
Status PosixMmapFile::Allocate(off_t offset, off_t len) { |
||||
TEST_KILL_RANDOM("PosixMmapFile::Allocate:0", rocksdb_kill_odds); |
||||
int alloc_status = 0; |
||||
if (allow_fallocate_) { |
||||
alloc_status = fallocate( |
||||
fd_, fallocate_with_keep_size_ ? FALLOC_FL_KEEP_SIZE : 0, offset, len); |
||||
} |
||||
if (alloc_status == 0) { |
||||
return Status::OK(); |
||||
} else { |
||||
return IOError(filename_, errno); |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
/*
|
||||
* PosixWritableFile |
||||
* |
||||
* Use posix write to write data to a file. |
||||
*/ |
||||
PosixWritableFile::PosixWritableFile(const std::string& fname, int fd, |
||||
const EnvOptions& options) |
||||
: filename_(fname), fd_(fd), filesize_(0) { |
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
allow_fallocate_ = options.allow_fallocate; |
||||
fallocate_with_keep_size_ = options.fallocate_with_keep_size; |
||||
#endif |
||||
assert(!options.use_mmap_writes); |
||||
} |
||||
|
||||
PosixWritableFile::~PosixWritableFile() { |
||||
if (fd_ >= 0) { |
||||
PosixWritableFile::Close(); |
||||
} |
||||
} |
||||
|
||||
Status PosixWritableFile::Append(const Slice& data) { |
||||
const char* src = data.data(); |
||||
size_t left = data.size(); |
||||
while (left != 0) { |
||||
ssize_t done = write(fd_, src, left); |
||||
if (done < 0) { |
||||
if (errno == EINTR) { |
||||
continue; |
||||
} |
||||
return IOError(filename_, errno); |
||||
} |
||||
left -= done; |
||||
src += done; |
||||
} |
||||
filesize_ += data.size(); |
||||
return Status::OK(); |
||||
} |
||||
|
||||
Status PosixWritableFile::Close() { |
||||
Status s; |
||||
|
||||
size_t block_size; |
||||
size_t last_allocated_block; |
||||
GetPreallocationStatus(&block_size, &last_allocated_block); |
||||
if (last_allocated_block > 0) { |
||||
// trim the extra space preallocated at the end of the file
|
||||
// NOTE(ljin): we probably don't want to surface failure as an IOError,
|
||||
// but it will be nice to log these errors.
|
||||
int dummy __attribute__((unused)); |
||||
dummy = ftruncate(fd_, filesize_); |
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
// in some file systems, ftruncate only trims trailing space if the
|
||||
// new file size is smaller than the current size. Calling fallocate
|
||||
// with FALLOC_FL_PUNCH_HOLE flag to explicitly release these unused
|
||||
// blocks. FALLOC_FL_PUNCH_HOLE is supported on at least the following
|
||||
// filesystems:
|
||||
// XFS (since Linux 2.6.38)
|
||||
// ext4 (since Linux 3.0)
|
||||
// Btrfs (since Linux 3.7)
|
||||
// tmpfs (since Linux 3.5)
|
||||
// We ignore error since failure of this operation does not affect
|
||||
// correctness.
|
||||
IOSTATS_TIMER_GUARD(allocate_nanos); |
||||
if (allow_fallocate_) { |
||||
fallocate(fd_, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, filesize_, |
||||
block_size * last_allocated_block - filesize_); |
||||
} |
||||
#endif |
||||
} |
||||
|
||||
if (close(fd_) < 0) { |
||||
s = IOError(filename_, errno); |
||||
} |
||||
fd_ = -1; |
||||
return s; |
||||
} |
||||
|
||||
// write out the cached data to the OS cache
|
||||
Status PosixWritableFile::Flush() { return Status::OK(); } |
||||
|
||||
Status PosixWritableFile::Sync() { |
||||
if (fdatasync(fd_) < 0) { |
||||
return IOError(filename_, errno); |
||||
} |
||||
return Status::OK(); |
||||
} |
||||
|
||||
Status PosixWritableFile::Fsync() { |
||||
if (fsync(fd_) < 0) { |
||||
return IOError(filename_, errno); |
||||
} |
||||
return Status::OK(); |
||||
} |
||||
|
||||
bool PosixWritableFile::IsSyncThreadSafe() const { return true; } |
||||
|
||||
uint64_t PosixWritableFile::GetFileSize() { return filesize_; } |
||||
|
||||
Status PosixWritableFile::InvalidateCache(size_t offset, size_t length) { |
||||
#ifndef OS_LINUX |
||||
return Status::OK(); |
||||
#else |
||||
// free OS pages
|
||||
int ret = Fadvise(fd_, offset, length, POSIX_FADV_DONTNEED); |
||||
if (ret == 0) { |
||||
return Status::OK(); |
||||
} |
||||
return IOError(filename_, errno); |
||||
#endif |
||||
} |
||||
|
||||
#ifdef ROCKSDB_FALLOCATE_PRESENT |
||||
Status PosixWritableFile::Allocate(off_t offset, off_t len) { |
||||
TEST_KILL_RANDOM("PosixWritableFile::Allocate:0", rocksdb_kill_odds); |
||||
IOSTATS_TIMER_GUARD(allocate_nanos); |
||||
int alloc_status = 0; |
||||
if (allow_fallocate_) { |
||||
alloc_status = fallocate( |
||||
fd_, fallocate_with_keep_size_ ? FALLOC_FL_KEEP_SIZE : 0, offset, len); |
||||
} |
||||
if (alloc_status == 0) { |
||||
return Status::OK(); |
||||
} else { |
||||
return IOError(filename_, errno); |
||||
} |
||||
} |
||||
|
||||
Status PosixWritableFile::RangeSync(off_t offset, off_t nbytes) { |
||||
if (sync_file_range(fd_, offset, nbytes, SYNC_FILE_RANGE_WRITE) == 0) { |
||||
return Status::OK(); |
||||
} else { |
||||
return IOError(filename_, errno); |
||||
} |
||||
} |
||||
|
||||
size_t PosixWritableFile::GetUniqueId(char* id, size_t max_size) const { |
||||
return GetUniqueIdFromFile(fd_, id, max_size); |
||||
} |
||||
#endif |
||||
} // namespace rocksdb
|
||||
#endif |
||||
Loading…
Reference in new issue