Merge branch 'mysql-8.4' into mysql-trunk

Author: Vidhya Sree Rajuladevi

storage/innobase/fil/fil0fil.cc

@@ -328,9 +328,6 @@ enum fil_operation_t {
 /** The null file address */
 fil_addr_t fil_addr_null = {FIL_NULL, 0};
 
-/** Maximum number of pages to read to determine the space ID. */
-static const size_t MAX_PAGES_TO_READ = 1;
-
 #ifndef UNIV_HOTBACKUP
 /** Maximum number of shards supported. */
 static const size_t MAX_SHARDS = 68;
@@ -1627,9 +1624,12 @@ class Fil_system {
   mapping table. */
   dberr_t scan() { return m_dirs.scan(); }
 
-  /** Get the tablespace ID from an .ibd and/or an undo tablespace. If the ID is
-  0 on the first page then try finding the ID with Datafile::find_space_id().
-  @param[in]    filename        File name to check
+  /** Get the tablespace ID from an .ibd and/or an undo tablespace. If the
+  read failed or the ID is 0 on the first page or there is a mismatch of
+  space_ids stored in FSP_SPACE_ID and FIL_PAGE_SPACE_ID, then try finding
+  the ID with Datafile::find_space_id(). This function should only be called
+  during server startup.
+  @param[in]      filename        File name to check
   @return s_invalid_space_id if not found, otherwise the space ID */
   [[nodiscard]] static space_id_t get_tablespace_id(
       const std::string &filename);
@@ -10954,116 +10954,62 @@ static bool fil_op_replay_rename(const page_id_t &page_id,
   return true;
 }
 
-/** Get the tablespace ID from an .ibd and/or an undo tablespace. If the ID is 0
-on the first page then try finding the ID with Datafile::find_space_id().
-@param[in]      filename        File name to check
-@return s_invalid_space_id if not found, otherwise the space ID */
 space_id_t Fil_system::get_tablespace_id(const std::string &filename) {
-  FILE *fp = fopen(filename.c_str(), "rb");
-
-  if (fp == nullptr) {
-    ib::warn(ER_IB_MSG_372) << "Unable to open '" << filename << "'";
-    return dict_sys_t::s_invalid_space_id;
-  }
+  constexpr size_t read_size = UNIV_SECTOR_SIZE;
+  pfs_os_file_t file;
+  bool success;
 
-  std::vector<space_id_t> space_ids;
-  auto page_size = srv_page_size;
+  /* Lambda function for heavy-duty method of finding the space id from
+  Datafile::find_space_id() which we fallback into, if the first page
+  cannot be read properly. */
+  const auto find_space_id_reliably = [&filename]() -> space_id_t {
+    Datafile data_file;
 
-  space_ids.reserve(MAX_PAGES_TO_READ);
+    data_file.set_filepath(filename.c_str());
+    const dberr_t err = data_file.open_read_only(false);
 
-  const auto n_bytes = page_size * MAX_PAGES_TO_READ;
+    ut_a(data_file.is_open());
+    ut_a(err == DB_SUCCESS);
 
-  std::unique_ptr<byte[]> buf(new byte[n_bytes]);
+    /* Use the heavier Datafile::find_space_id() method to find the space id. */
+    return (data_file.find_space_id() == DB_SUCCESS)
+               ? data_file.space_id()
+               : dict_sys_t::s_invalid_space_id;
+  };
 
-  if (!buf) {
+  /* Open the file with O_DIRECT flag for faster access */
+  file = os_file_create(innodb_data_file_key, filename.c_str(), OS_FILE_OPEN,
+                        OS_DATA_FILE_FOR_SPACE_ID_READ, true, &success);
+  if (!success) {
+    os_file_get_last_error(true);
+    ib::warn(ER_IB_MSG_372) << "Unable to open '" << filename << "'";
     return dict_sys_t::s_invalid_space_id;
   }
 
-  auto pages_read = fread(buf.get(), page_size, MAX_PAGES_TO_READ, fp);
-
-  DBUG_EXECUTE_IF("invalid_header", pages_read = 0;);
-
-  /* Find the space id from the pages read if enough pages could be read.
-  Fall back to the more heavier method of finding the space id from
-  Datafile::find_space_id() if pages cannot be read properly. */
-  if (pages_read >= MAX_PAGES_TO_READ) {
-    auto bytes_read = pages_read * page_size;
-
-#ifdef POSIX_FADV_DONTNEED
-    posix_fadvise(fileno(fp), 0, bytes_read, POSIX_FADV_DONTNEED);
-#endif /* POSIX_FADV_DONTNEED */
-
-    for (page_no_t i = 0; i < MAX_PAGES_TO_READ; ++i) {
-      const auto off = i * page_size + FIL_PAGE_SPACE_ID;
-
-      if (off == FIL_PAGE_SPACE_ID) {
-        /* Find out the page size of the tablespace from the first page.
-        In case of compressed pages, the subsequent pages can be of different
-        sizes. If MAX_PAGES_TO_READ is changed to a different value, then the
-        page size of subsequent pages is needed to find out the offset for
-        space ID. */
-
-        auto space_flags_offset = FSP_HEADER_OFFSET + FSP_SPACE_FLAGS;
-
-        ut_a(space_flags_offset + 4 < n_bytes);
-
-        const auto flags = mach_read_from_4(buf.get() + space_flags_offset);
-
-        page_size_t space_page_size(flags);
-
-        page_size = space_page_size.physical();
-      }
-
-      space_ids.push_back(mach_read_from_4(buf.get() + off));
+  space_id_t space_id = dict_sys_t::s_invalid_space_id;
 
-      if ((i + 1) * page_size >= bytes_read) {
-        break;
-      }
-    }
-  }
+  auto buf = ut::make_unique_aligned<byte[]>(read_size, read_size);
 
-  fclose(fp);
+  IORequest request(IORequest::READ);
+  ulint bytes_read = 0;
 
-  space_id_t space_id;
+  dberr_t err = os_file_read_no_error_handling(
+      request, filename.c_str(), file, buf.get(), 0, read_size, &bytes_read);
 
-  if (!space_ids.empty()) {
-    space_id = space_ids.front();
+  os_file_close(file);
 
-    for (auto id : space_ids) {
-      if (id == 0 || space_id != id) {
-        space_id = UINT32_UNDEFINED;
+  DBUG_EXECUTE_IF("invalid_header", bytes_read = 0;);
 
-        break;
-      }
-    }
-  } else {
-    space_id = UINT32_UNDEFINED;
+  if (err != DB_SUCCESS || (bytes_read != read_size)) {
+    /* Reading from the first page failed, falling back to heavy duty method */
+    return find_space_id_reliably();
   }
 
-  /* Try the more heavy duty method, as a last resort. */
-  if (space_id == UINT32_UNDEFINED) {
-    /* If the first page cannot be read properly, then for compressed
-    tablespaces we don't know where the page boundary starts because
-    we don't know the page size. */
-
-    Datafile file;
-
-    file.set_filepath(filename.c_str());
-
-    dberr_t err = file.open_read_only(false);
-
-    ut_a(file.is_open());
-    ut_a(err == DB_SUCCESS);
-
-    /* Use the heavier Datafile::find_space_id() method to
-    find the space id. */
-    err = file.find_space_id();
-
-    if (err == DB_SUCCESS) {
-      space_id = file.space_id();
-    }
+  /* Read the space_id from buf at offset FIL_PAGE_SPACE_ID */
+  space_id = fsp_header_get_space_id(buf.get());
 
-    file.close();
+  if (space_id == 0 || space_id == SPACE_UNKNOWN) {
+    return find_space_id_reliably();
   }
 
   return space_id;

storage/innobase/include/os0file.h

@@ -231,6 +231,7 @@ static const ulint OS_BUFFERED_FILE = 103;
 static const ulint OS_CLONE_DATA_FILE = 104;
 static const ulint OS_CLONE_LOG_FILE = 105;
 static const ulint OS_DBLWR_FILE = 106;
+static const ulint OS_DATA_FILE_FOR_SPACE_ID_READ = 107;
 /** @} */
 
 /** Error codes from os_file_get_last_error @{ */
@@ -736,10 +737,12 @@ MY_COMPILER_DIAGNOSTIC_POP()
 @param[in]      fd              file descriptor to alter
 @param[in]      file_name       file name, used in the diagnostic message
 @param[in]      operation_name  "open" or "create"; used in the diagnostic
-                                message */
+                                message
+@param[in]      on_error_silent if true then don't print any message to the log
+*/
 void os_file_set_nocache(int fd, const char *file_name,
-                         const char *operation_name);
-
+                         const char *operation_name,
+                         bool on_error_silent = false);
 /** NOTE! Use the corresponding macro os_file_create(), not directly
 this function!
 Opens an existing file or creates a new.
@@ -1237,6 +1240,7 @@ static inline bool pfs_os_file_delete_if_exists_func(mysql_pfs_key_t key,
 
 /* If UNIV_PFS_IO is not defined, these I/O APIs point
 to original un-instrumented file I/O APIs */
+
 #define os_file_create(key, name, create, purpose, read_only, success) \
   os_file_create_func(name, create, purpose, read_only, success)
 

storage/innobase/os/os0file.cc

@@ -105,6 +105,12 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 #include <data0type.h>
 #endif /* UNIV_HOTBACKUP */
 
+#ifndef _WIN32
+static_assert(OS_FILE_CLOSED == -1,
+              "Our implementation for OSes other than Windows assumes an "
+              "invalid handle is indicated by -1");
+#endif
+
 /* Flush after each os_fsync_threshold bytes */
 unsigned long long os_fsync_threshold = 0;
 
@@ -3152,7 +3158,7 @@ pfs_os_file_t os_file_create_func(const char *name, ulint create_mode,
   ut_a(purpose == OS_LOG_FILE || purpose == OS_LOG_FILE_RESIZING ||
        purpose == OS_DATA_FILE || purpose == OS_DBLWR_FILE ||
        purpose == OS_CLONE_DATA_FILE || purpose == OS_CLONE_LOG_FILE ||
-       purpose == OS_BUFFERED_FILE);
+       purpose == OS_BUFFERED_FILE || OS_DATA_FILE_FOR_SPACE_ID_READ);
 
 #ifdef O_SYNC
   /* We let O_SYNC only affect log files; note that we map O_DSYNC to
@@ -3190,19 +3196,38 @@ pfs_os_file_t os_file_create_func(const char *name, ulint create_mode,
 
   } while (retry);
 
-  /* We disable OS caching (O_DIRECT) only on data files. For clone we
-  need to set O_DIRECT even for read_only mode. */
+  if (!*success) {
+    ut_a(file.m_file == OS_FILE_CLOSED);
+    return file;
+  }
+
+  bool use_odirect = false;
 
-  if ((!read_only || purpose == OS_CLONE_DATA_FILE) && *success &&
+  if ((!read_only || purpose == OS_CLONE_DATA_FILE) &&
       (purpose == OS_DATA_FILE || purpose == OS_CLONE_DATA_FILE ||
        purpose == OS_DBLWR_FILE) &&
       (srv_unix_file_flush_method == SRV_UNIX_O_DIRECT ||
        srv_unix_file_flush_method == SRV_UNIX_O_DIRECT_NO_FSYNC)) {
-    os_file_set_nocache(file.m_file, name, mode_str);
+    use_odirect = true;
+  }
+
+  /* We also set O_DIRECT for files which are opened at startup to
+  read their space ID from the page header */
+  if (purpose == OS_DATA_FILE_FOR_SPACE_ID_READ) {
+    use_odirect = true;
+  }
+
+  if (use_odirect) {
+    /* Flag for executing os_file_set_nocache() without printing error
+    messages */
+    const bool on_error_silent_for_nocache =
+        (purpose == OS_DATA_FILE_FOR_SPACE_ID_READ);
+    os_file_set_nocache(file.m_file, name, mode_str,
+                        on_error_silent_for_nocache);
   }
 
 #ifdef USE_FILE_LOCK
-  if (!read_only && *success && create_mode != OS_FILE_OPEN_RAW &&
+  if (!read_only && create_mode != OS_FILE_OPEN_RAW &&
       /* Don't acquire file lock while cloning files. */
       purpose != OS_CLONE_DATA_FILE && purpose != OS_CLONE_LOG_FILE &&
       os_file_lock(file.m_file, name)) {
@@ -4129,7 +4154,12 @@ pfs_os_file_t os_file_create_func(const char *name, ulint create_mode,
     /* Do not use unbuffered i/o for the log files because
     we write really a lot and we have log flusher for fsyncs. */
 
-  } else if (srv_win_file_flush_method == SRV_WIN_IO_UNBUFFERED) {
+  } else if (srv_win_file_flush_method == SRV_WIN_IO_UNBUFFERED ||
+             purpose == OS_DATA_FILE_FOR_SPACE_ID_READ) {
+    /* We use unbuffered access only when allowed by the
+    'srv_win_file_flush_method', unless the purpose is
+    to read the space ID on the startup, in which case
+    we should always use the unbuffered access */
     attributes |= FILE_FLAG_NO_BUFFERING;
   }
 #endif /* UNIV_NON_BUFFERED_IO */
@@ -5257,10 +5287,11 @@ static bool os_file_handle_error_no_exit(const char *name,
 
 void os_file_set_nocache(int fd [[maybe_unused]],
                          const char *file_name [[maybe_unused]],
-                         const char *operation_name [[maybe_unused]]) {
+                         const char *operation_name [[maybe_unused]],
+                         bool on_error_silent [[maybe_unused]]) {
 /* some versions of Solaris may not have DIRECTIO_ON */
 #if defined(UNIV_SOLARIS) && defined(DIRECTIO_ON)
-  if (directio(fd, DIRECTIO_ON) == -1) {
+  if (directio(fd, DIRECTIO_ON) == -1 && !on_error_silent) {
     int errno_save = errno;
 
     ib::error(ER_IB_MSG_823)
@@ -5270,7 +5301,7 @@ void os_file_set_nocache(int fd [[maybe_unused]],
            " continuing anyway.";
   }
 #elif defined(O_DIRECT)
-  if (fcntl(fd, F_SETFL, O_DIRECT) == -1) {
+  if (fcntl(fd, F_SETFL, O_DIRECT) == -1 && !on_error_silent) {
     int errno_save = errno;
     static bool warning_message_printed = false;
     if (errno_save == EINVAL) {