squash! 0c52540

backup_target: A structured data type to represent a directory or a
stream. On Microsoft Windows, we must use directory paths because
there is no variant of CopyFileEx() that would work on file handles.

copy_file(): A file copying service for POSIX systems. On Windows,
we will use CopyFileEx().

Author: dr-m

sql/handler.h

@@ -1496,6 +1496,27 @@ struct transaction_participant
   ulonglong (*prepare_commit_versioned)(THD *thd, ulonglong *trx_id);
 };
 
+/** BACKUP SERVER target */
+struct backup_target
+{
+#ifdef _WIN32
+  /** Target directory path name */
+  const char *path;
+  union
+  {
+    /** Target pipe, if path==reinterpret_cast<const char*>(-1) */
+    HANDLE pipe;
+    /** Target socket, if path==nullptr */
+    SOCKET socket;
+  };
+#else
+  /** Target file descriptor */
+  int fd;
+  /** whether the fd is a directory handle */
+  bool directory;
+#endif
+};
+
 /*
   handlerton is a singleton structure - one instance per storage engine -
   to provide access to storage engine functionality that works on the
@@ -1901,11 +1922,11 @@ struct handlerton : public transaction_participant
   /**
      Start of BACKUP SERVER: collect all files to be backed up
      @param thd     current session
-     @param target  target directory
+     @param target  backup target
      @return error code
      @retval 0 on success
   */
-  int (*backup_start)(THD *thd, IF_WIN(const char*,int) target);
+  int (*backup_start)(THD *thd, backup_target target);
   /**
      Process a file that was collected in backup_start().
      @param thd   current session
@@ -1924,11 +1945,11 @@ struct handlerton : public transaction_participant
   /**
      Clean up after any backup_end().
      @param thd     the parameter on which backup_end() was invoked
-     @param target  target directory
+     @param target  backup target
      @return error code
      @retval 0 on success
   */
-  int (*backup_finalize)(THD *thd, IF_WIN(const char*,int) target);
+  int (*backup_finalize)(THD *thd, backup_target target);
 
   /**********************************************************************
    WSREP specific

sql/sql_backup.cc

@@ -18,15 +18,159 @@
 #include "mysys_err.h"
 #include "sql_class.h"
 #include "sql_backup.h"
+#include "sql_backup_interface.h"
 #include "sql_parse.h"
 
+#ifdef _WIN32
+#elif defined __APPLE__
+# include <sys/attr.h>
+# include <sys/clonefile.h>
+# include <copyfile.h>
+# define copy_file(src, dst, off) \
+  fcopyfile(src, dst, nullptr, COPYFILE_ALL | COPYFILE_CLONE)
+#else
+using copying_step= ssize_t(int,int,size_t,off_t*);
+template<copying_step step>
+static ssize_t copy(int in_fd, int out_fd, off_t c) noexcept
+{
+  ssize_t ret;
+  for (off_t offset{0};;)
+  {
+    off_t count= c;
+    if (count > INT_MAX >> 20 << 20)
+      count = INT_MAX >> 20 << 20;
+    ret= step(in_fd, out_fd, size_t(count), &offset);
+    if (ret < 0)
+      break;
+    c-= ret;
+    if (!c)
+      return 0;
+    if (!ret)
+      return -1;
+  }
+  return ret;
+}
+# if defined __linux__ || defined __FreeBSD__
+/* Copy between files in a single (type of) file system */
+static inline ssize_t
+copy_step(int in_fd, int out_fd, size_t count, off_t *offset) noexcept
+{
+  return copy_file_range(in_fd, offset, out_fd, nullptr, count, 0);
+}
+#  define cfr(src,dst,size) copy<copy_step>(src, dst, size)
+# endif
+# ifdef __linux__
+#  include <sys/sendfile.h>
+/* Copy a file to a stream or to a regular file. */
+static inline ssize_t
+send_step(int in_fd, int out_fd, size_t count, off_t *offset) noexcept
+{
+  return sendfile(out_fd, in_fd, offset, count);
+}
+# else
+#  include <sys/mman.h>
+/** Copy a file using a memory mapping.
+@param in_fd   source file
+@param out_fd  destination
+@param count   number of bytes to copy
+@return error code
+@retval 0  on success
+@retval 1  if a memory mapping failed */
+static ssize_t mmap_copy(int in_fd, int out_fd, off_t count)
+{
+#if SIZEOF_SIZE_T < 8
+  if (count != ssize_t(count))
+    return 1;
+#endif
+  void *p= mmap(nullptr, count, PROT_READ, MAP_SHARED, in_fd, 0);
+  if (p == MAP_FAILED)
+    return 1;
+  ssize_t ret;
+  size_t c= size_t(count);
+  for (const char *b= static_cast<const char*>(p);; b+= ret)
+  {
+    ret= write(out_fd, b, std::min(c, size_t(INT_MAX >> 20 << 20)));
+    if (ret < 0)
+      break;
+    c-= ret;
+    if (!c)
+    {
+      ret= 0;
+      break;
+    }
+    if (!ret)
+    {
+      ret= -1;
+      break;
+    }
+  }
+  munmap(p, count);
+  return ret;
+}
+
+static ssize_t pread_write(int in_fd, int out_fd, off_t count) noexcept
+{
+  constexpr size_t READ_WRITE_SIZE= 65536;
+  char *b= static_cast<char*>(aligned_malloc(READ_WRITE_SIZE, 4096));
+  if (!b)
+    return -1;
+  ssize_t ret;
+  for (off_t o= 0;; o+= ret)
+  {
+    ret= pread(in_fd, b, ssize_t(std::min(count, off_t{READ_WRITE_SIZE})), o);
+    if (ret > 0)
+      ret= write(out_fd, b, ret);
+    if (ret < 0)
+      break;
+    count-= ret;
+    if (!count)
+    {
+      ret= 0;
+      break;
+    }
+    if (!ret)
+    {
+      ret= -1;
+      break;
+    }
+  }
+  aligned_free(b);
+  return ret;
+}
+# endif
+
+/** Copy a file.
+@param src  source file descriptor
+@param dst  target to append src to
+@param size amount of data to be copied
+@return error code (negative)
+@retval 0   on success */
+extern "C" int copy_file(int src, int dst, off_t size)
+{
+  ssize_t ret;
+# ifdef cfr
+  if (!(ret= cfr(src, dst, size)))
+    return int(ret);
+#  ifdef __linux__
+  if (errno == EOPNOTSUPP)
+#  endif
+# endif
+# ifdef __linux__ // starting with Linux 2.6.33, we can rely on sendfile(2)
+    ret= copy<send_step>(src, dst, size);
+# else
+  if ((ret= mmap_copy(src, dst, size)) == 1)
+    ret= pread_write(src, dst, size);
+# endif
+  assert(ret <= 0);
+  return int(ret);
+}
+#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, *static_cast<backup_target*>(dst));
   return false;
 }
 
@@ -53,9 +197,7 @@ 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),
-                   int(reinterpret_cast<uintptr_t>(dst))));
+    return hton->backup_finalize(thd, *static_cast<backup_target*>(dst));
   return 0;
 }
 
@@ -90,9 +232,11 @@ bool Sql_cmd_backup::execute(THD *thd)
     return true;
   }
 
-#ifndef _WIN32
-  int dir= open(target.str, O_DIRECTORY);
-  if (dir < 0)
+#ifdef _WIN32
+  backup_target dir{target.str, INVALID_HANDLE_VALUE};
+#else
+  backup_target dir{open(target.str, O_DIRECTORY), true};
+  if (dir.fd < 0)
   {
     my_error(EE_CANT_MKDIR, MYF(ME_BELL), target.str, errno);
     goto err_exit;
@@ -101,9 +245,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)));
+                                      PLUGIN_IS_DELETED|PLUGIN_IS_READY, &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. */
@@ -122,11 +264,9 @@ bool Sql_cmd_backup::execute(THD *thd)
   Release the locks. */
   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)));
+                           PLUGIN_IS_DELETED|PLUGIN_IS_READY, &dir);
 #ifndef _WIN32
-  close(dir);
+  close(dir.fd);
 #endif
 
   if (!fail)

sql/sql_backup_interface.h

@@ -0,0 +1,30 @@
+/* Copyright (c) 2026, MariaDB plc
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifndef _WIN32
+/** Copy a file.
+@param src  source file descriptor
+@param dst  target to append src to
+@param size amount of data to be copied
+@return error code (negative)
+@retval 0   on success */
+int copy_file(int src, int dst, off_t size);
+#endif
+#ifdef __cplusplus
+};
+#endif