Import wiredtiger: 99698d7a8bd6ea4e15a6c4da5cfecb6f169daba9 from branch mongodb-master

ref: 3d54dd43fb..99698d7a8b
for: 7.2.0-rc0

WT-11721 Chunk cache metadata file management

Author: ruby-oujo

src/third_party/wiredtiger/dist/s_string.ok

@@ -424,6 +424,7 @@ WideCharToMultiByte
 WinNT
 WiredTiger
 WiredTiger's
+WiredTigerCC
 WiredTigerCheckpoint
 WiredTigerChunkCache
 WiredTigerHS

src/third_party/wiredtiger/import.data

@@ -2,5 +2,5 @@
     "vendor": "wiredtiger",
     "github": "wiredtiger/wiredtiger.git",
     "branch": "mongodb-master",
-    "commit": "3d54dd43fb29870da49300bf1777f98e83791619"
+    "commit": "99698d7a8bd6ea4e15a6c4da5cfecb6f169daba9"
 }

src/third_party/wiredtiger/src/block/block_open.c

@@ -328,6 +328,17 @@ __wt_desc_write(WT_SESSION_IMPL *session, WT_FH *fh, uint32_t allocsize)
     return (ret);
 }
 
+/*
+ * __file_is_wt_internal --
+ *     Check if a filename is one used by WiredTiger internal files.
+ */
+static bool
+__file_is_wt_internal(const char *name)
+{
+    return (strcmp(name, WT_METAFILE) == 0 || strcmp(name, WT_HS_FILE) == 0 ||
+      strcmp(name, WT_CC_METAFILE) == 0);
+}
+
 /*
  * __desc_read --
  *     Read and verify the file's metadata.
@@ -404,7 +415,7 @@ __desc_read(WT_SESSION_IMPL *session, uint32_t allocsize, WT_BLOCK *block)
      * file name, and is now frantically pounding their interrupt key.
      */
     if (desc->magic != WT_BLOCK_MAGIC || !checksum_matched) {
-        if (strcmp(block->name, WT_METAFILE) == 0 || strcmp(block->name, WT_HS_FILE) == 0)
+        if (__file_is_wt_internal(block->name))
             WT_ERR_MSG(session, WT_TRY_SALVAGE,
               "%s is corrupted: calculated block checksum of %#" PRIx32
               " doesn't match expected checksum of %#" PRIx32,

src/third_party/wiredtiger/src/block_cache/block_chunkcache.c

@@ -20,6 +20,75 @@
 #define WT_CHUNK_OFFSET(chunkcache, offset) \
     (wt_off_t)(((size_t)offset / (chunkcache)->chunk_size) * (chunkcache)->chunk_size)
 
+/*
+ * __chunkcache_create_metadata_file --
+ *     Create the table that will persistently track what chunk cache content is on disk.
+ */
+static int
+__chunkcache_create_metadata_file(
+  WT_SESSION_IMPL *session, uint64_t capacity, unsigned int hashtable_size, size_t chunk_size)
+{
+    char cfg[128];
+    WT_RET(__wt_snprintf(cfg, sizeof(cfg),
+      WT_CC_APP_META_FORMAT ",key_format=" WT_CC_KEY_FORMAT ",value_format=" WT_CC_VALUE_FORMAT,
+      capacity, hashtable_size, chunk_size));
+
+    return (__wt_session_create(session, WT_CC_METAFILE_URI, cfg));
+}
+
+/*
+ * __chunkcache_get_metadata_config --
+ *     If present, retrieve the on-disk configuration for the chunk cache metadata file. The caller
+ *     must only use *config if *found is true. The caller is responsible for freeing the memory
+ *     allocated into *config.
+ */
+static int
+__chunkcache_get_metadata_config(WT_SESSION_IMPL *session, char **config)
+{
+    WT_CURSOR *cursor;
+    WT_DECL_RET;
+    char *tmp;
+
+    *config = NULL;
+
+    WT_RET(__wt_metadata_cursor(session, &cursor));
+    cursor->set_key(cursor, WT_CC_METAFILE_URI);
+    WT_ERR(cursor->search(cursor));
+
+    WT_ERR(cursor->get_value(cursor, &tmp));
+    WT_ERR(__wt_strdup(session, tmp, config));
+
+err:
+    WT_TRET(__wt_metadata_cursor_release(session, &cursor));
+    return (ret);
+}
+
+/*
+ * __chunkcache_verify_metadata_config --
+ *     Check that the existing chunk cache configuration is compatible with our current
+ *     configuration (and ergo, whether we can reuse the chunk cache contents).
+ */
+static int
+__chunkcache_verify_metadata_config(WT_SESSION_IMPL *session, char *md_config, uint64_t capacity,
+  unsigned int hashtable_size, size_t chunk_size)
+{
+    WT_DECL_RET;
+    char tmp[128];
+
+    WT_RET(
+      __wt_snprintf(tmp, sizeof(tmp), WT_CC_APP_META_FORMAT, capacity, hashtable_size, chunk_size));
+
+    if (strstr(md_config, tmp) == NULL) {
+        __wt_verbose_error(session, WT_VERB_CHUNKCACHE,
+          "stored chunk cache config (%s) incompatible with runtime config (%s)", md_config, tmp);
+        ret = -1;
+    }
+
+    /* FIXME-WT-11723 Open the underlying table just to verify it exists. */
+
+    return (ret);
+}
+
 /*
  * __chunkcache_bitmap_find_free --
  *     Iterate through the bitmap to find a free chunk in the cache.
@@ -903,12 +972,13 @@ __wt_chunkcache_setup(WT_SESSION_IMPL *session, const char *cfg[])
     WT_CONFIG_ITEM cval;
     WT_DECL_RET;
     unsigned int cnt, i;
-    char **pinned_objects;
+    char *metadata_config, **pinned_objects;
     size_t mapped_size;
 
     chunkcache = &S2C(session)->chunkcache;
-    pinned_objects = NULL;
     cnt = 0;
+    metadata_config = NULL;
+    pinned_objects = NULL;
 
     if (F_ISSET(chunkcache, WT_CHUNKCACHE_CONFIGURED))
         WT_RET_MSG(session, EINVAL, "chunk cache setup requested, but cache is already configured");
@@ -969,6 +1039,21 @@ __wt_chunkcache_setup(WT_SESSION_IMPL *session, const char *cfg[])
         WT_RET(__wt_calloc(session,
           WT_CHUNKCACHE_BITMAP_SIZE(chunkcache->capacity, chunkcache->chunk_size), sizeof(uint8_t),
           &chunkcache->free_bitmap));
+
+        /* Retrieve the chunk cache metadata config, and ensure it matches our startup config. */
+        ret = __chunkcache_get_metadata_config(session, &metadata_config);
+        if (ret == WT_NOTFOUND) {
+            WT_RET(__chunkcache_create_metadata_file(
+              session, chunkcache->capacity, chunkcache->hashtable_size, chunkcache->chunk_size));
+            __wt_verbose(session, WT_VERB_CHUNKCACHE, "%s", "created chunkcache metadata file");
+        } else if (ret == 0) {
+            WT_RET(__chunkcache_verify_metadata_config(session, metadata_config,
+              chunkcache->capacity, chunkcache->hashtable_size, chunkcache->chunk_size));
+            __wt_verbose(session, WT_VERB_CHUNKCACHE, "%s", "reused chunkcache metadata file");
+        } else {
+            WT_RET(ret);
+        }
+        __wt_free(session, metadata_config);
     }
 
     WT_RET(__wt_config_gets(session, cfg, "chunk_cache.flushed_data_cache_insertion", &cval));
@@ -1032,6 +1117,28 @@ __wt_chunkcache_teardown(WT_SESSION_IMPL *session)
     return (ret);
 }
 
+/*
+ * __wt_chunkcache_salvage --
+ *     Remove any knowledge of any extant chunk cache metadata. We can always rebuild the cache
+ *     later, so make no attempt at a "real" salvage.
+ */
+int
+__wt_chunkcache_salvage(WT_SESSION_IMPL *session)
+{
+    WT_DECL_RET;
+    const char *drop_cfg[] = {WT_CONFIG_BASE(session, WT_SESSION_drop), NULL};
+
+    /* Check that we're holding the schema lock (or take it) before doing a schema operation. */
+    if (FLD_ISSET(session->lock_flags, WT_SESSION_LOCKED_SCHEMA))
+        ret = __wt_schema_drop(session, WT_CC_METAFILE_URI, drop_cfg);
+    else
+        WT_WITH_SCHEMA_LOCK(session, ret = __wt_schema_drop(session, WT_CC_METAFILE_URI, drop_cfg));
+
+    if (ret == ENOENT)
+        return (0);
+    return (ret);
+}
+
 #ifdef HAVE_UNITTEST
 
 int

src/third_party/wiredtiger/src/conn/conn_api.c

@@ -2946,7 +2946,6 @@ wiredtiger_open(const char *home, WT_EVENT_HANDLER *event_handler, const char *c
     WT_ERR(__wt_verbose_config(session, cfg, false));
     WT_ERR(__wt_timing_stress_config(session, cfg));
     WT_ERR(__wt_blkcache_setup(session, cfg, false));
-    WT_ERR(__wt_chunkcache_setup(session, cfg));
     WT_ERR(__wt_extra_diagnostics_config(session, cfg));
     WT_ERR(__wt_conn_optrack_setup(session, cfg, false));
     WT_ERR(__conn_session_size(session, cfg, &conn->session_size));
@@ -3156,6 +3155,9 @@ wiredtiger_open(const char *home, WT_EVENT_HANDLER *event_handler, const char *c
         wt_session = &session->iface;
         WT_ERR(__wt_copy_and_sync(wt_session, WT_METAFILE, WT_METAFILE_SLVG));
         WT_ERR(wt_session->salvage(wt_session, WT_METAFILE_URI, NULL));
+
+        /* Now that the metadata is usable, see if we need to erase the chunk cache. */
+        WT_ERR(__wt_chunkcache_salvage(session));
     }
 
     /* Initialize connection values from stored metadata. */

src/third_party/wiredtiger/src/conn/conn_open.c

@@ -227,6 +227,9 @@ __wt_connection_workers(WT_SESSION_IMPL *session, const char *cfg[])
     /* Initialize metadata tracking, required before creating tables. */
     WT_RET(__wt_meta_track_init(session));
 
+    /* Can create a table, so must be done after metadata tracking. */
+    WT_RET(__wt_chunkcache_setup(session, cfg));
+
     /*
      * Create the history store file. This will only actually create it on a clean upgrade or when
      * creating a new database.

src/third_party/wiredtiger/src/include/block_chunkcache.h

@@ -8,6 +8,11 @@
 
 /* WiredTiger's chunk cache. Locally caches chunks of remote objects. */
 
+#define WT_CC_KEY_FORMAT WT_UNCHECKED_STRING(SLq)
+#define WT_CC_VALUE_FORMAT WT_UNCHECKED_STRING(QQ)
+#define WT_CC_APP_META_FORMAT \
+    "app_metadata=\"version=1,capacity=%" PRIu64 ",buckets=%u,chunk_size=%" WT_SIZET_FMT "\""
+
 struct __wt_chunkcache_hashid {
     const char *objectname;
     uint32_t objectid;

src/third_party/wiredtiger/src/include/extern.h

@@ -411,6 +411,8 @@ extern int __wt_chunkcache_reconfig(WT_SESSION_IMPL *session, const char **cfg)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_chunkcache_remove(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t objectid,
   wt_off_t offset, uint32_t size) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_chunkcache_salvage(WT_SESSION_IMPL *session)
+  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_chunkcache_setup(WT_SESSION_IMPL *session, const char *cfg[])
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_chunkcache_teardown(WT_SESSION_IMPL *session)

src/third_party/wiredtiger/src/include/meta.h

@@ -34,6 +34,9 @@
 #define WT_HS_FILE "WiredTigerHS.wt"     /* History store table */
 #define WT_HS_URI "file:WiredTigerHS.wt" /* History store table URI */
 
+#define WT_CC_METAFILE "WiredTigerCC.wt"          /* Chunk cache metadata table */
+#define WT_CC_METAFILE_URI "file:WiredTigerCC.wt" /* Chunk cache metadata table URI */
+
 #define WT_SYSTEM_PREFIX "system:"                               /* System URI prefix */
 #define WT_SYSTEM_CKPT_TS "checkpoint_timestamp"                 /* Checkpoint timestamp name */
 #define WT_SYSTEM_CKPT_URI "system:checkpoint"                   /* Checkpoint timestamp URI */