�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%2Ffile%2F'>file</a>/</p><hr><h3>✏️ Editing: filename.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 (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.
#include &quot;file/filename.h&quot;
#include &lt;cinttypes&gt;

#include &lt;ctype.h&gt;
#include &lt;stdio.h&gt;
#include &lt;vector&gt;
#include &quot;file/writable_file_writer.h&quot;
#include &quot;logging/logging.h&quot;
#include &quot;rocksdb/env.h&quot;
#include &quot;test_util/sync_point.h&quot;
#include &quot;util/stop_watch.h&quot;
#include &quot;util/string_util.h&quot;

namespace ROCKSDB_NAMESPACE {

static const std::string kRocksDbTFileExt = &quot;sst&quot;;
static const std::string kLevelDbTFileExt = &quot;ldb&quot;;
static const std::string kRocksDBBlobFileExt = &quot;blob&quot;;

// Given a path, flatten the path name by replacing all chars not in
// {[0-9,a-z,A-Z,-,_,.]} with _. And append &#039;_LOG\0&#039; at the end.
// Return the number of chars stored in dest not including the trailing &#039;\0&#039;.
static size_t GetInfoLogPrefix(const std::string&amp; path, char* dest, int len) {
  const char suffix[] = &quot;_LOG&quot;;

  size_t write_idx = 0;
  size_t i = 0;
  size_t src_len = path.size();

  while (i &lt; src_len &amp;&amp; write_idx &lt; len - sizeof(suffix)) {
    if ((path[i] &gt;= &#039;a&#039; &amp;&amp; path[i] &lt;= &#039;z&#039;) ||
        (path[i] &gt;= &#039;0&#039; &amp;&amp; path[i] &lt;= &#039;9&#039;) ||
        (path[i] &gt;= &#039;A&#039; &amp;&amp; path[i] &lt;= &#039;Z&#039;) ||
        path[i] == &#039;-&#039; ||
        path[i] == &#039;.&#039; ||
        path[i] == &#039;_&#039;){
      dest[write_idx++] = path[i];
    } else {
      if (i &gt; 0) {
        dest[write_idx++] = &#039;_&#039;;
      }
    }
    i++;
  }
  assert(sizeof(suffix) &lt;= len - write_idx);
  // &quot;\0&quot; is automatically added by snprintf
  snprintf(dest + write_idx, len - write_idx, suffix);
  write_idx += sizeof(suffix) - 1;
  return write_idx;
}

static std::string MakeFileName(uint64_t number, const char* suffix) {
  char buf[100];
  snprintf(buf, sizeof(buf), &quot;%06llu.%s&quot;,
           static_cast&lt;unsigned long long&gt;(number), suffix);
  return buf;
}

static std::string MakeFileName(const std::string&amp; name, uint64_t number,
                                const char* suffix) {
  return name + &quot;/&quot; + MakeFileName(number, suffix);
}

std::string LogFileName(const std::string&amp; name, uint64_t number) {
  assert(number &gt; 0);
  return MakeFileName(name, number, &quot;log&quot;);
}

std::string LogFileName(uint64_t number) {
  assert(number &gt; 0);
  return MakeFileName(number, &quot;log&quot;);
}

std::string BlobFileName(const std::string&amp; blobdirname, uint64_t number) {
  assert(number &gt; 0);
  return MakeFileName(blobdirname, number, kRocksDBBlobFileExt.c_str());
}

std::string BlobFileName(const std::string&amp; dbname, const std::string&amp; blob_dir,
                         uint64_t number) {
  assert(number &gt; 0);
  return MakeFileName(dbname + &quot;/&quot; + blob_dir, number,
                      kRocksDBBlobFileExt.c_str());
}

std::string ArchivalDirectory(const std::string&amp; dir) {
  return dir + &quot;/&quot; + ARCHIVAL_DIR;
}
std::string ArchivedLogFileName(const std::string&amp; name, uint64_t number) {
  assert(number &gt; 0);
  return MakeFileName(name + &quot;/&quot; + ARCHIVAL_DIR, number, &quot;log&quot;);
}

std::string MakeTableFileName(const std::string&amp; path, uint64_t number) {
  return MakeFileName(path, number, kRocksDbTFileExt.c_str());
}

std::string MakeTableFileName(uint64_t number) {
  return MakeFileName(number, kRocksDbTFileExt.c_str());
}

std::string Rocks2LevelTableFileName(const std::string&amp; fullname) {
  assert(fullname.size() &gt; kRocksDbTFileExt.size() + 1);
  if (fullname.size() &lt;= kRocksDbTFileExt.size() + 1) {
    return &quot;&quot;;
  }
  return fullname.substr(0, fullname.size() - kRocksDbTFileExt.size()) +
         kLevelDbTFileExt;
}

uint64_t TableFileNameToNumber(const std::string&amp; name) {
  uint64_t number = 0;
  uint64_t base = 1;
  int pos = static_cast&lt;int&gt;(name.find_last_of(&#039;.&#039;));
  while (--pos &gt;= 0 &amp;&amp; name[pos] &gt;= &#039;0&#039; &amp;&amp; name[pos] &lt;= &#039;9&#039;) {
    number += (name[pos] - &#039;0&#039;) * base;
    base *= 10;
  }
  return number;
}

std::string TableFileName(const std::vector&lt;DbPath&gt;&amp; db_paths, uint64_t number,
                          uint32_t path_id) {
  assert(number &gt; 0);
  std::string path;
  if (path_id &gt;= db_paths.size()) {
    path = db_paths.back().path;
  } else {
    path = db_paths[path_id].path;
  }
  return MakeTableFileName(path, number);
}

void FormatFileNumber(uint64_t number, uint32_t path_id, char* out_buf,
                      size_t out_buf_size) {
  if (path_id == 0) {
    snprintf(out_buf, out_buf_size, &quot;%&quot; PRIu64, number);
  } else {
    snprintf(out_buf, out_buf_size, &quot;%&quot; PRIu64
                                    &quot;(path &quot;
                                    &quot;%&quot; PRIu32 &quot;)&quot;,
             number, path_id);
  }
}

std::string DescriptorFileName(const std::string&amp; dbname, uint64_t number) {
  assert(number &gt; 0);
  char buf[100];
  snprintf(buf, sizeof(buf), &quot;/MANIFEST-%06llu&quot;,
           static_cast&lt;unsigned long long&gt;(number));
  return dbname + buf;
}

std::string CurrentFileName(const std::string&amp; dbname) {
  return dbname + &quot;/CURRENT&quot;;
}

std::string LockFileName(const std::string&amp; dbname) {
  return dbname + &quot;/LOCK&quot;;
}

std::string TempFileName(const std::string&amp; dbname, uint64_t number) {
  return MakeFileName(dbname, number, kTempFileNameSuffix.c_str());
}

InfoLogPrefix::InfoLogPrefix(bool has_log_dir,
                             const std::string&amp; db_absolute_path) {
  if (!has_log_dir) {
    const char kInfoLogPrefix[] = &quot;LOG&quot;;
    // &quot;\0&quot; is automatically added to the end
    snprintf(buf, sizeof(buf), kInfoLogPrefix);
    prefix = Slice(buf, sizeof(kInfoLogPrefix) - 1);
  } else {
    size_t len = GetInfoLogPrefix(db_absolute_path, buf, sizeof(buf));
    prefix = Slice(buf, len);
  }
}

std::string InfoLogFileName(const std::string&amp; dbname,
    const std::string&amp; db_path, const std::string&amp; log_dir) {
  if (log_dir.empty()) {
    return dbname + &quot;/LOG&quot;;
  }

  InfoLogPrefix info_log_prefix(true, db_path);
  return log_dir + &quot;/&quot; + info_log_prefix.buf;
}

// Return the name of the old info log file for &quot;dbname&quot;.
std::string OldInfoLogFileName(const std::string&amp; dbname, uint64_t ts,
    const std::string&amp; db_path, const std::string&amp; log_dir) {
  char buf[50];
  snprintf(buf, sizeof(buf), &quot;%llu&quot;, static_cast&lt;unsigned long long&gt;(ts));

  if (log_dir.empty()) {
    return dbname + &quot;/LOG.old.&quot; + buf;
  }

  InfoLogPrefix info_log_prefix(true, db_path);
  return log_dir + &quot;/&quot; + info_log_prefix.buf + &quot;.old.&quot; + buf;
}

std::string OptionsFileName(const std::string&amp; dbname, uint64_t file_num) {
  char buffer[256];
  snprintf(buffer, sizeof(buffer), &quot;%s%06&quot; PRIu64,
           kOptionsFileNamePrefix.c_str(), file_num);
  return dbname + &quot;/&quot; + buffer;
}

std::string TempOptionsFileName(const std::string&amp; dbname, uint64_t file_num) {
  char buffer[256];
  snprintf(buffer, sizeof(buffer), &quot;%s%06&quot; PRIu64 &quot;.%s&quot;,
           kOptionsFileNamePrefix.c_str(), file_num,
           kTempFileNameSuffix.c_str());
  return dbname + &quot;/&quot; + buffer;
}

std::string MetaDatabaseName(const std::string&amp; dbname, uint64_t number) {
  char buf[100];
  snprintf(buf, sizeof(buf), &quot;/METADB-%llu&quot;,
           static_cast&lt;unsigned long long&gt;(number));
  return dbname + buf;
}

std::string IdentityFileName(const std::string&amp; dbname) {
  return dbname + &quot;/IDENTITY&quot;;
}

// Owned filenames have the form:
//    dbname/IDENTITY
//    dbname/CURRENT
//    dbname/LOCK
//    dbname/&lt;info_log_name_prefix&gt;
//    dbname/&lt;info_log_name_prefix&gt;.old.[0-9]+
//    dbname/MANIFEST-[0-9]+
//    dbname/[0-9]+.(log|sst|blob)
//    dbname/METADB-[0-9]+
//    dbname/OPTIONS-[0-9]+
//    dbname/OPTIONS-[0-9]+.dbtmp
//    Disregards / at the beginning
bool ParseFileName(const std::string&amp; fname,
                   uint64_t* number,
                   FileType* type,
                   WalFileType* log_type) {
  return ParseFileName(fname, number, &quot;&quot;, type, log_type);
}

bool ParseFileName(const std::string&amp; fname, uint64_t* number,
                   const Slice&amp; info_log_name_prefix, FileType* type,
                   WalFileType* log_type) {
  Slice rest(fname);
  if (fname.length() &gt; 1 &amp;&amp; fname[0] == &#039;/&#039;) {
    rest.remove_prefix(1);
  }
  if (rest == &quot;IDENTITY&quot;) {
    *number = 0;
    *type = kIdentityFile;
  } else if (rest == &quot;CURRENT&quot;) {
    *number = 0;
    *type = kCurrentFile;
  } else if (rest == &quot;LOCK&quot;) {
    *number = 0;
    *type = kDBLockFile;
  } else if (info_log_name_prefix.size() &gt; 0 &amp;&amp;
             rest.starts_with(info_log_name_prefix)) {
    rest.remove_prefix(info_log_name_prefix.size());
    if (rest == &quot;&quot; || rest == &quot;.old&quot;) {
      *number = 0;
      *type = kInfoLogFile;
    } else if (rest.starts_with(&quot;.old.&quot;)) {
      uint64_t ts_suffix;
      // sizeof also counts the trailing &#039;\0&#039;.
      rest.remove_prefix(sizeof(&quot;.old.&quot;) - 1);
      if (!ConsumeDecimalNumber(&amp;rest, &amp;ts_suffix)) {
        return false;
      }
      *number = ts_suffix;
      *type = kInfoLogFile;
    }
  } else if (rest.starts_with(&quot;MANIFEST-&quot;)) {
    rest.remove_prefix(strlen(&quot;MANIFEST-&quot;));
    uint64_t num;
    if (!ConsumeDecimalNumber(&amp;rest, &amp;num)) {
      return false;
    }
    if (!rest.empty()) {
      return false;
    }
    *type = kDescriptorFile;
    *number = num;
  } else if (rest.starts_with(&quot;METADB-&quot;)) {
    rest.remove_prefix(strlen(&quot;METADB-&quot;));
    uint64_t num;
    if (!ConsumeDecimalNumber(&amp;rest, &amp;num)) {
      return false;
    }
    if (!rest.empty()) {
      return false;
    }
    *type = kMetaDatabase;
    *number = num;
  } else if (rest.starts_with(kOptionsFileNamePrefix)) {
    uint64_t ts_suffix;
    bool is_temp_file = false;
    rest.remove_prefix(kOptionsFileNamePrefix.size());
    const std::string kTempFileNameSuffixWithDot =
        std::string(&quot;.&quot;) + kTempFileNameSuffix;
    if (rest.ends_with(kTempFileNameSuffixWithDot)) {
      rest.remove_suffix(kTempFileNameSuffixWithDot.size());
      is_temp_file = true;
    }
    if (!ConsumeDecimalNumber(&amp;rest, &amp;ts_suffix)) {
      return false;
    }
    *number = ts_suffix;
    *type = is_temp_file ? kTempFile : kOptionsFile;
  } else {
    // Avoid strtoull() to keep filename format independent of the
    // current locale
    bool archive_dir_found = false;
    if (rest.starts_with(ARCHIVAL_DIR)) {
      if (rest.size() &lt;= ARCHIVAL_DIR.size()) {
        return false;
      }
      rest.remove_prefix(ARCHIVAL_DIR.size() + 1); // Add 1 to remove / also
      if (log_type) {
        *log_type = kArchivedLogFile;
      }
      archive_dir_found = true;
    }
    uint64_t num;
    if (!ConsumeDecimalNumber(&amp;rest, &amp;num)) {
      return false;
    }
    if (rest.size() &lt;= 1 || rest[0] != &#039;.&#039;) {
      return false;
    }
    rest.remove_prefix(1);

    Slice suffix = rest;
    if (suffix == Slice(&quot;log&quot;)) {
      *type = kLogFile;
      if (log_type &amp;&amp; !archive_dir_found) {
        *log_type = kAliveLogFile;
      }
    } else if (archive_dir_found) {
      return false; // Archive dir can contain only log files
    } else if (suffix == Slice(kRocksDbTFileExt) ||
               suffix == Slice(kLevelDbTFileExt)) {
      *type = kTableFile;
    } else if (suffix == Slice(kRocksDBBlobFileExt)) {
      *type = kBlobFile;
    } else if (suffix == Slice(kTempFileNameSuffix)) {
      *type = kTempFile;
    } else {
      return false;
    }
    *number = num;
  }
  return true;
}

Status SetCurrentFile(Env* env, const std::string&amp; dbname,
                      uint64_t descriptor_number,
                      Directory* directory_to_fsync) {
  // Remove leading &quot;dbname/&quot; and add newline to manifest file name
  std::string manifest = DescriptorFileName(dbname, descriptor_number);
  Slice contents = manifest;
  assert(contents.starts_with(dbname + &quot;/&quot;));
  contents.remove_prefix(dbname.size() + 1);
  std::string tmp = TempFileName(dbname, descriptor_number);
  Status s = WriteStringToFile(env, contents.ToString() + &quot;\n&quot;, tmp, true);
  if (s.ok()) {
    TEST_KILL_RANDOM(&quot;SetCurrentFile:0&quot;, rocksdb_kill_odds * REDUCE_ODDS2);
    s = env-&gt;RenameFile(tmp, CurrentFileName(dbname));
    TEST_KILL_RANDOM(&quot;SetCurrentFile:1&quot;, rocksdb_kill_odds * REDUCE_ODDS2);
  }
  if (s.ok()) {
    if (directory_to_fsync != nullptr) {
      s = directory_to_fsync-&gt;Fsync();
    }
  } else {
    env-&gt;DeleteFile(tmp);
  }
  return s;
}

Status SetIdentityFile(Env* env, const std::string&amp; dbname,
                       const std::string&amp; db_id) {
  std::string id;
  if (db_id.empty()) {
    id = env-&gt;GenerateUniqueId();
  } else {
    id = db_id;
  }
  assert(!id.empty());
  // Reserve the filename dbname/000000.dbtmp for the temporary identity file
  std::string tmp = TempFileName(dbname, 0);
  Status s = WriteStringToFile(env, id, tmp, true);
  if (s.ok()) {
    s = env-&gt;RenameFile(tmp, IdentityFileName(dbname));
  }
  if (!s.ok()) {
    env-&gt;DeleteFile(tmp);
  }
  return s;
}

Status SyncManifest(Env* env, const ImmutableDBOptions* db_options,
                    WritableFileWriter* file) {
  TEST_KILL_RANDOM(&quot;SyncManifest:0&quot;, rocksdb_kill_odds * REDUCE_ODDS2);
  StopWatch sw(env, db_options-&gt;statistics.get(), MANIFEST_FILE_SYNC_MICROS);
  return file-&gt;Sync(db_options-&gt;use_fsync);
}

Status GetInfoLogFiles(Env* env, const std::string&amp; db_log_dir,
                       const std::string&amp; dbname, std::string* parent_dir,
                       std::vector&lt;std::string&gt;* info_log_list) {
  assert(parent_dir != nullptr);
  assert(info_log_list != nullptr);
  uint64_t number = 0;
  FileType type = kLogFile;

  if (!db_log_dir.empty()) {
    *parent_dir = db_log_dir;
  } else {
    *parent_dir = dbname;
  }

  InfoLogPrefix info_log_prefix(!db_log_dir.empty(), dbname);

  std::vector&lt;std::string&gt; file_names;
  Status s = env-&gt;GetChildren(*parent_dir, &amp;file_names);

  if (!s.ok()) {
    return s;
  }

  for (auto&amp; f : file_names) {
    if (ParseFileName(f, &amp;number, info_log_prefix.prefix, &amp;type) &amp;&amp;
        (type == kInfoLogFile)) {
      info_log_list-&gt;push_back(f);
    }
  }
  return Status::OK();
}

}  // namespace ROCKSDB_NAMESPACE
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Ffile'>🔙 Back</a></p>