Replace Status with IOStatus in the backupable_db (#8820)

Summary:
In order to populate the IOStatus up to the higher level, replace some of the Status to IOStatus.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/8820

Test Plan: make check

Reviewed By: pdillinger

Differential Revision: D30967215

Pulled By: zhichao-cao

fbshipit-source-id: ccf9d5cfbd9d3de047c464aaa85f9fa43b474903

file/line_file_reader.cc

@@ -11,24 +11,24 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-Status LineFileReader::Create(const std::shared_ptr<FileSystem>& fs,
-                              const std::string& fname,
-                              const FileOptions& file_opts,
-                              std::unique_ptr<LineFileReader>* reader,
-                              IODebugContext* dbg) {
+IOStatus LineFileReader::Create(const std::shared_ptr<FileSystem>& fs,
+                                const std::string& fname,
+                                const FileOptions& file_opts,
+                                std::unique_ptr<LineFileReader>* reader,
+                                IODebugContext* dbg) {
   std::unique_ptr<FSSequentialFile> file;
-  Status s = fs->NewSequentialFile(fname, file_opts, &file, dbg);
-  if (s.ok()) {
+  IOStatus io_s = fs->NewSequentialFile(fname, file_opts, &file, dbg);
+  if (io_s.ok()) {
     reader->reset(new LineFileReader(std::move(file), fname));
   }
-  return s;
+  return io_s;
 }
 
 bool LineFileReader::ReadLine(std::string* out) {
   assert(out);
-  if (!status_.ok()) {
+  if (!io_status_.ok()) {
     // Status should be checked (or permit unchecked) any time we return false.
-    status_.MustCheck();
+    io_status_.MustCheck();
     return false;
   }
   out->clear();
@@ -44,16 +44,16 @@ bool LineFileReader::ReadLine(std::string* out) {
       return true;
     }
     if (at_eof_) {
-      status_.MustCheck();
+      io_status_.MustCheck();
       return false;
     }
     // else flush and reload buffer
     out->append(buf_begin_, buf_end_ - buf_begin_);
     Slice result;
-    status_ = sfr_.Read(buf_.size(), &result, buf_.data());
+    io_status_ = sfr_.Read(buf_.size(), &result, buf_.data());
     IOSTATS_ADD(bytes_read, result.size());
-    if (!status_.ok()) {
-      status_.MustCheck();
+    if (!io_status_.ok()) {
+      io_status_.MustCheck();
       return false;
     }
     if (result.size() != buf_.size()) {

file/line_file_reader.h

@@ -17,7 +17,7 @@ class LineFileReader {
  private:
   std::array<char, 8192> buf_;
   SequentialFileReader sfr_;
-  Status status_;
+  IOStatus io_status_;
   const char* buf_begin_ = buf_.data();
   const char* buf_end_ = buf_.data();
   size_t line_number_ = 0;
@@ -29,10 +29,10 @@ class LineFileReader {
   explicit LineFileReader(Args&&... args)
       : sfr_(std::forward<Args&&>(args)...) {}
 
-  static Status Create(const std::shared_ptr<FileSystem>& fs,
-                       const std::string& fname, const FileOptions& file_opts,
-                       std::unique_ptr<LineFileReader>* reader,
-                       IODebugContext* dbg);
+  static IOStatus Create(const std::shared_ptr<FileSystem>& fs,
+                         const std::string& fname, const FileOptions& file_opts,
+                         std::unique_ptr<LineFileReader>* reader,
+                         IODebugContext* dbg);
 
   LineFileReader(const LineFileReader&) = delete;
   LineFileReader& operator=(const LineFileReader&) = delete;
@@ -53,7 +53,7 @@ class LineFileReader {
   // Returns any error encountered during read. The error is considered
   // permanent and no retry or recovery is attempted with the same
   // LineFileReader.
-  const Status& GetStatus() const { return status_; }
+  const IOStatus& GetStatus() const { return io_status_; }
 };
 
 }  // namespace ROCKSDB_NAMESPACE

file/sequence_file_reader.cc

@@ -22,20 +22,20 @@
 #include "util/rate_limiter.h"
 
 namespace ROCKSDB_NAMESPACE {
-Status SequentialFileReader::Create(
+IOStatus SequentialFileReader::Create(
     const std::shared_ptr<FileSystem>& fs, const std::string& fname,
     const FileOptions& file_opts, std::unique_ptr<SequentialFileReader>* reader,
     IODebugContext* dbg) {
   std::unique_ptr<FSSequentialFile> file;
-  Status s = fs->NewSequentialFile(fname, file_opts, &file, dbg);
-  if (s.ok()) {
+  IOStatus io_s = fs->NewSequentialFile(fname, file_opts, &file, dbg);
+  if (io_s.ok()) {
     reader->reset(new SequentialFileReader(std::move(file), fname));
   }
-  return s;
+  return io_s;
 }
 
-Status SequentialFileReader::Read(size_t n, Slice* result, char* scratch) {
-  Status s;
+IOStatus SequentialFileReader::Read(size_t n, Slice* result, char* scratch) {
+  IOStatus io_s;
   if (use_direct_io()) {
 #ifndef ROCKSDB_LITE
     size_t offset = offset_.fetch_add(n);
@@ -48,9 +48,9 @@ Status SequentialFileReader::Read(size_t n, Slice* result, char* scratch) {
     buf.Alignment(alignment);
     buf.AllocateNewBuffer(size);
     Slice tmp;
-    s = file_->PositionedRead(aligned_offset, size, IOOptions(), &tmp,
-                              buf.BufferStart(), nullptr);
-    if (s.ok() && offset_advance < tmp.size()) {
+    io_s = file_->PositionedRead(aligned_offset, size, IOOptions(), &tmp,
+                                 buf.BufferStart(), nullptr);
+    if (io_s.ok() && offset_advance < tmp.size()) {
       buf.Size(tmp.size());
       r = buf.Read(scratch, offset_advance,
                    std::min(tmp.size() - offset_advance, n));
@@ -58,17 +58,17 @@ Status SequentialFileReader::Read(size_t n, Slice* result, char* scratch) {
     *result = Slice(scratch, r);
 #endif  // !ROCKSDB_LITE
   } else {
-    s = file_->Read(n, IOOptions(), result, scratch, nullptr);
+    io_s = file_->Read(n, IOOptions(), result, scratch, nullptr);
   }
   IOSTATS_ADD(bytes_read, result->size());
-  return s;
+  return io_s;
 }
 
-Status SequentialFileReader::Skip(uint64_t n) {
+IOStatus SequentialFileReader::Skip(uint64_t n) {
 #ifndef ROCKSDB_LITE
   if (use_direct_io()) {
     offset_ += static_cast<size_t>(n);
-    return Status::OK();
+    return IOStatus::OK();
   }
 #endif  // !ROCKSDB_LITE
   return file_->Skip(n);

file/sequence_file_reader.h

@@ -41,17 +41,17 @@ class SequentialFileReader {
       : file_name_(_file_name),
         file_(NewReadaheadSequentialFile(std::move(_file), _readahead_size),
               io_tracer, _file_name) {}
-  static Status Create(const std::shared_ptr<FileSystem>& fs,
-                       const std::string& fname, const FileOptions& file_opts,
-                       std::unique_ptr<SequentialFileReader>* reader,
-                       IODebugContext* dbg);
+  static IOStatus Create(const std::shared_ptr<FileSystem>& fs,
+                         const std::string& fname, const FileOptions& file_opts,
+                         std::unique_ptr<SequentialFileReader>* reader,
+                         IODebugContext* dbg);
 
   SequentialFileReader(const SequentialFileReader&) = delete;
   SequentialFileReader& operator=(const SequentialFileReader&) = delete;
 
-  Status Read(size_t n, Slice* result, char* scratch);
+  IOStatus Read(size_t n, Slice* result, char* scratch);
 
-  Status Skip(uint64_t n);
+  IOStatus Skip(uint64_t n);
 
   FSSequentialFile* file() { return file_.get(); }
 

include/rocksdb/utilities/backup_engine.h

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "rocksdb/env.h"
+#include "rocksdb/io_status.h"
 #include "rocksdb/options.h"
 #include "rocksdb/status.h"
 
@@ -406,25 +407,25 @@ class BackupEngineReadOnlyBase {
       std::vector<BackupID>* corrupt_backup_ids) const = 0;
 
   // Restore to specified db_dir and wal_dir from backup_id.
-  virtual Status RestoreDBFromBackup(const RestoreOptions& options,
-                                     BackupID backup_id,
-                                     const std::string& db_dir,
-                                     const std::string& wal_dir) const = 0;
+  virtual IOStatus RestoreDBFromBackup(const RestoreOptions& options,
+                                       BackupID backup_id,
+                                       const std::string& db_dir,
+                                       const std::string& wal_dir) const = 0;
 
   // keep for backward compatibility.
-  virtual Status RestoreDBFromBackup(
+  virtual IOStatus RestoreDBFromBackup(
       BackupID backup_id, const std::string& db_dir, const std::string& wal_dir,
       const RestoreOptions& options = RestoreOptions()) const {
     return RestoreDBFromBackup(options, backup_id, db_dir, wal_dir);
   }
 
   // Like RestoreDBFromBackup but restores from latest non-corrupt backup_id
-  virtual Status RestoreDBFromLatestBackup(
+  virtual IOStatus RestoreDBFromLatestBackup(
       const RestoreOptions& options, const std::string& db_dir,
       const std::string& wal_dir) const = 0;
 
   // keep for backward compatibility.
-  virtual Status RestoreDBFromLatestBackup(
+  virtual IOStatus RestoreDBFromLatestBackup(
       const std::string& db_dir, const std::string& wal_dir,
       const RestoreOptions& options = RestoreOptions()) const {
     return RestoreDBFromLatestBackup(options, db_dir, wal_dir);
@@ -445,8 +446,8 @@ class BackupEngineReadOnlyBase {
   // their sizes (and checksums) when the BackupEngine was opened.
   //
   // Returns Status::OK() if all checks are good
-  virtual Status VerifyBackup(BackupID backup_id,
-                              bool verify_with_checksum = false) const = 0;
+  virtual IOStatus VerifyBackup(BackupID backup_id,
+                                bool verify_with_checksum = false) const = 0;
 };
 
 // Append-only functions of a BackupEngine. See BackupEngine comment for
@@ -457,12 +458,12 @@ class BackupEngineAppendOnlyBase {
   virtual ~BackupEngineAppendOnlyBase() {}
 
   // same as CreateNewBackup, but stores extra application metadata.
-  virtual Status CreateNewBackupWithMetadata(
+  virtual IOStatus CreateNewBackupWithMetadata(
       const CreateBackupOptions& options, DB* db,
       const std::string& app_metadata, BackupID* new_backup_id = nullptr) = 0;
 
   // keep here for backward compatibility.
-  virtual Status CreateNewBackupWithMetadata(
+  virtual IOStatus CreateNewBackupWithMetadata(
       DB* db, const std::string& app_metadata, bool flush_before_backup = false,
       std::function<void()> progress_callback = []() {}) {
     CreateBackupOptions options;
@@ -514,7 +515,7 @@ class BackupEngineAppendOnlyBase {
   // with Append or Write operations in another BackupEngine on the same
   // backup_dir, because temporary files will be treated as obsolete and
   // deleted.
-  virtual Status GarbageCollect() = 0;
+  virtual IOStatus GarbageCollect() = 0;
 };
 
 // A backup engine for organizing and managing backups.
@@ -585,13 +586,13 @@ class BackupEngine : public BackupEngineReadOnlyBase,
 
   // Deletes old backups, keeping latest num_backups_to_keep alive.
   // See also DeleteBackup.
-  virtual Status PurgeOldBackups(uint32_t num_backups_to_keep) = 0;
+  virtual IOStatus PurgeOldBackups(uint32_t num_backups_to_keep) = 0;
 
   // Deletes a specific backup. If this operation (or PurgeOldBackups)
   // is not completed due to crash, power failure, etc. the state
   // will be cleaned up the next time you call DeleteBackup,
   // PurgeOldBackups, or GarbageCollect.
-  virtual Status DeleteBackup(BackupID backup_id) = 0;
+  virtual IOStatus DeleteBackup(BackupID backup_id) = 0;
 };
 
 // A variant of BackupEngine that only allows "Read" operations. See