Use directory handles also on Windows

my_mkdir_open(): Create and open a directory handle on Windows
by invoking NtCreateFile().

InnoDB_backup::targetPath(): Determine the target directory path
from a HANDLE.  Yes, this is somewhat awkward, but the basic
operations such as CopyFileEx() work on file names, not file handles.
We may implement lower-level file copying / block cloning primitives
later as well as openat(2) like functionality, as part of implementing
streaming backup.

Author: dr-m

sql/handler.h

@@ -1905,7 +1905,7 @@ struct handlerton : public transaction_participant
      @return error code
      @retval 0 on success
   */
-  int (*backup_start)(THD *thd, IF_WIN(const char*,int) target);
+  int (*backup_start)(THD *thd, IF_WIN(HANDLE,int) target);
   /**
      Process a file that was collected in backup_start().
      @param thd   current session
@@ -1928,7 +1928,7 @@ struct handlerton : public transaction_participant
      @return error code
      @retval 0 on success
   */
-  int (*backup_finalize)(THD *thd, IF_WIN(const char*,int) target);
+  int (*backup_finalize)(THD *thd, IF_WIN(HANDLE,int) target);
 
   /**********************************************************************
    WSREP specific

sql/sql_backup.cc

@@ -20,13 +20,54 @@
 #include "sql_backup.h"
 #include "sql_parse.h"
 
+#ifdef _WIN32
+# include<winternl.h>
+/** Create a directory.
+@param path   path name
+@return directory handle
+@retval nullptr  on error */
+static HANDLE my_mkdir_open(const char *path) noexcept
+{
+  OBJECT_ATTRIBUTES attr;
+  UNICODE_STRING upath;
+  size_t pathlen= strlen(path);
+  upath.Length= upath.MaximumLength= 2 * pathlen;
+  upath.Buffer= static_cast<PWSTR>
+    (my_malloc(PSI_NOT_INSTRUMENTED, upath.MaximumLength, MYF(MY_WME)));
+  if (!upath.Buffer)
+    return nullptr;
+
+  uint errors= 0;
+  strconvert(&my_charset_ucs2_bin, path, pathlen, system_charset_info,
+             reinterpret_cast<char*>(upath.Buffer), upath.Length, &errors);
+  if (errors)
+  {
+    my_free(upath.Buffer);
+    errno= EINVAL;
+    return nullptr;
+  }
+
+  InitializeObjectAttributes(&attr, &upath, 0, /*dir=*/ nullptr, nullptr);
+  IO_STATUS_BLOCK io_status_block;
+  HANDLE h= nullptr;
+  if (NtCreateFile(&h, FILE_READ_DATA | SYNCHRONIZE, &attr, &io_status_block,
+                   nullptr, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
+                   FILE_CREATE,
+                   FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
+                   nullptr, 0))
+    errno= EINVAL; /* FIXME: determine a more precise error */
+  my_free(upath.Buffer);
+  return h;
+}
+#endif
+
 static my_bool backup_start(THD *thd, plugin_ref plugin, void *dst) noexcept
 {
   handlerton *hton= plugin_hton(plugin);
   if (hton->backup_start)
-    return hton->backup_start(thd,
-                              IF_WIN(static_cast<const char*>(dst),
-                                     int(reinterpret_cast<uintptr_t>(dst))));
+    return hton->backup_start
+      (thd, IF_WIN(reinterpret_cast<HANDLE>(dst),
+                   int(reinterpret_cast<uintptr_t>(dst))));
   return false;
 }
 
@@ -49,12 +90,13 @@ static my_bool backup_step(THD *thd, plugin_ref plugin, void *) noexcept
   return res != 0;
 }
 
-static my_bool backup_finalize(THD *thd, plugin_ref plugin, void *dst) noexcept
+static my_bool backup_finalize(THD *thd, plugin_ref plugin,
+                               void *dst) noexcept
 {
   handlerton *hton= plugin_hton(plugin);
   if (hton->backup_step)
     return hton->backup_finalize
-      (thd, IF_WIN(static_cast<const char*>(dst),
+      (thd, IF_WIN(reinterpret_cast<HANDLE>(dst),
                    int(reinterpret_cast<uintptr_t>(dst))));
   return 0;
 }
@@ -81,16 +123,22 @@ bool Sql_cmd_backup::execute(THD *thd)
                                     thd->variables.lock_wait_timeout))
     return true;
 
+#ifdef _WIN32
+  HANDLE dir= my_mkdir_open(target.str);
+  if (!dir)
+  {
+    my_error(EE_CANT_MKDIR, MYF(ME_BELL), target.str, errno);
+    thd->mdl_context.release_lock(mdl_request.ticket);
+    return true;
+  }
+#else
   if (my_mkdir(target.str, 0755, MYF(MY_WME)))
   {
-#ifndef _WIN32
   err_exit:
-#endif
     thd->mdl_context.release_lock(mdl_request.ticket);
     return true;
   }
 
-#ifndef _WIN32
   int dir= open(target.str, O_DIRECTORY);
   if (dir < 0)
   {
@@ -102,8 +150,7 @@ bool Sql_cmd_backup::execute(THD *thd)
   bool fail= plugin_foreach_with_mask(thd, backup_start,
                                       MYSQL_STORAGE_ENGINE_PLUGIN,
                                       PLUGIN_IS_DELETED|PLUGIN_IS_READY,
-                                      IF_WIN(const_cast<char*>(target.str),
-                                             reinterpret_cast<void*>(dir)));
+                                      IF_WIN(, reinterpret_cast<void*>)(dir));
 
   /* The backup_step may be invoked in multiple concurrent threads.
   At the time backup_end is invoked, all backup_step will have to complete. */
@@ -123,11 +170,8 @@ bool Sql_cmd_backup::execute(THD *thd)
   thd->mdl_context.release_lock(mdl_request.ticket);
   plugin_foreach_with_mask(thd, backup_finalize, MYSQL_STORAGE_ENGINE_PLUGIN,
                            PLUGIN_IS_DELETED|PLUGIN_IS_READY,
-                           IF_WIN(const_cast<char*>(target.str),
-                                  reinterpret_cast<void*>(dir)));
-#ifndef _WIN32
-  close(dir);
-#endif
+                           IF_WIN(, reinterpret_cast<void*>)(dir));
+  IF_WIN(CloseHandle(dir), close(dir));
 
   if (!fail)
     my_ok(thd);

storage/innobase/handler/backup_innodb.cc

@@ -186,8 +186,8 @@ class InnoDB_backup
   hard-linked, copied, or moved */
   std::vector<lsn_t> logs;
 
-  /** target directory name or handle */
-  IF_WIN(const char*,int) target;
+  /** target directory handle handle */
+  IF_WIN(HANDLE,int) target;
 
   /** the checkpoint from which the backup starts */
   lsn_t checkpoint;
@@ -429,15 +429,13 @@ class InnoDB_backup
         trx->start_time_micro= 0;
         /* Copy our clone of the last log until the final LSN */
 #ifdef _WIN32
-        std::string src{target};
-        src.push_back('/');
-        std::string dst{src};
+        std::string src= targetPath(), dst= src;
         src.append("ib_logfile101");
         log_sys.append_archive_name(dst, first_lsn);
         const char *s= src.c_str(), *d= dst.c_str();
-
-        if (!CopyFileExA(s, d, nullptr, nullptr, nullptr,
-                         COPY_FILE_NO_BUFFERING) ||
+        if (!CopyFileEx(s, d, nullptr, nullptr, nullptr,
+                        COPY_FILE_NO_BUFFERING) ||
+            !SetFileAttributes(s, FILE_ATTRIBUTE_NORMAL) ||
             !MoveFileEx(d, s, MOVEFILE_REPLACE_EXISTING))
         {
           my_osmaperr(GetLastError());
@@ -509,6 +507,19 @@ class InnoDB_backup
   }
 
 private:
+#ifdef _WIN32
+  /** @return the target directory path */
+  std::string targetPath() const
+  {
+    size_t dirlen=
+      GetFinalPathNameByHandle(target, 0, 0, FILE_NAME_NORMALIZED);
+    TCHAR dir[dirlen + 1];
+    ut_a(dirlen == GetFinalPathNameByHandle(target, dir, dirlen,
+                                            FILE_NAME_NORMALIZED));
+    dir[dirlen]= '\\';
+    return std::string{dir, dirlen};
+  }
+#endif
   /** Safely start backing up a tablespace file */
   static void backup_start(fil_space_t *space) noexcept
   {
@@ -537,11 +548,14 @@ class InnoDB_backup
     {
 #ifdef _WIN32
       backup_start(node->space);
-      std::string path{target};
-      path.push_back('/');
-      path.append(node->name);
-      bool ok= CopyFileExA(node->name, path.c_str(), nullptr, nullptr, nullptr,
-                           COPY_FILE_NO_BUFFERING);
+      std::string path= targetPath();
+      {
+        size_t size= path.size();
+        path.append(node->name);
+        std::replace(s.begin() + size, s.end(), '/', '\\');
+      }
+      bool ok= CopyFileEx(node->name, path.c_str(), nullptr, nullptr, nullptr,
+                          COPY_FILE_NO_BUFFERING);
       backup_stop(node->space);
       if (!ok)
       {
@@ -645,14 +659,8 @@ class InnoDB_backup
 
 #ifdef _WIN32
     const bool closed{clone && log_sys.close_file_if_at(lsn)};
-    std::string b{target};
-    if (clone)
-      b.append("/ib_logfile101");
-    else
-    {
-      b.push_back('/');
-      b.append(basename);
-    }
+    std::string b= targetPath();
+    b.append(clone ? "ib_logfile101" : basename);
     const char *destname= b.c_str();
 
     unsigned long err;
@@ -680,8 +688,8 @@ class InnoDB_backup
       b.append(basename);
       destname= b.c_str();
 
-      if (!CopyFileExA(path, destname, nullptr, nullptr, nullptr,
-                       COPY_FILE_NO_BUFFERING))
+      if (!CopyFileEx(path, destname, nullptr, nullptr, nullptr,
+                      COPY_FILE_NO_BUFFERING))
         goto fail;
     }
     else if (clone)

storage/innobase/handler/backup_innodb.h

@@ -20,7 +20,7 @@
    @return error code
    @retval 0 on success
 */
-int innodb_backup_start(THD *thd, IF_WIN(const char*,int) target) noexcept;
+int innodb_backup_start(THD *thd, IF_WIN(HANDLE,int) target) noexcept;
 
 /**
    Process a file that was collected in backup_start().
@@ -46,7 +46,7 @@ int innodb_backup_end(THD *thd, bool abort) noexcept;
    @return error code
    @retval 0 on success
 */
-int innodb_backup_finalize(THD *thd, IF_WIN(const char*,int) target) noexcept;
+int innodb_backup_finalize(THD *thd, IF_WIN(HANDLE,int) target) noexcept;
 
 /**
    Complete the first checkpoint in a new archive log file.