�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Ftest_util%2F'>test_util</a>/</p><hr><h3>✏️ Editing: fault_injection_test_env.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).
//
// Copyright 2014 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.

// This test uses a custom Env to keep track of the state of a filesystem as of
// the last &quot;sync&quot;. It then checks for data loss errors by purposely dropping
// file data (or entire files) not protected by a &quot;sync&quot;.

#include &quot;test_util/fault_injection_test_env.h&quot;
#include &lt;functional&gt;
#include &lt;utility&gt;

namespace ROCKSDB_NAMESPACE {

// Assume a filename, and not a directory name like &quot;/foo/bar/&quot;
std::string GetDirName(const std::string filename) {
  size_t found = filename.find_last_of(&quot;/\\&quot;);
  if (found == std::string::npos) {
    return &quot;&quot;;
  } else {
    return filename.substr(0, found);
  }
}

// A basic file truncation function suitable for this test.
Status Truncate(Env* env, const std::string&amp; filename, uint64_t length) {
  std::unique_ptr&lt;SequentialFile&gt; orig_file;
  const EnvOptions options;
  Status s = env-&gt;NewSequentialFile(filename, &amp;orig_file, options);
  if (!s.ok()) {
    fprintf(stderr, &quot;Cannot open file %s for truncation: %s\n&quot;,
            filename.c_str(), s.ToString().c_str());
    return s;
  }

  std::unique_ptr&lt;char[]&gt; scratch(new char[length]);
  ROCKSDB_NAMESPACE::Slice result;
  s = orig_file-&gt;Read(length, &amp;result, scratch.get());
#ifdef OS_WIN
  orig_file.reset();
#endif
  if (s.ok()) {
    std::string tmp_name = GetDirName(filename) + &quot;/truncate.tmp&quot;;
    std::unique_ptr&lt;WritableFile&gt; tmp_file;
    s = env-&gt;NewWritableFile(tmp_name, &amp;tmp_file, options);
    if (s.ok()) {
      s = tmp_file-&gt;Append(result);
      if (s.ok()) {
        s = env-&gt;RenameFile(tmp_name, filename);
      } else {
        fprintf(stderr, &quot;Cannot rename file %s to %s: %s\n&quot;, tmp_name.c_str(),
                filename.c_str(), s.ToString().c_str());
        env-&gt;DeleteFile(tmp_name);
      }
    }
  }
  if (!s.ok()) {
    fprintf(stderr, &quot;Cannot truncate file %s: %s\n&quot;, filename.c_str(),
            s.ToString().c_str());
  }

  return s;
}

// Trim the tailing &quot;/&quot; in the end of `str`
std::string TrimDirname(const std::string&amp; str) {
  size_t found = str.find_last_not_of(&quot;/&quot;);
  if (found == std::string::npos) {
    return str;
  }
  return str.substr(0, found + 1);
}

// Return pair &lt;parent directory name, file name&gt; of a full path.
std::pair&lt;std::string, std::string&gt; GetDirAndName(const std::string&amp; name) {
  std::string dirname = GetDirName(name);
  std::string fname = name.substr(dirname.size() + 1);
  return std::make_pair(dirname, fname);
}

Status FileState::DropUnsyncedData(Env* env) const {
  ssize_t sync_pos = pos_at_last_sync_ == -1 ? 0 : pos_at_last_sync_;
  return Truncate(env, filename_, sync_pos);
}

Status FileState::DropRandomUnsyncedData(Env* env, Random* rand) const {
  ssize_t sync_pos = pos_at_last_sync_ == -1 ? 0 : pos_at_last_sync_;
  assert(pos_ &gt;= sync_pos);
  int range = static_cast&lt;int&gt;(pos_ - sync_pos);
  uint64_t truncated_size =
      static_cast&lt;uint64_t&gt;(sync_pos) + rand-&gt;Uniform(range);
  return Truncate(env, filename_, truncated_size);
}

Status TestDirectory::Fsync() {
  if (!env_-&gt;IsFilesystemActive()) {
    return env_-&gt;GetError();
  }
  env_-&gt;SyncDir(dirname_);
  return dir_-&gt;Fsync();
}

TestWritableFile::TestWritableFile(const std::string&amp; fname,
                                   std::unique_ptr&lt;WritableFile&gt;&amp;&amp; f,
                                   FaultInjectionTestEnv* env)
    : state_(fname),
      target_(std::move(f)),
      writable_file_opened_(true),
      env_(env) {
  assert(target_ != nullptr);
  state_.pos_ = 0;
}

TestWritableFile::~TestWritableFile() {
  if (writable_file_opened_) {
    Close();
  }
}

Status TestWritableFile::Append(const Slice&amp; data) {
  if (!env_-&gt;IsFilesystemActive()) {
    return env_-&gt;GetError();
  }
  Status s = target_-&gt;Append(data);
  if (s.ok()) {
    state_.pos_ += data.size();
    env_-&gt;WritableFileAppended(state_);
  }
  return s;
}

Status TestWritableFile::Close() {
  writable_file_opened_ = false;
  Status s = target_-&gt;Close();
  if (s.ok()) {
    env_-&gt;WritableFileClosed(state_);
  }
  return s;
}

Status TestWritableFile::Flush() {
  Status s = target_-&gt;Flush();
  if (s.ok() &amp;&amp; env_-&gt;IsFilesystemActive()) {
    state_.pos_at_last_flush_ = state_.pos_;
  }
  return s;
}

Status TestWritableFile::Sync() {
  if (!env_-&gt;IsFilesystemActive()) {
    return Status::IOError(&quot;FaultInjectionTestEnv: not active&quot;);
  }
  // No need to actual sync.
  state_.pos_at_last_sync_ = state_.pos_;
  env_-&gt;WritableFileSynced(state_);
  return Status::OK();
}

TestRandomRWFile::TestRandomRWFile(const std::string&amp; /*fname*/,
                                   std::unique_ptr&lt;RandomRWFile&gt;&amp;&amp; f,
                                   FaultInjectionTestEnv* env)
    : target_(std::move(f)), file_opened_(true), env_(env) {
  assert(target_ != nullptr);
}

TestRandomRWFile::~TestRandomRWFile() {
  if (file_opened_) {
    Close();
  }
}

Status TestRandomRWFile::Write(uint64_t offset, const Slice&amp; data) {
  if (!env_-&gt;IsFilesystemActive()) {
    return env_-&gt;GetError();
  }
  return target_-&gt;Write(offset, data);
}

Status TestRandomRWFile::Read(uint64_t offset, size_t n, Slice* result,
                              char* scratch) const {
  if (!env_-&gt;IsFilesystemActive()) {
    return env_-&gt;GetError();
  }
  return target_-&gt;Read(offset, n, result, scratch);
}

Status TestRandomRWFile::Close() {
  file_opened_ = false;
  return target_-&gt;Close();
}

Status TestRandomRWFile::Flush() {
  if (!env_-&gt;IsFilesystemActive()) {
    return env_-&gt;GetError();
  }
  return target_-&gt;Flush();
}

Status TestRandomRWFile::Sync() {
  if (!env_-&gt;IsFilesystemActive()) {
    return env_-&gt;GetError();
  }
  return target_-&gt;Sync();
}

Status FaultInjectionTestEnv::NewDirectory(const std::string&amp; name,
                                           std::unique_ptr&lt;Directory&gt;* result) {
  std::unique_ptr&lt;Directory&gt; r;
  Status s = target()-&gt;NewDirectory(name, &amp;r);
  assert(s.ok());
  if (!s.ok()) {
    return s;
  }
  result-&gt;reset(new TestDirectory(this, TrimDirname(name), r.release()));
  return Status::OK();
}

Status FaultInjectionTestEnv::NewWritableFile(
    const std::string&amp; fname, std::unique_ptr&lt;WritableFile&gt;* result,
    const EnvOptions&amp; soptions) {
  if (!IsFilesystemActive()) {
    return GetError();
  }
  // Not allow overwriting files
  Status s = target()-&gt;FileExists(fname);
  if (s.ok()) {
    return Status::Corruption(&quot;File already exists.&quot;);
  } else if (!s.IsNotFound()) {
    assert(s.IsIOError());
    return s;
  }
  s = target()-&gt;NewWritableFile(fname, result, soptions);
  if (s.ok()) {
    result-&gt;reset(new TestWritableFile(fname, std::move(*result), this));
    // WritableFileWriter* file is opened
    // again then it will be truncated - so forget our saved state.
    UntrackFile(fname);
    MutexLock l(&amp;mutex_);
    open_files_.insert(fname);
    auto dir_and_name = GetDirAndName(fname);
    auto&amp; list = dir_to_new_files_since_last_sync_[dir_and_name.first];
    list.insert(dir_and_name.second);
  }
  return s;
}

Status FaultInjectionTestEnv::ReopenWritableFile(
    const std::string&amp; fname, std::unique_ptr&lt;WritableFile&gt;* result,
    const EnvOptions&amp; soptions) {
  if (!IsFilesystemActive()) {
    return GetError();
  }
  Status s = target()-&gt;ReopenWritableFile(fname, result, soptions);
  if (s.ok()) {
    result-&gt;reset(new TestWritableFile(fname, std::move(*result), this));
    // WritableFileWriter* file is opened
    // again then it will be truncated - so forget our saved state.
    UntrackFile(fname);
    MutexLock l(&amp;mutex_);
    open_files_.insert(fname);
    auto dir_and_name = GetDirAndName(fname);
    auto&amp; list = dir_to_new_files_since_last_sync_[dir_and_name.first];
    list.insert(dir_and_name.second);
  }
  return s;
}

Status FaultInjectionTestEnv::NewRandomRWFile(
    const std::string&amp; fname, std::unique_ptr&lt;RandomRWFile&gt;* result,
    const EnvOptions&amp; soptions) {
  if (!IsFilesystemActive()) {
    return GetError();
  }
  Status s = target()-&gt;NewRandomRWFile(fname, result, soptions);
  if (s.ok()) {
    result-&gt;reset(new TestRandomRWFile(fname, std::move(*result), this));
    // WritableFileWriter* file is opened
    // again then it will be truncated - so forget our saved state.
    UntrackFile(fname);
    MutexLock l(&amp;mutex_);
    open_files_.insert(fname);
    auto dir_and_name = GetDirAndName(fname);
    auto&amp; list = dir_to_new_files_since_last_sync_[dir_and_name.first];
    list.insert(dir_and_name.second);
  }
  return s;
}

Status FaultInjectionTestEnv::NewRandomAccessFile(
    const std::string&amp; fname, std::unique_ptr&lt;RandomAccessFile&gt;* result,
    const EnvOptions&amp; soptions) {
  if (!IsFilesystemActive()) {
    return GetError();
  }
  return target()-&gt;NewRandomAccessFile(fname, result, soptions);
}

Status FaultInjectionTestEnv::DeleteFile(const std::string&amp; f) {
  if (!IsFilesystemActive()) {
    return GetError();
  }
  Status s = EnvWrapper::DeleteFile(f);
  if (!s.ok()) {
    fprintf(stderr, &quot;Cannot delete file %s: %s\n&quot;, f.c_str(),
            s.ToString().c_str());
  }
  if (s.ok()) {
    UntrackFile(f);
  }
  return s;
}

Status FaultInjectionTestEnv::RenameFile(const std::string&amp; s,
                                         const std::string&amp; t) {
  if (!IsFilesystemActive()) {
    return GetError();
  }
  Status ret = EnvWrapper::RenameFile(s, t);

  if (ret.ok()) {
    MutexLock l(&amp;mutex_);
    if (db_file_state_.find(s) != db_file_state_.end()) {
      db_file_state_[t] = db_file_state_[s];
      db_file_state_.erase(s);
    }

    auto sdn = GetDirAndName(s);
    auto tdn = GetDirAndName(t);
    if (dir_to_new_files_since_last_sync_[sdn.first].erase(sdn.second) != 0) {
      auto&amp; tlist = dir_to_new_files_since_last_sync_[tdn.first];
      assert(tlist.find(tdn.second) == tlist.end());
      tlist.insert(tdn.second);
    }
  }

  return ret;
}

void FaultInjectionTestEnv::WritableFileClosed(const FileState&amp; state) {
  MutexLock l(&amp;mutex_);
  if (open_files_.find(state.filename_) != open_files_.end()) {
    db_file_state_[state.filename_] = state;
    open_files_.erase(state.filename_);
  }
}

void FaultInjectionTestEnv::WritableFileSynced(const FileState&amp; state) {
  MutexLock l(&amp;mutex_);
  if (open_files_.find(state.filename_) != open_files_.end()) {
    if (db_file_state_.find(state.filename_) == db_file_state_.end()) {
      db_file_state_.insert(std::make_pair(state.filename_, state));
    } else {
      db_file_state_[state.filename_] = state;
    }
  }
}

void FaultInjectionTestEnv::WritableFileAppended(const FileState&amp; state) {
  MutexLock l(&amp;mutex_);
  if (open_files_.find(state.filename_) != open_files_.end()) {
    if (db_file_state_.find(state.filename_) == db_file_state_.end()) {
      db_file_state_.insert(std::make_pair(state.filename_, state));
    } else {
      db_file_state_[state.filename_] = state;
    }
  }
}

// For every file that is not fully synced, make a call to `func` with
// FileState of the file as the parameter.
Status FaultInjectionTestEnv::DropFileData(
    std::function&lt;Status(Env*, FileState)&gt; func) {
  Status s;
  MutexLock l(&amp;mutex_);
  for (std::map&lt;std::string, FileState&gt;::const_iterator it =
           db_file_state_.begin();
       s.ok() &amp;&amp; it != db_file_state_.end(); ++it) {
    const FileState&amp; state = it-&gt;second;
    if (!state.IsFullySynced()) {
      s = func(target(), state);
    }
  }
  return s;
}

Status FaultInjectionTestEnv::DropUnsyncedFileData() {
  return DropFileData([&amp;](Env* env, const FileState&amp; state) {
    return state.DropUnsyncedData(env);
  });
}

Status FaultInjectionTestEnv::DropRandomUnsyncedFileData(Random* rnd) {
  return DropFileData([&amp;](Env* env, const FileState&amp; state) {
    return state.DropRandomUnsyncedData(env, rnd);
  });
}

Status FaultInjectionTestEnv::DeleteFilesCreatedAfterLastDirSync() {
  // Because DeleteFile access this container make a copy to avoid deadlock
  std::map&lt;std::string, std::set&lt;std::string&gt;&gt; map_copy;
  {
    MutexLock l(&amp;mutex_);
    map_copy.insert(dir_to_new_files_since_last_sync_.begin(),
                    dir_to_new_files_since_last_sync_.end());
  }

  for (auto&amp; pair : map_copy) {
    for (std::string name : pair.second) {
      Status s = DeleteFile(pair.first + &quot;/&quot; + name);
      if (!s.ok()) {
        return s;
      }
    }
  }
  return Status::OK();
}
void FaultInjectionTestEnv::ResetState() {
  MutexLock l(&amp;mutex_);
  db_file_state_.clear();
  dir_to_new_files_since_last_sync_.clear();
  SetFilesystemActiveNoLock(true);
}

void FaultInjectionTestEnv::UntrackFile(const std::string&amp; f) {
  MutexLock l(&amp;mutex_);
  auto dir_and_name = GetDirAndName(f);
  dir_to_new_files_since_last_sync_[dir_and_name.first].erase(
      dir_and_name.second);
  db_file_state_.erase(f);
  open_files_.erase(f);
}
}  // namespace ROCKSDB_NAMESPACE
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Ftest_util'>🔙 Back</a></p>