MDEV-39092 BACKUP SERVER of ENGINE=Aria to the local file system

Enable backup for non-Apple systems.
Copy non-Aria-specific files *.frm and db.opt as part of Aria backup.

Author: mariadb-andrzejjarzabek

include/my_backup.h

@@ -0,0 +1,54 @@
+/*****************************************************************************
+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 Street, Fifth Floor, Boston, MA 02110-1335 USA
+
+*****************************************************************************/
+
+#pragma once
+
+#include <cstdint>
+
+namespace backup
+{
+
+using target_dir_t= IF_WIN(const char*,int);
+
+inline void* to_void_ptr(target_dir_t tgt) noexcept
+{
+  return IF_WIN(const_cast<char*>, reinterpret_cast<void*>)(tgt);
+}
+
+inline target_dir_t to_target_dir(void* ptr) noexcept
+{
+  return IF_WIN(static_cast<const char*>(ptr), 
+                int(reinterpret_cast<uintptr_t>(ptr)));
+}
+
+#ifndef _WIN32
+/** Copy a file.
+@param src  source file descriptor
+@param dst  target to append src to
+@return error code (negative)
+@retval 0   on success */
+int copy_file(int src, int dst) noexcept;
+
+/** Copy the entire 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) noexcept;
+#endif // _WIN32
+}

mysys/CMakeLists.txt

@@ -48,7 +48,7 @@ SET(MYSYS_SOURCES  array.c charset-def.c charset.c my_default.c
                                 my_atomic_writes.c my_cpu.c my_likely.c my_largepage.c
                                 file_logger.c my_dlerror.c   crc32/crc32c.cc
                                 my_timezone.cc my_compr_int.cc my_thread_name.cc
-                                my_virtual_mem.c)
+                                my_virtual_mem.c my_backup.cc)
 
 IF (WIN32)
   SET (MYSYS_SOURCES ${MYSYS_SOURCES}

mysys/my_backup.cc

@@ -0,0 +1,176 @@
+#include "my_global.h"
+#include "my_backup.h"
+
+#ifdef __APPLE__
+# include <sys/attr.h>
+# include <sys/clonefile.h>
+# include <copyfile.h>
+#elif defined __linux__
+# include <sys/sendfile.h>
+#elif !defined _WIN32
+# include <sys/mman.h>
+#endif
+
+namespace
+{
+#if !(defined __APPLE__ || defined _WIN32)
+
+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__
+/* 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
+/** 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
+#endif
+}
+
+namespace backup
+{
+
+#ifndef _WIN32
+/** Copy a file.
+@param src  source file descriptor
+@param dst  target to append src to
+@return error code (negative)
+@retval 0   on success */
+int copy_file(int src, int dst) noexcept
+{
+#ifdef __APPLE__
+  return fcopyfile(src, dst, nullptr, COPYFILE_ALL | COPYFILE_CLONE);
+#else
+  return copy_file(src, dst, lseek(src, 0, SEEK_END));
+#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 */
+int copy_file(int src, int dst, off_t size) noexcept
+{
+#ifdef __APPLE__
+  return fcopyfile(src, dst, nullptr, COPYFILE_ALL | COPYFILE_CLONE);
+#else
+  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
+  DBUG_ASSERT(ret <= 0);
+  return int(ret);
+#endif
+}
+#endif
+}

sql/handler.h

@@ -38,6 +38,7 @@
 #include "sql_analyze_stmt.h" // for Exec_time_tracker 
 
 #include <my_compare.h>
+#include <my_backup.h>
 #include <ft_global.h>
 #include <keycache.h>
 #include <mysql/psi/mysql_table.h>
@@ -1905,7 +1906,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, backup::target_dir_t target);
   /**
      Process a file that was collected in backup_start().
      @param thd   current session
@@ -1928,7 +1929,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, backup::target_dir_t target);
 
   /**********************************************************************
    WSREP specific

sql/sql_backup.cc

@@ -19,14 +19,15 @@
 #include "sql_class.h"
 #include "sql_backup.h"
 #include "sql_parse.h"
+#include "my_backup.h"
+
+using namespace backup;
 
 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, to_target_dir(dst));
   return false;
 }
 
@@ -53,9 +54,7 @@ static my_bool backup_finalize(THD *thd, plugin_ref plugin, void *dst) noexcept
 {
   handlerton *hton= plugin_hton(plugin);
   if (hton->backup_finalize)
-    return hton->backup_finalize
-      (thd, IF_WIN(static_cast<const char*>(dst),
-                   int(reinterpret_cast<uintptr_t>(dst))));
+    return hton->backup_finalize(thd, to_target_dir(dst));
   return 0;
 }
 
@@ -97,13 +96,14 @@ bool Sql_cmd_backup::execute(THD *thd)
     my_error(EE_CANT_MKDIR, MYF(ME_BELL), target.str, errno);
     goto err_exit;
   }
+#else
+  const char *const dir= target.str;
 #endif
 
   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)));
+                                      to_void_ptr(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,8 +123,7 @@ 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)));
+                           to_void_ptr(dir));
 #ifndef _WIN32
   close(dir);
 #endif