MDEV-36733 Clone: Support Local Clone

debian/mariadb-server.install

@@ -59,6 +59,7 @@ usr/lib/mysql/plugin/simple_password_check.so
 usr/lib/mysql/plugin/sql_errlog.so
 usr/lib/mysql/plugin/type_mysql_json.so
 usr/lib/mysql/plugin/wsrep_info.so
+usr/lib/mysql/plugin/mariadb_clone.so
 usr/share/doc/mariadb-server/mariadbd.sym.gz
 usr/share/man/man1/aria_chk.1
 usr/share/man/man1/aria_dump_log.1

extra/mariabackup/aria_backup_client.cc

@@ -400,16 +400,18 @@ bool Table::copy(ds_ctxt_t *ds, bool is_index, unsigned thread_num) {
 		for (ulonglong block= 0 ; ; block++) {
 			size_t length = m_cap.block_size;
 			if (is_index) {
-				if ((error= aria_read_index(
-							partition.m_index_file, &m_cap, block, copy_buffer) ==
-							HA_ERR_END_OF_FILE))
-					break;
+				error= aria_read_index(partition.m_index_file,
+						       &m_cap, block,
+						       copy_buffer);
 			} else {
-				if ((error= aria_read_data(
-							partition.m_data_file, &m_cap, block, copy_buffer, &length) ==
-							HA_ERR_END_OF_FILE))
-					break;
+				error= aria_read_data(partition.m_data_file,
+						      &m_cap, block,
+						      copy_buffer, &length);
 			}
+
+			if (error == HA_ERR_END_OF_FILE)
+			  break;
+
 			if (error) {
 				msg(thread_num, "error: aria_read %s failed:  %d",
 					is_index ? "index" : "data", error);

include/mysql/plugin.h

@@ -97,7 +97,7 @@ typedef struct st_mysql_xid MYSQL_XID;
 #define MYSQL_AUDIT_PLUGIN           5
 #define MYSQL_REPLICATION_PLUGIN     6
 #define MYSQL_AUTHENTICATION_PLUGIN  7
-#define MYSQL_MAX_PLUGIN_TYPE_NUM    12  /**< The number of plugin types */
+#define MYSQL_MAX_PLUGIN_TYPE_NUM    13  /**< The number of plugin types */
 
 /* MariaDB plugin types */
 /** Client and server password validation */
@@ -108,6 +108,8 @@ typedef struct st_mysql_xid MYSQL_XID;
 #define MariaDB_DATA_TYPE_PLUGIN  10
 /**< Plugins for new native SQL functions */
 #define MariaDB_FUNCTION_PLUGIN 11
+/** Plugin for cloning storage engine data */
+#define MariaDB_CLONE_PLUGIN 12
 
 /* We use the following strings to define licenses for plugins */
 #define PLUGIN_LICENSE_PROPRIETARY 0

include/mysql/plugin_audit.h.pp

@@ -22,6 +22,83 @@
                   void *dst, const char **end_ptr, int flags);
 }
 extern "C" {
+typedef struct st_net_server NET_SERVER;
+typedef struct st_mysql MYSQL;
+typedef struct st_mysql_socket MYSQL_SOCKET;
+typedef struct mysql_clone_ssl_context_t {
+  int m_ssl_mode;
+  const char *m_ssl_key;
+  const char *m_ssl_cert;
+  const char *m_ssl_ca;
+  bool m_enable_compression;
+  NET_SERVER *m_server_extn;
+} mysql_clone_ssl_context;
+extern struct clone_protocol_service_st {
+  THD* (*start_statement_fn)(THD* thd, unsigned int thread_key,
+                             unsigned int statement_key,
+                             const char* thd_name);
+  void (*finish_statement_fn)(THD* thd);
+  int (*get_charsets_fn)(THD* thd, void *char_sets);
+  int (*validate_charsets_fn)(THD* thd, void *char_sets);
+  int (*get_configs_fn)(THD* thd, void *configs);
+  int (*validate_configs_fn)(THD* thd, void *configs);
+  MYSQL* (*connect_fn)(THD* thd, const char *host, uint32_t port,
+                             const char *user, const char *passwd,
+                             mysql_clone_ssl_context *ssl_ctx,
+                             MYSQL_SOCKET *socket);
+  int (*send_command_fn)(THD* thd, MYSQL *connection, bool set_active,
+                         unsigned char command, unsigned char *com_buffer,
+                         size_t buffer_length);
+  int (*get_response_fn)(THD* thd, MYSQL *connection, bool set_active,
+                         uint32_t timeout, unsigned char **packet,
+                         size_t *length, size_t *net_length);
+  int (*kill_fn)(MYSQL *connection, MYSQL *kill_connection);
+  void (*disconnect_fn)(THD* thd, MYSQL *connection, bool is_fatal,
+                        bool clear_error);
+  void (*get_error_fn)(THD* thd, uint32_t *err_num,
+                       const char **err_mesg);
+  int (*get_command_fn)(THD* thd, unsigned char *command,
+                        unsigned char **com_buffer, size_t *buffer_length);
+  int (*send_response_fn)(THD* thd, bool secure, unsigned char *packet,
+                          size_t length);
+  int (*send_error_fn)(THD* thd, unsigned char err_cmd, bool is_fatal);
+  int (*set_backup_stage_fn)(THD* thd, unsigned char stage);
+  int (*backup_lock_fn)(THD* thd, const char *db, const char *tbl);
+  int (*backup_unlock_fn)(THD* thd);
+} *clone_protocol_service;
+  THD* clone_start_statement(THD* thd, unsigned int thread_key,
+                             unsigned int statement_key,
+                             const char* thd_name);
+  void clone_finish_statement(THD* thd);
+  int clone_get_charsets(THD* thd, void *char_sets);
+  int clone_validate_charsets(THD* thd, void *char_sets);
+  int clone_get_configs(THD* thd, void *configs);
+  int clone_validate_configs(THD* thd, void *configs);
+  MYSQL* clone_connect(THD* thd, const char *host, uint32_t port,
+                       const char *user, const char *passwd,
+                       mysql_clone_ssl_context *ssl_ctx,
+                       MYSQL_SOCKET *socket);
+  int clone_send_command(THD* thd, MYSQL *connection, bool set_active,
+                         unsigned char command, unsigned char *com_buffer,
+                         size_t buffer_length);
+  int clone_get_response(THD* thd, MYSQL *connection, bool set_active,
+                         uint32_t timeout, unsigned char **packet,
+                         size_t *length, size_t *net_length);
+  int clone_kill(MYSQL *connection, MYSQL *kill_connection);
+  void clone_disconnect(THD* thd, MYSQL *connection, bool is_fatal,
+                        bool clear_error);
+  void clone_get_error(THD* thd, uint32_t *err_num,
+                       const char **err_mesg);
+  int clone_get_command(THD* thd, unsigned char *command,
+                        unsigned char **com_buffer, size_t *buffer_length);
+  int clone_send_response(THD* thd, bool secure, unsigned char *packet,
+                          size_t length);
+  int clone_send_error(THD* thd, unsigned char err_cmd, bool is_fatal);
+  int clone_set_backup_stage(THD* thd, unsigned char stage);
+  int clone_backup_lock(THD* thd, const char* db, const char* tbl);
+  int clone_backup_unlock(THD* thd);
+}
+extern "C" {
 extern void (*debug_sync_C_callback_ptr)(THD*, const char *, size_t);
 }
 extern "C" {

include/mysql/plugin_auth.h.pp

@@ -22,6 +22,83 @@
                   void *dst, const char **end_ptr, int flags);
 }
 extern "C" {
+typedef struct st_net_server NET_SERVER;
+typedef struct st_mysql MYSQL;
+typedef struct st_mysql_socket MYSQL_SOCKET;
+typedef struct mysql_clone_ssl_context_t {
+  int m_ssl_mode;
+  const char *m_ssl_key;
+  const char *m_ssl_cert;
+  const char *m_ssl_ca;
+  bool m_enable_compression;
+  NET_SERVER *m_server_extn;
+} mysql_clone_ssl_context;
+extern struct clone_protocol_service_st {
+  THD* (*start_statement_fn)(THD* thd, unsigned int thread_key,
+                             unsigned int statement_key,
+                             const char* thd_name);
+  void (*finish_statement_fn)(THD* thd);
+  int (*get_charsets_fn)(THD* thd, void *char_sets);
+  int (*validate_charsets_fn)(THD* thd, void *char_sets);
+  int (*get_configs_fn)(THD* thd, void *configs);
+  int (*validate_configs_fn)(THD* thd, void *configs);
+  MYSQL* (*connect_fn)(THD* thd, const char *host, uint32_t port,
+                             const char *user, const char *passwd,
+                             mysql_clone_ssl_context *ssl_ctx,
+                             MYSQL_SOCKET *socket);
+  int (*send_command_fn)(THD* thd, MYSQL *connection, bool set_active,
+                         unsigned char command, unsigned char *com_buffer,
+                         size_t buffer_length);
+  int (*get_response_fn)(THD* thd, MYSQL *connection, bool set_active,
+                         uint32_t timeout, unsigned char **packet,
+                         size_t *length, size_t *net_length);
+  int (*kill_fn)(MYSQL *connection, MYSQL *kill_connection);
+  void (*disconnect_fn)(THD* thd, MYSQL *connection, bool is_fatal,
+                        bool clear_error);
+  void (*get_error_fn)(THD* thd, uint32_t *err_num,
+                       const char **err_mesg);
+  int (*get_command_fn)(THD* thd, unsigned char *command,
+                        unsigned char **com_buffer, size_t *buffer_length);
+  int (*send_response_fn)(THD* thd, bool secure, unsigned char *packet,
+                          size_t length);
+  int (*send_error_fn)(THD* thd, unsigned char err_cmd, bool is_fatal);
+  int (*set_backup_stage_fn)(THD* thd, unsigned char stage);
+  int (*backup_lock_fn)(THD* thd, const char *db, const char *tbl);
+  int (*backup_unlock_fn)(THD* thd);
+} *clone_protocol_service;
+  THD* clone_start_statement(THD* thd, unsigned int thread_key,
+                             unsigned int statement_key,
+                             const char* thd_name);
+  void clone_finish_statement(THD* thd);
+  int clone_get_charsets(THD* thd, void *char_sets);
+  int clone_validate_charsets(THD* thd, void *char_sets);
+  int clone_get_configs(THD* thd, void *configs);
+  int clone_validate_configs(THD* thd, void *configs);
+  MYSQL* clone_connect(THD* thd, const char *host, uint32_t port,
+                       const char *user, const char *passwd,
+                       mysql_clone_ssl_context *ssl_ctx,
+                       MYSQL_SOCKET *socket);
+  int clone_send_command(THD* thd, MYSQL *connection, bool set_active,
+                         unsigned char command, unsigned char *com_buffer,
+                         size_t buffer_length);
+  int clone_get_response(THD* thd, MYSQL *connection, bool set_active,
+                         uint32_t timeout, unsigned char **packet,
+                         size_t *length, size_t *net_length);
+  int clone_kill(MYSQL *connection, MYSQL *kill_connection);
+  void clone_disconnect(THD* thd, MYSQL *connection, bool is_fatal,
+                        bool clear_error);
+  void clone_get_error(THD* thd, uint32_t *err_num,
+                       const char **err_mesg);
+  int clone_get_command(THD* thd, unsigned char *command,
+                        unsigned char **com_buffer, size_t *buffer_length);
+  int clone_send_response(THD* thd, bool secure, unsigned char *packet,
+                          size_t length);
+  int clone_send_error(THD* thd, unsigned char err_cmd, bool is_fatal);
+  int clone_set_backup_stage(THD* thd, unsigned char stage);
+  int clone_backup_lock(THD* thd, const char* db, const char* tbl);
+  int clone_backup_unlock(THD* thd);
+}
+extern "C" {
 extern void (*debug_sync_C_callback_ptr)(THD*, const char *, size_t);
 }
 extern "C" {

include/mysql/plugin_clone.h

@@ -0,0 +1,89 @@
+/* Copyright (c) 2017, 2024, Oracle and/or its affiliates.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License, version 2.0,
+   as published by the Free Software Foundation.
+
+   This program is designed to work with certain software (including
+   but not limited to OpenSSL) that is licensed under separate terms,
+   as designated in a particular file or component or in included license
+   documentation.  The authors of MySQL hereby grant you an additional
+   permission to link the program and your derivative works with the
+   separately licensed software that they have either included with
+   the program or referenced in the documentation.
+
+   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, version 2.0, 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-1301  USA */
+
+/**
+@file mysql/plugin_clone.h
+API for clone plugin
+*/
+
+#ifndef MYSQL_PLUGIN_CLONE_INCLUDED
+#define MYSQL_PLUGIN_CLONE_INCLUDED
+
+#include "my_global.h"
+#include "violite.h"
+#include "plugin.h"
+
+/** Clone plugin interface version */
+#define MariaDB_CLONE_INTERFACE_VERSION 0x0100
+
+/**
+  The descriptor structure for the plugin, that is referred from
+  st_mysql_plugin.
+*/
+
+struct Mysql_clone {
+  /** clone plugin interface version */
+  int interface_version;
+
+  /** Clone database from local server.
+  @param[in]	thd		server thread handle
+  @param[in]	data_dir	cloned data directory
+  @return error code, 0 on success */
+  int (*clone_local)(THD *thd, const char *data_dir);
+
+  /** Clone database from remote server.
+  @param[in]	thd		server thread handle
+  @param[in]	remote_host	remote host IP address
+  @param[in]	remote_port	remote server port
+  @param[in]	remote_user	remote user name
+  @param[in]	remote_passwd	remote user's password
+  @param[in]	data_dir	cloned data directory
+  @param[in]	ssl_mode	ssl mode for remote connection
+  @return error code, 0 on success */
+  int (*clone_client)(THD *thd, const char *remote_host, uint remote_port,
+                      const char *remote_user, const char *remote_passwd,
+                      const char *data_dir, int ssl_mode);
+
+  /** Clone database and send to remote clone client.
+  @param[in]	thd	server thread handle
+  @param[in]	socket	network socket to remote client
+  @return error code, 0 on success */
+  int (*clone_server)(THD *thd, MYSQL_SOCKET socket);
+};
+
+/** Create clone handle to  access the clone interfaces from server.
+Called when Clone plugin is installed.
+@param[in]	plugin_name	clone plugin name
+@return error code */
+int clone_handle_create(const char *plugin_name);
+
+/** Drop clone handle. Called when Clone plugin is uninstalled.
+@return error code */
+int clone_handle_drop();
+
+/** Check if it is safe to uninstall clone plugin.
+@param[in,out]	plugin_info	plugin
+@return error code */
+int clone_handle_check_drop(MYSQL_PLUGIN plugin_info);
+
+#endif

include/mysql/plugin_data_type.h.pp

@@ -22,6 +22,83 @@
                   void *dst, const char **end_ptr, int flags);
 }
 extern "C" {
+typedef struct st_net_server NET_SERVER;
+typedef struct st_mysql MYSQL;
+typedef struct st_mysql_socket MYSQL_SOCKET;
+typedef struct mysql_clone_ssl_context_t {
+  int m_ssl_mode;
+  const char *m_ssl_key;
+  const char *m_ssl_cert;
+  const char *m_ssl_ca;
+  bool m_enable_compression;
+  NET_SERVER *m_server_extn;
+} mysql_clone_ssl_context;
+extern struct clone_protocol_service_st {
+  THD* (*start_statement_fn)(THD* thd, unsigned int thread_key,
+                             unsigned int statement_key,
+                             const char* thd_name);
+  void (*finish_statement_fn)(THD* thd);
+  int (*get_charsets_fn)(THD* thd, void *char_sets);
+  int (*validate_charsets_fn)(THD* thd, void *char_sets);
+  int (*get_configs_fn)(THD* thd, void *configs);
+  int (*validate_configs_fn)(THD* thd, void *configs);
+  MYSQL* (*connect_fn)(THD* thd, const char *host, uint32_t port,
+                             const char *user, const char *passwd,
+                             mysql_clone_ssl_context *ssl_ctx,
+                             MYSQL_SOCKET *socket);
+  int (*send_command_fn)(THD* thd, MYSQL *connection, bool set_active,
+                         unsigned char command, unsigned char *com_buffer,
+                         size_t buffer_length);
+  int (*get_response_fn)(THD* thd, MYSQL *connection, bool set_active,
+                         uint32_t timeout, unsigned char **packet,
+                         size_t *length, size_t *net_length);
+  int (*kill_fn)(MYSQL *connection, MYSQL *kill_connection);
+  void (*disconnect_fn)(THD* thd, MYSQL *connection, bool is_fatal,
+                        bool clear_error);
+  void (*get_error_fn)(THD* thd, uint32_t *err_num,
+                       const char **err_mesg);
+  int (*get_command_fn)(THD* thd, unsigned char *command,
+                        unsigned char **com_buffer, size_t *buffer_length);
+  int (*send_response_fn)(THD* thd, bool secure, unsigned char *packet,
+                          size_t length);
+  int (*send_error_fn)(THD* thd, unsigned char err_cmd, bool is_fatal);
+  int (*set_backup_stage_fn)(THD* thd, unsigned char stage);
+  int (*backup_lock_fn)(THD* thd, const char *db, const char *tbl);
+  int (*backup_unlock_fn)(THD* thd);
+} *clone_protocol_service;
+  THD* clone_start_statement(THD* thd, unsigned int thread_key,
+                             unsigned int statement_key,
+                             const char* thd_name);
+  void clone_finish_statement(THD* thd);
+  int clone_get_charsets(THD* thd, void *char_sets);
+  int clone_validate_charsets(THD* thd, void *char_sets);
+  int clone_get_configs(THD* thd, void *configs);
+  int clone_validate_configs(THD* thd, void *configs);
+  MYSQL* clone_connect(THD* thd, const char *host, uint32_t port,
+                       const char *user, const char *passwd,
+                       mysql_clone_ssl_context *ssl_ctx,
+                       MYSQL_SOCKET *socket);
+  int clone_send_command(THD* thd, MYSQL *connection, bool set_active,
+                         unsigned char command, unsigned char *com_buffer,
+                         size_t buffer_length);
+  int clone_get_response(THD* thd, MYSQL *connection, bool set_active,
+                         uint32_t timeout, unsigned char **packet,
+                         size_t *length, size_t *net_length);
+  int clone_kill(MYSQL *connection, MYSQL *kill_connection);
+  void clone_disconnect(THD* thd, MYSQL *connection, bool is_fatal,
+                        bool clear_error);
+  void clone_get_error(THD* thd, uint32_t *err_num,
+                       const char **err_mesg);
+  int clone_get_command(THD* thd, unsigned char *command,
+                        unsigned char **com_buffer, size_t *buffer_length);
+  int clone_send_response(THD* thd, bool secure, unsigned char *packet,
+                          size_t length);
+  int clone_send_error(THD* thd, unsigned char err_cmd, bool is_fatal);
+  int clone_set_backup_stage(THD* thd, unsigned char stage);
+  int clone_backup_lock(THD* thd, const char* db, const char* tbl);
+  int clone_backup_unlock(THD* thd);
+}
+extern "C" {
 extern void (*debug_sync_C_callback_ptr)(THD*, const char *, size_t);
 }
 extern "C" {