PXB-3034 Reduce the time the instance remains under lock

storage/innobase/fil/fil0fil.cc

@@ -519,7 +519,7 @@ class Tablespace_dirs {
 
   /** Discover tablespaces by reading the header from .ibd files.
   @return DB_SUCCESS if all goes well */
-  [[nodiscard]] dberr_t scan(bool populate_fil_cache);
+  [[nodiscard]] dberr_t scan(bool populate_fil_cache, bool is_prep_handle_ddls);
 
   /** Clear all the tablespace file data but leave the list of
   scanned directories in place. */
@@ -678,7 +678,7 @@ class Tablespace_dirs {
   @param[in]  thread_id Thread ID
   @param[out] result false in case of failure */
   void open_ibd(const Const_iter &start, const Const_iter &end,
-                size_t thread_id, bool &result);
+                size_t thread_id, bool &result, bool is_prep_handle_ddls);
 
  private:
   /** Directories scanned and the files discovered under them. */
@@ -1643,6 +1643,8 @@ class Fil_system {
   @return DB_SUCCESS if the open was successful */
   [[nodiscard]] dberr_t open_for_recovery(space_id_t space_id);
 
+  [[nodiscard]] dberr_t open_for_prepare(const std::string &path);
+
   /** This function should be called after recovery has completed.
   Check for tablespace files for which we did not see any
   MLOG_FILE_DELETE or MLOG_FILE_RENAME record. These could not
@@ -1699,8 +1701,8 @@ class Fil_system {
 
   /** Scan the directories to build the tablespace ID to file name
   mapping table. */
-  dberr_t scan(bool populate_fil_cache) {
-    return (m_dirs.scan(populate_fil_cache));
+  dberr_t scan(bool populate_fil_cache, bool is_prep_handle_ddls) {
+    return (m_dirs.scan(populate_fil_cache, is_prep_handle_ddls));
   }
 
   /** Open all known tablespaces. */
@@ -1825,7 +1827,6 @@ class Fil_system {
   void meb_name_process(char *name, space_id_t space_id, bool deleted);
 
 #endif /* UNIV_HOTBACKUP */
-
  private:
   /** Open an ibd tablespace and add it to the InnoDB data structures.
   This is similar to fil_ibd_open() except that it is used while
@@ -10190,6 +10191,22 @@ dberr_t fil_tablespace_open_for_recovery(space_id_t space_id) {
   return fil_system->open_for_recovery(space_id);
 }
 
+dberr_t Fil_system::open_for_prepare(const std::string &path) {
+  space_id_t space_id = get_tablespace_id(path);
+  fil_space_t *space;
+
+  auto status = ibd_open_for_recovery(space_id, path, space);
+
+  if (status == FIL_LOAD_DBWLR_CORRUPTION) {
+    return DB_CORRUPTION;
+  }
+  return DB_SUCCESS;
+}
+
+dberr_t fil_open_for_prepare(const std::string &path) {
+  return fil_system->open_for_prepare(path);
+}
+
 Fil_state fil_tablespace_path_equals(space_id_t space_id,
                                      const char *space_name, ulint fsp_flags,
                                      std::string old_path,
@@ -11635,7 +11652,8 @@ std::tuple<dberr_t, space_id_t> fil_open_for_xtrabackup(
 @param[in]  thread_id Thread ID
 @param[in,out]  result  result of the open */
 void Tablespace_dirs::open_ibd(const Const_iter &start, const Const_iter &end,
-                               size_t thread_id, bool &result) {
+                               size_t thread_id, bool &result,
+                               bool is_prep_handle_ddls) {
   if (!result) return;
 
   for (auto it = start; it != end; ++it) {
@@ -11647,28 +11665,37 @@ void Tablespace_dirs::open_ibd(const Const_iter &start, const Const_iter &end,
       continue;
     }
 
-    /* cannot use auto [err, space_id] = fil_open_for_xtrabackup() as space_id
-    is unused here and we get unused variable error during compilation */
-    dberr_t err;
-    std::tie(err, std::ignore) = fil_open_for_xtrabackup(
-        phy_filename, filename.substr(0, filename.length() - 4));
-
-    /* Allow deleted tables between disovery and file open when
-     LOCK_DDL_REDUCED, they will be handled by ddl_tracker */
-    if (err == DB_CANNOT_OPEN_FILE && opt_lock_ddl == LOCK_DDL_REDUCED) {
-      ddl_tracker->add_missing_table(phy_filename);
-    } else if (err == DB_TABLESPACE_EXISTS &&
-               opt_lock_ddl == LOCK_DDL_REDUCED) {
-      /* table was renamed during scan. Since original table was loaded to cache
-      and rename ddl will be handled by ddl_tracker we skip loading
-      duplicate tablespace */
-      continue;
-    } else
-      /* PXB-2275 - Allow DB_INVALID_ENCRYPTION_META as we will test it in
-      the end of the backup */
-      if (err != DB_SUCCESS && err != DB_INVALID_ENCRYPTION_META) {
+    /* when processing ddl files on prepare phase we should load data files
+    without first page validation */
+    if (is_prep_handle_ddls) {
+      dberr_t err = fil_open_for_prepare(phy_filename);
+      if (err != DB_SUCCESS) {
         result = false;
       }
+    } else {
+      /* cannot use auto [err, space_id] = fil_open_for_xtrabackup() as space_id
+      is unused here and we get unused variable error during compilation */
+      dberr_t err;
+      std::tie(err, std::ignore) = fil_open_for_xtrabackup(
+          phy_filename, filename.substr(0, filename.length() - 4));
+
+      /* Allow deleted tables between disovery and file open when
+      LOCK_DDL_REDUCED, they will be handled by ddl_tracker */
+      if (err == DB_CANNOT_OPEN_FILE && opt_lock_ddl == LOCK_DDL_REDUCED) {
+        ddl_tracker->add_missing_table(phy_filename);
+      } else if (err == DB_TABLESPACE_EXISTS &&
+                 opt_lock_ddl == LOCK_DDL_REDUCED) {
+        /* table was renamed during scan. Since original table was loaded to
+        cache and rename ddl will be handled by ddl_tracker we skip loading
+        duplicate tablespace */
+        continue;
+      } else
+        /* PXB-2275 - Allow DB_INVALID_ENCRYPTION_META as we will test it in
+        the end of the backup */
+        if (err != DB_SUCCESS && err != DB_INVALID_ENCRYPTION_META) {
+          result = false;
+        }
+    }
   }
 }
 
@@ -11939,7 +11966,8 @@ void Tablespace_dirs::set_scan_dirs(const std::string &in_directories) {
 /** Discover tablespaces by reading the header from .ibd files.
 @param[in]      in_directories  Directories to scan
 @return DB_SUCCESS if all goes well */
-dberr_t Tablespace_dirs::scan(bool populate_fil_cache) {
+dberr_t Tablespace_dirs::scan(bool populate_fil_cache,
+                              bool is_prep_handle_ddls) {
   Scanned_files ibd_files;
   Scanned_files undo_files;
   uint16_t count = 0;
@@ -12055,10 +12083,12 @@ dberr_t Tablespace_dirs::scan(bool populate_fil_cache) {
 
   if (err == DB_SUCCESS && populate_fil_cache) {
     bool result = true;
-    std::function<void(const Const_iter &, const Const_iter &, size_t, bool &)>
-        open = std::bind(&Tablespace_dirs::open_ibd, this, _1, _2, _3, _4);
+    std::function<void(const Const_iter &, const Const_iter &, size_t, bool &,
+                       bool)>
+        open = std::bind(&Tablespace_dirs::open_ibd, this, _1, _2, _3, _4, _5);
 
-    par_for(PFS_NOT_INSTRUMENTED, ibd_files, n_threads, open, result);
+    par_for(PFS_NOT_INSTRUMENTED, ibd_files, n_threads, open, result,
+            is_prep_handle_ddls);
 
     if (!result) err = DB_FAIL;
   }
@@ -12077,8 +12107,9 @@ void fil_set_scan_dirs(const std::string &directories) {
 /** Discover tablespaces by reading the header from .ibd files.
 @param[in]  populate_fil_cache Whether to load tablespaces into fil cache
 @return DB_SUCCESS if all goes well */
-dberr_t fil_scan_for_tablespaces(bool populate_fil_cache) {
-  return (fil_system->scan(populate_fil_cache));
+dberr_t fil_scan_for_tablespaces(bool populate_fil_cache,
+                                 bool is_prep_handle_ddls) {
+  return (fil_system->scan(populate_fil_cache, is_prep_handle_ddls));
 }
 
 /** Open all known tablespaces. */

storage/innobase/include/fil0fil.h

@@ -2241,15 +2241,20 @@ void fil_set_scan_dirs(const std::string &directories);
 
 /** Discover tablespaces by reading the header from .ibd files.
 @param[in]  populate_fil_cache Whether to load tablespaces into fil cache
+@param[in]  is_prep_handle_ddls Whether loading tablespaces on prepare phase
+                                to handle the ddls
 @return DB_SUCCESS if all goes well */
-dberr_t fil_scan_for_tablespaces(bool populate_fil_cache);
+dberr_t fil_scan_for_tablespaces(bool populate_fil_cache,
+                                 bool is_prep_handle_ddls);
 
 /** Open the tablespace and also get the tablespace filenames, space_id must
 already be known.
 @param[in]  space_id  Tablespace ID to lookup
 @return DB_SUCCESS if open was successful */
 [[nodiscard]] dberr_t fil_tablespace_open_for_recovery(space_id_t space_id);
 
+dberr_t fil_open_for_prepare(const std::string &path);
+
 /** Replay a file rename operation for ddl replay.
 @param[in]      page_id         Space ID and first page number in the file
 @param[in]      old_name        old file name

storage/innobase/os/os0enc.cc

@@ -662,7 +662,9 @@ bool Encryption::decode_encryption_info(space_id_t space_id,
     encryption info maybe hasn't written into datafile when
     the table is newly created. For clone encryption information
     should have been already correct. */
-    return (recv_recovery_is_on() ? true : false);
+    bool prep_lock_ddl_reduced =
+        !srv_backup_mode && opt_lock_ddl == LOCK_DDL_REDUCED;
+    return (recv_recovery_is_on() || prep_lock_ddl_reduced ? true : false);
   } else {
     ib::error(ER_IB_MSG_837) << "Failed to decrypt encryption information,"
                              << " found unexpected version of it!";

storage/innobase/srv/srv0start.cc

@@ -1782,7 +1782,7 @@ dberr_t srv_start(bool create_new_db IF_XB(, lsn_t to_lsn)) {
     return (srv_init_abort(err));
   }
 
-  err = fil_scan_for_tablespaces(false);
+  err = fil_scan_for_tablespaces(false, false);
 
   if (err != DB_SUCCESS) {
     return (srv_init_abort(err));

storage/innobase/xtrabackup/src/xtrabackup.cc

@@ -2465,7 +2465,7 @@ static bool innodb_init_param(void) {
   return (true);
 }
 
-static void xb_scan_for_tablespaces() {
+static void xb_scan_for_tablespaces(bool is_prep_handle_ddls) {
   /* This is the default directory for IBD and IBU files. Put it first
   in the list of known directories. */
   fil_set_scan_dir(MySQL_datadir_path.path());
@@ -2484,7 +2484,7 @@ static void xb_scan_for_tablespaces() {
   --innodb-undo-directory also. */
   fil_set_scan_dir(Fil_path::remove_quotes(MySQL_undo_path), true);
 
-  if (fil_scan_for_tablespaces(true) != DB_SUCCESS) {
+  if (fil_scan_for_tablespaces(true, is_prep_handle_ddls) != DB_SUCCESS) {
     exit(EXIT_FAILURE);
   }
 }
@@ -3611,7 +3611,7 @@ static dberr_t xb_load_tablespaces(bool is_prep_handle_ddls)
   }
 
   xb::info() << "Generating a list of tablespaces";
-  xb_scan_for_tablespaces();
+  xb_scan_for_tablespaces(is_prep_handle_ddls);
 
   /* Add separate undo tablespaces to fil_system */
 
@@ -3625,8 +3625,7 @@ static dberr_t xb_load_tablespaces(bool is_prep_handle_ddls)
     /* when processing ddl files on prepare phase we should load data files
     without first page validation */
     if (is_prep_handle_ddls) {
-      space_id_t space_id = fil_get_tablespace_id(tablespace.file_name);
-      dberr_t err = fil_tablespace_open_for_recovery(space_id);
+      dberr_t err = fil_open_for_prepare(tablespace.file_name);
       if (err != DB_SUCCESS) {
         return (err);
       }