Merge 10.1 into 10.2

This will also change the minimum and maximum value of
innodb_log_file_size to 1MiB and 512GiB, respectively.

18 files changed, 56 insertions, 3702 deletions

diff --git a/extra/mariabackup/backup_copy.cc b/extra/mariabackup/backup_copy.cc
index 306009e2139..156e0b20e7c 100644
--- a/extra/mariabackup/backup_copy.cc
+++ b/extra/mariabackup/backup_copy.cc
@@ -1774,7 +1774,7 @@ copy_back()
 		const char *ext_list[] = {"backup-my.cnf", "xtrabackup_logfile",
 			"xtrabackup_binary", "xtrabackup_binlog_info",
 			"xtrabackup_checkpoints", ".qp", ".pmap", ".tmp",
-			".xbcrypt", NULL};
+			NULL};
 		const char *filename;
 		char c_tmp;
 		int i_tmp;
@@ -1807,7 +1807,7 @@ copy_back()
 
 		filename = base_name(node.filepath);
 
-		/* skip .qp and .xbcrypt files */
+		/* skip .qp files */
 		if (filename_matches(filename, ext_list)) {
 			continue;
 		}
@@ -1899,24 +1899,8 @@ decrypt_decompress_file(const char *filepath, uint thread_n)
 
 	cmd << IF_WIN("type ","cat ") << filepath;
 
- 	if (ends_with(filepath, ".xbcrypt") && opt_decrypt) {
- 		cmd << " | xbcrypt --decrypt --encrypt-algo="
- 		    << xtrabackup_encrypt_algo_names[opt_decrypt_algo];
- 		if (xtrabackup_encrypt_key) {
- 			cmd << " --encrypt-key=" << xtrabackup_encrypt_key;
- 		} else {
- 			cmd << " --encrypt-key-file="
- 			    << xtrabackup_encrypt_key_file;
- 		}
- 		dest_filepath[strlen(dest_filepath) - 8] = 0;
- 		message << "decrypting";
- 		needs_action = true;
- 	}
-
  	if (opt_decompress
- 	    && (ends_with(filepath, ".qp")
-		|| (ends_with(filepath, ".qp.xbcrypt")
-		    && opt_decrypt))) {
+ 	    && ends_with(filepath, ".qp")) {
  		cmd << " | qpress -dio ";
  		dest_filepath[strlen(dest_filepath) - 3] = 0;
  		if (needs_action) {
@@ -1967,8 +1951,7 @@ decrypt_decompress_thread_func(void *arg)
 			continue;
 		}
 
-		if (!ends_with(node.filepath, ".qp")
-		    && !ends_with(node.filepath, ".xbcrypt")) {
+		if (!ends_with(node.filepath, ".qp")) {
 			continue;
 		}
 
diff --git a/extra/mariabackup/backup_mysql.cc b/extra/mariabackup/backup_mysql.cc
index 6299afffc6e..2353c7692cb 100644
--- a/extra/mariabackup/backup_mysql.cc
+++ b/extra/mariabackup/backup_mysql.cc
@@ -1435,9 +1435,7 @@ write_xtrabackup_info(MYSQL *connection)
 		"partial = %s\n"
 		"incremental = %s\n"
 		"format = %s\n"
-		"compact = %s\n"
-		"compressed = %s\n"
-		"encrypted = %s\n",
+		"compressed = %s\n",
 		uuid, /* uuid */
 		opt_history ? opt_history : "",  /* name */
 		tool_name,  /* tool_name */
@@ -1455,9 +1453,7 @@ write_xtrabackup_info(MYSQL *connection)
 		is_partial? "Y" : "N",
 		xtrabackup_incremental ? "Y" : "N", /* incremental */
 		xb_stream_name[xtrabackup_stream_fmt], /* format */
-		"N", /* compact */
-		xtrabackup_compress ? "compressed" : "N", /* compressed */
-		xtrabackup_encrypt ? "Y" : "N"); /* encrypted */
+		xtrabackup_compress ? "compressed" : "N"); /* compressed */
 
 	if (!opt_history) {
 		goto cleanup;
@@ -1483,9 +1479,7 @@ write_xtrabackup_info(MYSQL *connection)
 		"partial ENUM('Y', 'N') DEFAULT NULL,"
 		"incremental ENUM('Y', 'N') DEFAULT NULL,"
 		"format ENUM('file', 'tar', 'xbstream') DEFAULT NULL,"
-		"compact ENUM('Y', 'N') DEFAULT NULL,"
-		"compressed ENUM('Y', 'N') DEFAULT NULL,"
-		"encrypted ENUM('Y', 'N') DEFAULT NULL"
+		"compressed ENUM('Y', 'N') DEFAULT NULL"
 		") CHARACTER SET utf8 ENGINE=innodb", false);
 
 
@@ -1495,8 +1489,8 @@ write_xtrabackup_info(MYSQL *connection)
 		<< "uuid, name, tool_name, tool_command, tool_version,"
 		<< "ibbackup_version, server_version, start_time, end_time,"
 		<< "lock_time, binlog_pos, innodb_from_lsn, innodb_to_lsn,"
-		<< "partial, incremental, format, compact, compressed, "
-		<< "encrypted) values("
+		<< "partial, incremental, format, compressed) "
+		<< "values("
 		<< escape_and_quote(connection, uuid) << ","
 		<< escape_and_quote(connection, opt_history) << ","
 		<< escape_and_quote(connection, tool_name) << ","
@@ -1513,9 +1507,7 @@ write_xtrabackup_info(MYSQL *connection)
 		<< ESCAPE_BOOL(is_partial) << ","
 		<< ESCAPE_BOOL(xtrabackup_incremental)<< ","
 		<< escape_and_quote(connection,xb_stream_name[xtrabackup_stream_fmt]) <<","
-		<< ESCAPE_BOOL(false) << ","
-		<< ESCAPE_BOOL(xtrabackup_compress) << ","
-		<< ESCAPE_BOOL(xtrabackup_encrypt) <<")";
+		<< ESCAPE_BOOL(xtrabackup_compress) << ")";
 
 	xb_mysql_query(mysql_connection, oss.str().c_str(), false);
 
@@ -1581,14 +1573,6 @@ char *make_argv(char *buf, size_t len, int argc, char **argv)
 		if (strncmp(*argv, "--password", strlen("--password")) == 0) {
 			arg = "--password=...";
 		}
-		if (strncmp(*argv, "--encrypt-key",
-				strlen("--encrypt-key")) == 0) {
-			arg = "--encrypt-key=...";
-		}
-		if (strncmp(*argv, "--encrypt_key",
-				strlen("--encrypt_key")) == 0) {
-			arg = "--encrypt_key=...";
-		}
 		left-= ut_snprintf(buf + len - left, left,
 			"%s%c", arg, argc > 1 ? ' ' : 0);
 		++argv; --argc;
diff --git a/extra/mariabackup/ds_decrypt.c b/extra/mariabackup/ds_decrypt.c
deleted file mode 100644
index e897ca101e5..00000000000
--- a/extra/mariabackup/ds_decrypt.c
+++ /dev/null
@@ -1,665 +0,0 @@
-/******************************************************
-Copyright (c) 2017 Percona LLC and/or its affiliates.
-
-Encryption datasink implementation for XtraBackup.
-
-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-1301, USA
-
-*******************************************************/
-
-
-#include <my_base.h>
-#include "common.h"
-#include "datasink.h"
-#include "xbcrypt.h"
-#include "xbcrypt_common.h"
-#include "crc_glue.h"
-
-typedef struct {
-	pthread_t		id;
-	uint			num;
-	pthread_mutex_t 	ctrl_mutex;
-	pthread_cond_t		ctrl_cond;
-	pthread_mutex_t		data_mutex;
-	pthread_cond_t  	data_cond;
-	my_bool			started;
-	my_bool			data_avail;
-	my_bool			cancelled;
-	my_bool			failed;
-	const uchar 		*from;
-	size_t			from_len;
-	uchar			*to;
-	size_t			to_len;
-	size_t			to_size;
-	const uchar		*iv;
-	size_t			iv_len;
-	unsigned long long	offset;
-	my_bool			hash_appended;
-	gcry_cipher_hd_t	cipher_handle;
-	xb_rcrypt_result_t	parse_result;
-} crypt_thread_ctxt_t;
-
-typedef struct {
-	crypt_thread_ctxt_t	*threads;
-	uint			nthreads;
-	int			encrypt_algo;
-	size_t			chunk_size;
-	char			*encrypt_key;
-	char			*encrypt_key_file;
-} ds_decrypt_ctxt_t;
-
-typedef struct {
-	ds_decrypt_ctxt_t	*crypt_ctxt;
-	size_t			bytes_processed;
-	ds_file_t		*dest_file;
-	uchar			*buf;
-	size_t			buf_len;
-	size_t			buf_size;
-} ds_decrypt_file_t;
-
-int		ds_decrypt_encrypt_threads = 1;
-
-static ds_ctxt_t *decrypt_init(const char *root);
-static ds_file_t *decrypt_open(ds_ctxt_t *ctxt, const char *path,
-				MY_STAT *mystat);
-static int decrypt_write(ds_file_t *file, const void *buf, size_t len);
-static int decrypt_close(ds_file_t *file);
-static void decrypt_deinit(ds_ctxt_t *ctxt);
-
-datasink_t datasink_decrypt = {
-	&decrypt_init,
-	&decrypt_open,
-	&decrypt_write,
-	&decrypt_close,
-	&decrypt_deinit
-};
-
-static crypt_thread_ctxt_t *create_worker_threads(uint n);
-static void destroy_worker_threads(crypt_thread_ctxt_t *threads, uint n);
-static void *decrypt_worker_thread_func(void *arg);
-
-static
-ds_ctxt_t *
-decrypt_init(const char *root)
-{
-	ds_ctxt_t		*ctxt;
-	ds_decrypt_ctxt_t	*decrypt_ctxt;
-	crypt_thread_ctxt_t	*threads;
-
-	if (xb_crypt_init(NULL)) {
-		return NULL;
-	}
-
-	/* Create and initialize the worker threads */
-	threads = create_worker_threads(ds_decrypt_encrypt_threads);
-	if (threads == NULL) {
-		msg("decrypt: failed to create worker threads.\n");
-		return NULL;
-	}
-
-	ctxt = (ds_ctxt_t *) my_malloc(sizeof(ds_ctxt_t) +
-				       sizeof(ds_decrypt_ctxt_t),
-				       MYF(MY_FAE));
-
-	decrypt_ctxt = (ds_decrypt_ctxt_t *) (ctxt + 1);
-	decrypt_ctxt->threads = threads;
-	decrypt_ctxt->nthreads = ds_decrypt_encrypt_threads;
-
-	ctxt->ptr = decrypt_ctxt;
-	ctxt->root = my_strdup(root, MYF(MY_FAE));
-
-	return ctxt;
-}
-
-static
-ds_file_t *
-decrypt_open(ds_ctxt_t *ctxt, const char *path, MY_STAT *mystat)
-{
-	ds_ctxt_t		*dest_ctxt;
-
-	ds_decrypt_ctxt_t	*crypt_ctxt;
-	ds_decrypt_file_t	*crypt_file;
-
-	char			new_name[FN_REFLEN];
-	ds_file_t		*file;
-
-	xb_ad(ctxt->pipe_ctxt != NULL);
-	dest_ctxt = ctxt->pipe_ctxt;
-
-	crypt_ctxt = (ds_decrypt_ctxt_t *) ctxt->ptr;
-
-
-	file = (ds_file_t *) my_malloc(sizeof(ds_file_t) +
-				       sizeof(ds_decrypt_file_t),
-				       MYF(MY_FAE|MY_ZEROFILL));
-
-	crypt_file = (ds_decrypt_file_t *) (file + 1);
-
-	/* Remove the .xbcrypt extension from the filename */
-	strncpy(new_name, path, FN_REFLEN);
-	new_name[strlen(new_name) - 8] = 0;
-	crypt_file->dest_file = ds_open(dest_ctxt, new_name, mystat);
-	if (crypt_file->dest_file == NULL) {
-		msg("decrypt: ds_open(\"%s\") failed.\n", new_name);
-		goto err;
-	}
-
-	crypt_file->crypt_ctxt = crypt_ctxt;
-	crypt_file->buf = NULL;
-	crypt_file->buf_size = 0;
-	crypt_file->buf_len = 0;
-
-	file->ptr = crypt_file;
-	file->path = crypt_file->dest_file->path;
-
-	return file;
-
-err:
-	if (crypt_file->dest_file) {
-		ds_close(crypt_file->dest_file);
-	}
-	my_free(file);
-	return NULL;
-}
-
-#define CHECK_BUF_SIZE(ptr, size, buf, len) \
-	if (ptr + size - buf > (ssize_t) len) { \
-		result = XB_CRYPT_READ_INCOMPLETE; \
-		goto exit; \
-	}
-
-static
-xb_rcrypt_result_t
-parse_xbcrypt_chunk(crypt_thread_ctxt_t *thd, const uchar *buf, size_t len,
-		    size_t *bytes_processed)
-{
-	const uchar *ptr;
-	uint version;
-	ulong checksum, checksum_exp;
-	ulonglong tmp;
-	xb_rcrypt_result_t result = XB_CRYPT_READ_CHUNK;
-
-	*bytes_processed = 0;
-	ptr = buf;
-
-	CHECK_BUF_SIZE(ptr, XB_CRYPT_CHUNK_MAGIC_SIZE, buf, len);
-	if (memcmp(ptr, XB_CRYPT_CHUNK_MAGIC3,
-		   XB_CRYPT_CHUNK_MAGIC_SIZE) == 0) {
-		version = 3;
-	} else if (memcmp(ptr, XB_CRYPT_CHUNK_MAGIC2,
-			  XB_CRYPT_CHUNK_MAGIC_SIZE) == 0) {
-		version = 2;
-	} else if (memcmp(ptr, XB_CRYPT_CHUNK_MAGIC1,
-			  XB_CRYPT_CHUNK_MAGIC_SIZE) == 0) {
-		version = 1;
-	} else {
-		msg("%s:%s: wrong chunk magic at offset 0x%llx.\n",
-		    my_progname, __FUNCTION__, thd->offset);
-		result = XB_CRYPT_READ_ERROR;
-		goto exit;
-	}
-
-	ptr += XB_CRYPT_CHUNK_MAGIC_SIZE;
-	thd->offset += XB_CRYPT_CHUNK_MAGIC_SIZE;
-
-	CHECK_BUF_SIZE(ptr, 8, buf, len);
-	tmp = uint8korr(ptr);	/* reserved */
-	ptr += 8;
-	thd->offset += 8;
-
-	CHECK_BUF_SIZE(ptr, 8, buf, len);
-	tmp = uint8korr(ptr);	/* original size */
-	ptr += 8;
-	if (tmp > INT_MAX) {
-		msg("%s:%s: invalid original size at offset 0x%llx.\n",
-		    my_progname, __FUNCTION__, thd->offset);
-		result = XB_CRYPT_READ_ERROR;
-		goto exit;
-	}
-	thd->offset += 8;
-	thd->to_len = (size_t)tmp;
-
-	if (thd->to_size < thd->to_len + XB_CRYPT_HASH_LEN) {
-		thd->to = (uchar *) my_realloc(
-				thd->to,
-				thd->to_len + XB_CRYPT_HASH_LEN,
-				MYF(MY_FAE | MY_ALLOW_ZERO_PTR));
-		thd->to_size = thd->to_len;
-	}
-
-	CHECK_BUF_SIZE(ptr, 8, buf, len);
-	tmp = uint8korr(ptr);	/* encrypted size */
-	ptr += 8;
-	if (tmp > INT_MAX) {
-		msg("%s:%s: invalid encrypted size at offset 0x%llx.\n",
-		    my_progname, __FUNCTION__, thd->offset);
-		result = XB_CRYPT_READ_ERROR;
-		goto exit;
-	}
-	thd->offset += 8;
-	thd->from_len = (size_t)tmp;
-
-	xb_a(thd->from_len <= thd->to_len + XB_CRYPT_HASH_LEN);
-
-	CHECK_BUF_SIZE(ptr, 4, buf, len);
-	checksum_exp = uint4korr(ptr);	/* checksum */
-	ptr += 4;
-	thd->offset += 4;
-
-	/* iv size */
-	if (version == 1) {
-		thd->iv_len = 0;
-		thd->iv = NULL;
-	} else {
-		CHECK_BUF_SIZE(ptr, 8, buf, len);
-
-		tmp = uint8korr(ptr);
-		if (tmp > INT_MAX) {
-			msg("%s:%s: invalid iv size at offset 0x%llx.\n",
-			    my_progname, __FUNCTION__, thd->offset);
-			result = XB_CRYPT_READ_ERROR;
-			goto exit;
-		}
-		ptr += 8;
-		thd->offset += 8;
-		thd->iv_len = (size_t)tmp;
-	}
-
-	if (thd->iv_len > 0) {
-		CHECK_BUF_SIZE(ptr, thd->iv_len, buf, len);
-		thd->iv = ptr;
-		ptr += thd->iv_len;
-	}
-
-	/* for version euqals 2 we need to read in the iv data but do not init
-	CTR with it */
-	if (version == 2) {
-		thd->iv_len = 0;
-		thd->iv = 0;
-	}
-
-	if (thd->from_len > 0) {
-		CHECK_BUF_SIZE(ptr, thd->from_len, buf, len);
-		thd->from = ptr;
-		ptr += thd->from_len;
-	}
-
-	xb_ad(thd->from_len <= thd->to_len);
-
-	checksum = crc32_iso3309(0, thd->from, thd->from_len);
-	if (checksum != checksum_exp) {
-		msg("%s:%s invalid checksum at offset 0x%llx, "
-		    "expected 0x%lx, actual 0x%lx.\n", my_progname,
-		    __FUNCTION__, thd->offset, checksum_exp, checksum);
-		result = XB_CRYPT_READ_ERROR;
-		goto exit;
-	}
-
-	thd->offset += thd->from_len;
-
-	thd->hash_appended = version > 2;
-
-exit:
-
-	*bytes_processed = (size_t) (ptr - buf);
-
-	return result;
-}
-
-static
-int
-decrypt_write(ds_file_t *file, const void *buf, size_t len)
-{
-	ds_decrypt_file_t	*crypt_file;
-	ds_decrypt_ctxt_t	*crypt_ctxt;
-	crypt_thread_ctxt_t	*threads;
-	crypt_thread_ctxt_t	*thd;
-	uint			nthreads;
-	uint			i;
-	size_t			bytes_processed;
-	xb_rcrypt_result_t	parse_result = XB_CRYPT_READ_CHUNK;
-	my_bool			err = FALSE;
-
-	crypt_file = (ds_decrypt_file_t *) file->ptr;
-	crypt_ctxt = crypt_file->crypt_ctxt;
-
-	threads = crypt_ctxt->threads;
-	nthreads = crypt_ctxt->nthreads;
-
-	if (crypt_file->buf_len > 0) {
-		thd = threads;
-
-		pthread_mutex_lock(&thd->ctrl_mutex);
-
-		do {
-			if (parse_result == XB_CRYPT_READ_INCOMPLETE) {
-				crypt_file->buf_size = crypt_file->buf_size * 2;
-				crypt_file->buf = (uchar *) my_realloc(
-						crypt_file->buf,
-						crypt_file->buf_size,
-						MYF(MY_FAE|MY_ALLOW_ZERO_PTR));
-			}
-
-			memcpy(crypt_file->buf + crypt_file->buf_len,
-			       buf, MY_MIN(crypt_file->buf_size -
-					   crypt_file->buf_len, len));
-
-			parse_result = parse_xbcrypt_chunk(
-				thd, crypt_file->buf,
-				crypt_file->buf_size, &bytes_processed);
-
-			if (parse_result == XB_CRYPT_READ_ERROR) {
-				pthread_mutex_unlock(&thd->ctrl_mutex);
-				return 1;
-			}
-
-		} while (parse_result == XB_CRYPT_READ_INCOMPLETE &&
-			 crypt_file->buf_size < len);
-
-		if (parse_result != XB_CRYPT_READ_CHUNK) {
-			msg("decrypt: incomplete data.\n");
-			pthread_mutex_unlock(&thd->ctrl_mutex);
-			return 1;
-		}
-
-		pthread_mutex_lock(&thd->data_mutex);
-		thd->data_avail = TRUE;
-		pthread_cond_signal(&thd->data_cond);
-		pthread_mutex_unlock(&thd->data_mutex);
-
-		len -= bytes_processed - crypt_file->buf_len;
-		buf += bytes_processed - crypt_file->buf_len;
-
-		/* reap */
-
-		pthread_mutex_lock(&thd->data_mutex);
-		while (thd->data_avail == TRUE) {
-			pthread_cond_wait(&thd->data_cond,
-					  &thd->data_mutex);
-		}
-
-		if (thd->failed) {
-			msg("decrypt: failed to decrypt chunk.\n");
-			err = TRUE;
-		}
-
-		xb_a(thd->to_len > 0);
-
-		if (!err &&
-		    ds_write(crypt_file->dest_file, thd->to, thd->to_len)) {
-			msg("decrypt: write to destination failed.\n");
-			err = TRUE;
-		}
-
-		crypt_file->bytes_processed += thd->from_len;
-
-		pthread_mutex_unlock(&thd->data_mutex);
-		pthread_mutex_unlock(&thd->ctrl_mutex);
-
-		crypt_file->buf_len = 0;
-
-		if (err) {
-			return 1;
-		}
-	}
-
-	while (parse_result == XB_CRYPT_READ_CHUNK && len > 0) {
-		uint max_thread;
-
-		for (i = 0; i < nthreads; i++) {
-			thd = threads + i;
-
-			pthread_mutex_lock(&thd->ctrl_mutex);
-
-			parse_result = parse_xbcrypt_chunk(
-				thd, buf, len, &bytes_processed);
-
-			if (parse_result == XB_CRYPT_READ_ERROR) {
-				pthread_mutex_unlock(&thd->ctrl_mutex);
-				err = TRUE;
-				break;
-			}
-
-			thd->parse_result = parse_result;
-
-			if (parse_result != XB_CRYPT_READ_CHUNK) {
-				pthread_mutex_unlock(&thd->ctrl_mutex);
-				break;
-			}
-
-			pthread_mutex_lock(&thd->data_mutex);
-			thd->data_avail = TRUE;
-			pthread_cond_signal(&thd->data_cond);
-			pthread_mutex_unlock(&thd->data_mutex);
-
-			len -= bytes_processed;
-			buf += bytes_processed;
-		}
-
-		max_thread = (i < nthreads) ? i :  nthreads - 1;
-
-		/* Reap and write decrypted data */
-		for (i = 0; i <= max_thread; i++) {
-			thd = threads + i;
-
-			if (thd->parse_result != XB_CRYPT_READ_CHUNK) {
-				break;
-			}
-
-			pthread_mutex_lock(&thd->data_mutex);
-			while (thd->data_avail == TRUE) {
-				pthread_cond_wait(&thd->data_cond,
-						  &thd->data_mutex);
-			}
-
-			if (thd->failed) {
-				msg("decrypt: failed to decrypt chunk.\n");
-				err = TRUE;
-			}
-
-			xb_a(thd->to_len > 0);
-
-			if (!err && ds_write(crypt_file->dest_file, thd->to,
-				     thd->to_len)) {
-				msg("decrypt: write to destination failed.\n");
-				err = TRUE;
-			}
-
-			crypt_file->bytes_processed += thd->from_len;
-
-			pthread_mutex_unlock(&thd->data_mutex);
-			pthread_mutex_unlock(&thd->ctrl_mutex);
-		}
-
-		if (err) {
-			return 1;
-		}
-	}
-
-	if (parse_result == XB_CRYPT_READ_INCOMPLETE && len > 0) {
-		crypt_file->buf_len = len;
-		if (crypt_file->buf_size < len) {
-			crypt_file->buf = (uchar *) my_realloc(
-					crypt_file->buf,
-					crypt_file->buf_len,
-					MYF(MY_FAE | MY_ALLOW_ZERO_PTR));
-			crypt_file->buf_size = len;
-		}
-		memcpy(crypt_file->buf, buf, len);
-	}
-
-	return 0;
-}
-
-static
-int
-decrypt_close(ds_file_t *file)
-{
-	ds_decrypt_file_t	*crypt_file;
-	ds_file_t		*dest_file;
-	int			rc = 0;
-
-	crypt_file = (ds_decrypt_file_t *) file->ptr;
-	dest_file = crypt_file->dest_file;
-
-	if (ds_close(dest_file)) {
-		rc = 1;
-	}
-
-	my_free(crypt_file->buf);
-	my_free(file);
-
-	return rc;
-}
-
-static
-void
-decrypt_deinit(ds_ctxt_t *ctxt)
-{
-	ds_decrypt_ctxt_t 	*crypt_ctxt;
-
-	xb_ad(ctxt->pipe_ctxt != NULL);
-
-	crypt_ctxt = (ds_decrypt_ctxt_t *) ctxt->ptr;
-
-	destroy_worker_threads(crypt_ctxt->threads, crypt_ctxt->nthreads);
-
-	my_free(ctxt->root);
-	my_free(ctxt);
-}
-
-static
-crypt_thread_ctxt_t *
-create_worker_threads(uint n)
-{
-	crypt_thread_ctxt_t	*threads;
-	uint 			i;
-
-	threads = (crypt_thread_ctxt_t *)
-		my_malloc(sizeof(crypt_thread_ctxt_t) * n,
-			  MYF(MY_FAE | MY_ZEROFILL));
-
-	for (i = 0; i < n; i++) {
-		crypt_thread_ctxt_t *thd = threads + i;
-
-		thd->num = i + 1;
-
-		/* Initialize the control mutex and condition var */
-		if (pthread_mutex_init(&thd->ctrl_mutex, NULL) ||
-		    pthread_cond_init(&thd->ctrl_cond, NULL)) {
-			goto err;
-		}
-
-		/* Initialize and data mutex and condition var */
-		if (pthread_mutex_init(&thd->data_mutex, NULL) ||
-		    pthread_cond_init(&thd->data_cond, NULL)) {
-			goto err;
-		}
-
-		xb_crypt_cipher_open(&thd->cipher_handle);
-
-		pthread_mutex_lock(&thd->ctrl_mutex);
-
-		if (pthread_create(&thd->id, NULL, decrypt_worker_thread_func,
-				   thd)) {
-			msg("decrypt: pthread_create() failed: "
-			    "errno = %d\n", errno);
-			goto err;
-		}
-	}
-
-	/* Wait for the threads to start */
-	for (i = 0; i < n; i++) {
-		crypt_thread_ctxt_t *thd = threads + i;
-
-		while (thd->started == FALSE)
-			pthread_cond_wait(&thd->ctrl_cond, &thd->ctrl_mutex);
-		pthread_mutex_unlock(&thd->ctrl_mutex);
-	}
-
-	return threads;
-
-err:
-	return NULL;
-}
-
-static
-void
-destroy_worker_threads(crypt_thread_ctxt_t *threads, uint n)
-{
-	uint i;
-
-	for (i = 0; i < n; i++) {
-		crypt_thread_ctxt_t *thd = threads + i;
-
-		pthread_mutex_lock(&thd->data_mutex);
-		threads[i].cancelled = TRUE;
-		pthread_cond_signal(&thd->data_cond);
-		pthread_mutex_unlock(&thd->data_mutex);
-
-		pthread_join(thd->id, NULL);
-
-		pthread_cond_destroy(&thd->data_cond);
-		pthread_mutex_destroy(&thd->data_mutex);
-		pthread_cond_destroy(&thd->ctrl_cond);
-		pthread_mutex_destroy(&thd->ctrl_mutex);
-
-		xb_crypt_cipher_close(thd->cipher_handle);
-
-		my_free(thd->to);
-	}
-
-	my_free(threads);
-}
-
-static
-void *
-decrypt_worker_thread_func(void *arg)
-{
-	crypt_thread_ctxt_t *thd = (crypt_thread_ctxt_t *) arg;
-
-	pthread_mutex_lock(&thd->ctrl_mutex);
-
-	pthread_mutex_lock(&thd->data_mutex);
-
-	thd->started = TRUE;
-	pthread_cond_signal(&thd->ctrl_cond);
-
-	pthread_mutex_unlock(&thd->ctrl_mutex);
-
-	while (1) {
-		thd->data_avail = FALSE;
-		pthread_cond_signal(&thd->data_cond);
-
-		while (!thd->data_avail && !thd->cancelled) {
-			pthread_cond_wait(&thd->data_cond, &thd->data_mutex);
-		}
-
-		if (thd->cancelled)
-			break;
-
-		if (xb_crypt_decrypt(thd->cipher_handle, thd->from,
-				     thd->from_len, thd->to, &thd->to_len,
-				     thd->iv, thd->iv_len,
-				     thd->hash_appended)) {
-			thd->failed = TRUE;
-			continue;
-		}
-
-	}
-
-	pthread_mutex_unlock(&thd->data_mutex);
-
-	return NULL;
-}
diff --git a/extra/mariabackup/ds_decrypt.h b/extra/mariabackup/ds_decrypt.h
deleted file mode 100644
index 3bb4de55f54..00000000000
--- a/extra/mariabackup/ds_decrypt.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/******************************************************
-Copyright (c) 2017 Percona LLC and/or its affiliates.
-
-Encryption interface for XtraBackup.
-
-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-1301, USA
-
-*******************************************************/
-
-#ifndef DS_DECRYPT_H
-#define DS_DECRYPT_H
-
-#include "datasink.h"
-
-extern datasink_t	datasink_decrypt;
-
-extern int		ds_decrypt_encrypt_threads;
-
-#endif
diff --git a/extra/mariabackup/ds_encrypt.c b/extra/mariabackup/ds_encrypt.c
deleted file mode 100644
index 576ea207eb1..00000000000
--- a/extra/mariabackup/ds_encrypt.c
+++ /dev/null
@@ -1,446 +0,0 @@
-/******************************************************
-Copyright (c) 2013 Percona LLC and/or its affiliates.
-
-Encryption datasink implementation for XtraBackup.
-
-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-1301, USA
-
-*******************************************************/
-
-
-#include <my_base.h>
-#include "common.h"
-#include "datasink.h"
-#include "xbcrypt_common.h"
-#ifdef HAVE_GRYPT
-#include "xbcrypt.h"
-
-#define XB_CRYPT_CHUNK_SIZE ((size_t) (ds_encrypt_encrypt_chunk_size))
-
-typedef struct {
-	pthread_t		id;
-	uint			num;
-	pthread_mutex_t 	ctrl_mutex;
-	pthread_cond_t		ctrl_cond;
-	pthread_mutex_t		data_mutex;
-	pthread_cond_t  	data_cond;
-	my_bool			started;
-	my_bool			data_avail;
-	my_bool			cancelled;
-	const uchar 		*from;
-	size_t			from_len;
-	uchar			*to;
-	uchar			*iv;
-	size_t			to_len;
-	gcry_cipher_hd_t	cipher_handle;
-} crypt_thread_ctxt_t;
-
-typedef struct {
-	crypt_thread_ctxt_t	*threads;
-	uint			nthreads;
-} ds_encrypt_ctxt_t;
-
-typedef struct {
-	xb_wcrypt_t		*xbcrypt_file;
-	ds_encrypt_ctxt_t	*crypt_ctxt;
-	size_t			bytes_processed;
-	ds_file_t		*dest_file;
-} ds_encrypt_file_t;
-
-/* Encryption options */
-uint		ds_encrypt_encrypt_threads;
-ulonglong	ds_encrypt_encrypt_chunk_size;
-
-static ds_ctxt_t *encrypt_init(const char *root);
-static ds_file_t *encrypt_open(ds_ctxt_t *ctxt, const char *path,
-				MY_STAT *mystat);
-static int encrypt_write(ds_file_t *file, const void *buf, size_t len);
-static int encrypt_close(ds_file_t *file);
-static void encrypt_deinit(ds_ctxt_t *ctxt);
-
-datasink_t datasink_encrypt = {
-	&encrypt_init,
-	&encrypt_open,
-	&encrypt_write,
-	&encrypt_close,
-	&encrypt_deinit
-};
-
-static crypt_thread_ctxt_t *create_worker_threads(uint n);
-static void destroy_worker_threads(crypt_thread_ctxt_t *threads, uint n);
-static void *encrypt_worker_thread_func(void *arg);
-
-static uint encrypt_iv_len = 0;
-
-static
-ssize_t
-my_xb_crypt_write_callback(void *userdata, const void *buf, size_t len)
-{
-	ds_encrypt_file_t		*encrypt_file;
-
-	encrypt_file = (ds_encrypt_file_t *) userdata;
-
-	xb_ad(encrypt_file != NULL);
-	xb_ad(encrypt_file->dest_file != NULL);
-
-	if (!ds_write(encrypt_file->dest_file, buf, len)) {
-		return len;
-	}
-	return -1;
-}
-
-static
-ds_ctxt_t *
-encrypt_init(const char *root)
-{
-	ds_ctxt_t		*ctxt;
-	ds_encrypt_ctxt_t	*encrypt_ctxt;
-	crypt_thread_ctxt_t	*threads;
-
-	if (xb_crypt_init(&encrypt_iv_len)) {
-		return NULL;
-	}
-
-	/* Create and initialize the worker threads */
-	threads = create_worker_threads(ds_encrypt_encrypt_threads);
-	if (threads == NULL) {
-		msg("encrypt: failed to create worker threads.\n");
-		return NULL;
-	}
-
-	ctxt = (ds_ctxt_t *) my_malloc(sizeof(ds_ctxt_t) +
-				       sizeof(ds_encrypt_ctxt_t),
-				       MYF(MY_FAE));
-
-	encrypt_ctxt = (ds_encrypt_ctxt_t *) (ctxt + 1);
-	encrypt_ctxt->threads = threads;
-	encrypt_ctxt->nthreads = ds_encrypt_encrypt_threads;
-
-	ctxt->ptr = encrypt_ctxt;
-	ctxt->root = my_strdup(root, MYF(MY_FAE));
-
-	return ctxt;
-}
-
-static
-ds_file_t *
-encrypt_open(ds_ctxt_t *ctxt, const char *path, MY_STAT *mystat)
-{
-	ds_ctxt_t		*dest_ctxt;
-
-	ds_encrypt_ctxt_t	*crypt_ctxt;
-	ds_encrypt_file_t	*crypt_file;
-
-	char			new_name[FN_REFLEN];
-	ds_file_t		*file;
-
-	xb_ad(ctxt->pipe_ctxt != NULL);
-	dest_ctxt = ctxt->pipe_ctxt;
-
-	crypt_ctxt = (ds_encrypt_ctxt_t *) ctxt->ptr;
-
-
-	file = (ds_file_t *) my_malloc(sizeof(ds_file_t) +
-				       sizeof(ds_encrypt_file_t),
-				       MYF(MY_FAE|MY_ZEROFILL));
-
-	crypt_file = (ds_encrypt_file_t *) (file + 1);
-
-	/* Append the .xbcrypt extension to the filename */
-	fn_format(new_name, path, "", ".xbcrypt", MYF(MY_APPEND_EXT));
-	crypt_file->dest_file = ds_open(dest_ctxt, new_name, mystat);
-	if (crypt_file->dest_file == NULL) {
-		msg("encrypt: ds_open(\"%s\") failed.\n", new_name);
-		goto err;
-	}
-
-	crypt_file->crypt_ctxt = crypt_ctxt;
-	crypt_file->xbcrypt_file = xb_crypt_write_open(crypt_file,
-					   my_xb_crypt_write_callback);
-
-	if (crypt_file->xbcrypt_file == NULL) {
-		msg("encrypt: xb_crypt_write_open() failed.\n");
-		goto err;
-	}
-
-
-	file->ptr = crypt_file;
-	file->path = crypt_file->dest_file->path;
-
-	return file;
-
-err:
-	if (crypt_file->dest_file) {
-		ds_close(crypt_file->dest_file);
-	}
-	my_free(file);
-	return NULL;
-}
-
-static
-int
-encrypt_write(ds_file_t *file, const void *buf, size_t len)
-{
-	ds_encrypt_file_t	*crypt_file;
-	ds_encrypt_ctxt_t	*crypt_ctxt;
-	crypt_thread_ctxt_t	*threads;
-	crypt_thread_ctxt_t	*thd;
-	uint			nthreads;
-	uint			i;
-	const uchar		*ptr;
-
-	crypt_file = (ds_encrypt_file_t *) file->ptr;
-	crypt_ctxt = crypt_file->crypt_ctxt;
-
-	threads = crypt_ctxt->threads;
-	nthreads = crypt_ctxt->nthreads;
-
-	ptr = (const uchar *) buf;
-	while (len > 0) {
-		uint max_thread;
-
-		/* Send data to worker threads for encryption */
-		for (i = 0; i < nthreads; i++) {
-			size_t chunk_len;
-
-			thd = threads + i;
-
-			pthread_mutex_lock(&thd->ctrl_mutex);
-
-			chunk_len = (len > XB_CRYPT_CHUNK_SIZE) ?
-				XB_CRYPT_CHUNK_SIZE : len;
-			thd->from = ptr;
-			thd->from_len = chunk_len;
-
-			pthread_mutex_lock(&thd->data_mutex);
-			thd->data_avail = TRUE;
-			pthread_cond_signal(&thd->data_cond);
-			pthread_mutex_unlock(&thd->data_mutex);
-
-			len -= chunk_len;
-			if (len == 0) {
-				break;
-			}
-			ptr += chunk_len;
-		}
-
-		max_thread = (i < nthreads) ? i :  nthreads - 1;
-
-		/* Reap and stream the encrypted data */
-		for (i = 0; i <= max_thread; i++) {
-			thd = threads + i;
-
-			pthread_mutex_lock(&thd->data_mutex);
-			while (thd->data_avail == TRUE) {
-				pthread_cond_wait(&thd->data_cond,
-						  &thd->data_mutex);
-			}
-
-			xb_a(threads[i].to_len > 0);
-
-			if (xb_crypt_write_chunk(crypt_file->xbcrypt_file,
-						 threads[i].to,
-						 threads[i].from_len +
-							XB_CRYPT_HASH_LEN,
-						 threads[i].to_len,
-						 threads[i].iv,
-						 encrypt_iv_len)) {
-				msg("encrypt: write to the destination file "
-				    "failed.\n");
-				return 1;
-			}
-
-			crypt_file->bytes_processed += threads[i].from_len;
-
-			pthread_mutex_unlock(&threads[i].data_mutex);
-			pthread_mutex_unlock(&threads[i].ctrl_mutex);
-		}
-	}
-
-	return 0;
-}
-
-static
-int
-encrypt_close(ds_file_t *file)
-{
-	ds_encrypt_file_t	*crypt_file;
-	ds_file_t		*dest_file;
-	int			rc = 0;
-
-	crypt_file = (ds_encrypt_file_t *) file->ptr;
-	dest_file = crypt_file->dest_file;
-
-	rc = xb_crypt_write_close(crypt_file->xbcrypt_file);
-
-	if (ds_close(dest_file)) {
-		rc = 1;
-	}
-
-	my_free(file);
-
-	return rc;
-}
-
-static
-void
-encrypt_deinit(ds_ctxt_t *ctxt)
-{
-	ds_encrypt_ctxt_t 	*crypt_ctxt;
-
-	xb_ad(ctxt->pipe_ctxt != NULL);
-
-	crypt_ctxt = (ds_encrypt_ctxt_t *) ctxt->ptr;
-
-	destroy_worker_threads(crypt_ctxt->threads, crypt_ctxt->nthreads);
-
-	my_free(ctxt->root);
-	my_free(ctxt);
-}
-
-static
-crypt_thread_ctxt_t *
-create_worker_threads(uint n)
-{
-	crypt_thread_ctxt_t	*threads;
-	uint 			i;
-
-	threads = (crypt_thread_ctxt_t *)
-		my_malloc(sizeof(crypt_thread_ctxt_t) * n, MYF(MY_FAE));
-
-	for (i = 0; i < n; i++) {
-		crypt_thread_ctxt_t *thd = threads + i;
-
-		thd->num = i + 1;
-		thd->started = FALSE;
-		thd->cancelled = FALSE;
-		thd->data_avail = FALSE;
-
-		thd->to = (uchar *) my_malloc(XB_CRYPT_CHUNK_SIZE +
-					      XB_CRYPT_HASH_LEN, MYF(MY_FAE));
-
-		thd->iv = (uchar *) my_malloc(encrypt_iv_len, MYF(MY_FAE));
-
-		/* Initialize the control mutex and condition var */
-		if (pthread_mutex_init(&thd->ctrl_mutex, NULL) ||
-		    pthread_cond_init(&thd->ctrl_cond, NULL)) {
-			goto err;
-		}
-
-		/* Initialize and data mutex and condition var */
-		if (pthread_mutex_init(&thd->data_mutex, NULL) ||
-		    pthread_cond_init(&thd->data_cond, NULL)) {
-			goto err;
-		}
-
-		if (xb_crypt_cipher_open(&thd->cipher_handle)) {
-			goto err;
-		}
-
-		pthread_mutex_lock(&thd->ctrl_mutex);
-
-		if (pthread_create(&thd->id, NULL, encrypt_worker_thread_func,
-				   thd)) {
-			msg("encrypt: pthread_create() failed: "
-			    "errno = %d\n", errno);
-			goto err;
-		}
-	}
-
-	/* Wait for the threads to start */
-	for (i = 0; i < n; i++) {
-		crypt_thread_ctxt_t *thd = threads + i;
-
-		while (thd->started == FALSE)
-			pthread_cond_wait(&thd->ctrl_cond, &thd->ctrl_mutex);
-		pthread_mutex_unlock(&thd->ctrl_mutex);
-	}
-
-	return threads;
-
-err:
-	return NULL;
-}
-
-static
-void
-destroy_worker_threads(crypt_thread_ctxt_t *threads, uint n)
-{
-	uint i;
-
-	for (i = 0; i < n; i++) {
-		crypt_thread_ctxt_t *thd = threads + i;
-
-		pthread_mutex_lock(&thd->data_mutex);
-		threads[i].cancelled = TRUE;
-		pthread_cond_signal(&thd->data_cond);
-		pthread_mutex_unlock(&thd->data_mutex);
-
-		pthread_join(thd->id, NULL);
-
-		pthread_cond_destroy(&thd->data_cond);
-		pthread_mutex_destroy(&thd->data_mutex);
-		pthread_cond_destroy(&thd->ctrl_cond);
-		pthread_mutex_destroy(&thd->ctrl_mutex);
-
-		xb_crypt_cipher_close(thd->cipher_handle);
-
-		my_free(thd->to);
-		my_free(thd->iv);
-	}
-
-	my_free(threads);
-}
-
-static
-void *
-encrypt_worker_thread_func(void *arg)
-{
-	crypt_thread_ctxt_t *thd = (crypt_thread_ctxt_t *) arg;
-
-	pthread_mutex_lock(&thd->ctrl_mutex);
-
-	pthread_mutex_lock(&thd->data_mutex);
-
-	thd->started = TRUE;
-	pthread_cond_signal(&thd->ctrl_cond);
-
-	pthread_mutex_unlock(&thd->ctrl_mutex);
-
-	while (1) {
-		thd->data_avail = FALSE;
-		pthread_cond_signal(&thd->data_cond);
-
-		while (!thd->data_avail && !thd->cancelled) {
-			pthread_cond_wait(&thd->data_cond, &thd->data_mutex);
-		}
-
-		if (thd->cancelled)
-			break;
-
-		thd->to_len = thd->from_len;
-
-		if (xb_crypt_encrypt(thd->cipher_handle, thd->from,
-				     thd->from_len, thd->to, &thd->to_len,
-				     thd->iv)) {
-			thd->to_len = 0;
-			continue;
-		}
-	}
-
-	pthread_mutex_unlock(&thd->data_mutex);
-
-	return NULL;
-}
-#endif /* HAVE_GCRYPT*/
diff --git a/extra/mariabackup/ds_encrypt.h b/extra/mariabackup/ds_encrypt.h
deleted file mode 100644
index c4d8d7f8427..00000000000
--- a/extra/mariabackup/ds_encrypt.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/******************************************************
-Copyright (c) 2013 Percona LLC and/or its affiliates.
-
-Encryption interface for XtraBackup.
-
-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-1301, USA
-
-*******************************************************/
-
-#ifndef DS_ENCRYPT_H
-#define DS_ENCRYPT_H
-
-#include "datasink.h"
-#ifdef HAVE_GCRYPT
-extern datasink_t datasink_encrypt;
-#endif
-/* Encryption options */
-extern uint		ds_encrypt_encrypt_threads;
-extern ulonglong	ds_encrypt_encrypt_chunk_size;
-
-
-#endif
diff --git a/extra/mariabackup/encryption_plugin.cc b/extra/mariabackup/encryption_plugin.cc
index 9f2782d89a1..8f7741b057a 100644
--- a/extra/mariabackup/encryption_plugin.cc
+++ b/extra/mariabackup/encryption_plugin.cc
@@ -126,7 +126,6 @@ void encryption_plugin_prepare_init(int argc, char **argv)
 
   if (!xb_plugin_load)
   {
-    /* This prevents crashes e.g in --stats with wrong my.cnf*/
     finalize_encryption_plugin(0);
     return;
   }
diff --git a/extra/mariabackup/innobackupex.cc b/extra/mariabackup/innobackupex.cc
index 2114e546440..7e97b258489 100644
--- a/extra/mariabackup/innobackupex.cc
+++ b/extra/mariabackup/innobackupex.cc
@@ -101,8 +101,6 @@ char *opt_ibx_login_path = NULL;
 ulong opt_ibx_lock_wait_query_type;
 ulong opt_ibx_kill_long_query_type;
 
-ulong opt_ibx_decrypt_algo = 0;
-
 uint opt_ibx_kill_long_queries_timeout = 0;
 uint opt_ibx_lock_wait_timeout = 0;
 uint opt_ibx_lock_wait_threshold = 0;
@@ -110,7 +108,6 @@ uint opt_ibx_debug_sleep_before_unlock = 0;
 uint opt_ibx_safe_slave_backup_timeout = 0;
 
 const char *opt_ibx_history = NULL;
-bool opt_ibx_decrypt = false;
 
 char *opt_ibx_include = NULL;
 char *opt_ibx_databases = NULL;
@@ -121,15 +118,9 @@ char *ibx_backup_directory = NULL;
 
 /* copy of proxied xtrabackup options */
 my_bool ibx_xb_close_files;
-my_bool	ibx_xtrabackup_compact;
 const char *ibx_xtrabackup_compress_alg;
 uint ibx_xtrabackup_compress_threads;
 ulonglong ibx_xtrabackup_compress_chunk_size;
-ulong ibx_xtrabackup_encrypt_algo;
-char *ibx_xtrabackup_encrypt_key;
-char *ibx_xtrabackup_encrypt_key_file;
-uint ibx_xtrabackup_encrypt_threads;
-ulonglong ibx_xtrabackup_encrypt_chunk_size;
 my_bool ibx_xtrabackup_export;
 char *ibx_xtrabackup_extra_lsndir;
 char *ibx_xtrabackup_incremental_basedir;
@@ -138,8 +129,6 @@ my_bool	ibx_xtrabackup_incremental_force_scan;
 ulint ibx_xtrabackup_log_copy_interval;
 char *ibx_xtrabackup_incremental;
 int ibx_xtrabackup_parallel;
-my_bool ibx_xtrabackup_rebuild_indexes;
-ulint ibx_xtrabackup_rebuild_threads;
 char *ibx_xtrabackup_stream_str;
 char *ibx_xtrabackup_tables_file;
 long ibx_xtrabackup_throttle;
@@ -201,7 +190,6 @@ enum innobackupex_options
 	OPT_NO_VERSION_CHECK,
 	OPT_NO_BACKUP_LOCKS,
 	OPT_DATABASES,
-	OPT_DECRYPT,
 	OPT_DECOMPRESS,
 
 	/* options wich are passed directly to xtrabackup */
@@ -210,11 +198,6 @@ enum innobackupex_options
 	OPT_COMPRESS,
 	OPT_COMPRESS_THREADS,
 	OPT_COMPRESS_CHUNK_SIZE,
-	OPT_ENCRYPT,
-	OPT_ENCRYPT_KEY,
-	OPT_ENCRYPT_KEY_FILE,
-	OPT_ENCRYPT_THREADS,
-	OPT_ENCRYPT_CHUNK_SIZE,
 	OPT_EXPORT,
 	OPT_EXTRA_LSNDIR,
 	OPT_INCREMENTAL_BASEDIR,
@@ -430,12 +413,6 @@ static struct my_option ibx_long_options[] =
 	 (uchar*) &opt_ibx_incremental_history_uuid, 0, GET_STR,
 	 REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
-	{"decrypt", OPT_DECRYPT, "Decrypts all files with the .xbcrypt "
-	 "extension in a backup previously made with --encrypt option.",
-	 &opt_ibx_decrypt_algo, &opt_ibx_decrypt_algo,
-	 &xtrabackup_encrypt_algo_typelib, GET_ENUM, REQUIRED_ARG,
-	 0, 0, 0, 0, 0, 0},
-
 	{"ftwrl-wait-query-type", OPT_LOCK_WAIT_QUERY_TYPE,
 	 "This option specifies which types of queries are allowed to complete "
 	 "before innobackupex will issue the global lock. Default is all.",
@@ -533,12 +510,6 @@ static struct my_option ibx_long_options[] =
 	 (uchar*) &ibx_xb_close_files, (uchar*) &ibx_xb_close_files, 0,
 	 GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
-	{"compact", OPT_COMPACT, "Create a compact backup with all secondary "
-	 "index pages omitted. This option is passed directly to xtrabackup. "
-	 "See xtrabackup documentation for details.",
-	 (uchar*) &ibx_xtrabackup_compact, (uchar*) &ibx_xtrabackup_compact,
-	 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-
 	{"compress", OPT_COMPRESS, "This option instructs xtrabackup to "
 	 "compress backup copies of InnoDB data files. It is passed directly "
 	 "to the xtrabackup child process. Try 'xtrabackup --help' for more "
@@ -560,46 +531,6 @@ static struct my_option ibx_long_options[] =
 	 (uchar*) &ibx_xtrabackup_compress_chunk_size,
 	 0, GET_ULL, REQUIRED_ARG, (1 << 16), 1024, ULONGLONG_MAX, 0, 0, 0},
 
-	{"encrypt", OPT_ENCRYPT, "This option instructs xtrabackup to encrypt "
-	 "backup copies of InnoDB data files using the algorithm specified in "
-	 "the ENCRYPTION-ALGORITHM. It is passed directly to the xtrabackup "
-	 "child process. Try 'xtrabackup --help' for more details.",
-	 &ibx_xtrabackup_encrypt_algo, &ibx_xtrabackup_encrypt_algo,
-	 &xtrabackup_encrypt_algo_typelib, GET_ENUM, REQUIRED_ARG,
-	 0, 0, 0, 0, 0, 0},
-
-	{"encrypt-key", OPT_ENCRYPT_KEY, "This option instructs xtrabackup to "
-	 "use the given ENCRYPTION-KEY when using the --encrypt or --decrypt "
-	 "options. During backup it is passed directly to the xtrabackup child "
-	 "process. Try 'xtrabackup --help' for more details.",
-	 (uchar*) &ibx_xtrabackup_encrypt_key,
-	 (uchar*) &ibx_xtrabackup_encrypt_key, 0,
-	 GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"encrypt-key-file", OPT_ENCRYPT_KEY_FILE, "This option instructs "
-	 "xtrabackup to use the encryption key stored in the given "
-	 "ENCRYPTION-KEY-FILE when using the --encrypt or --decrypt options.",
-	 (uchar*) &ibx_xtrabackup_encrypt_key_file,
-	 (uchar*) &ibx_xtrabackup_encrypt_key_file, 0,
-	 GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"encrypt-threads", OPT_ENCRYPT_THREADS,
-	 "This option specifies the number of worker threads that will be used "
-	 "for parallel encryption. It is passed directly to the xtrabackup "
-	 "child process. Try 'xtrabackup --help' for more details.",
-	 (uchar*) &ibx_xtrabackup_encrypt_threads,
-	 (uchar*) &ibx_xtrabackup_encrypt_threads,
-	 0, GET_UINT, REQUIRED_ARG, 1, 1, UINT_MAX, 0, 0, 0},
-
-	{"encrypt-chunk-size", OPT_ENCRYPT_CHUNK_SIZE,
-	 "This option specifies the size of the internal working buffer for "
-	 "each encryption thread, measured in bytes. It is passed directly to "
-	 "the xtrabackup child process. Try 'xtrabackup --help' for more "
-	 "details.",
-	 (uchar*) &ibx_xtrabackup_encrypt_chunk_size,
-	 (uchar*) &ibx_xtrabackup_encrypt_chunk_size,
-	 0, GET_ULL, REQUIRED_ARG, (1 << 16), 1024, ULONGLONG_MAX, 0, 0, 0},
-
 	{"export", OPT_EXPORT, "This option is passed directly to xtrabackup's "
 	 "--export option. It enables exporting individual tables for import "
 	 "into another server. See the xtrabackup documentation for details.",
@@ -735,8 +666,6 @@ You can download full text of the license on http://www.gnu.org/licenses/gpl-2.0
 SYNOPOSIS\n\
 \n\
 innobackupex [--compress] [--compress-threads=NUMBER-OF-THREADS] [--compress-chunk-size=CHUNK-SIZE]\n\
-             [--encrypt=ENCRYPTION-ALGORITHM] [--encrypt-threads=NUMBER-OF-THREADS] [--encrypt-chunk-size=CHUNK-SIZE]\n\
-             [--encrypt-key=LITERAL-ENCRYPTION-KEY] | [--encryption-key-file=MY.KEY]\n\
              [--include=REGEXP] [--user=NAME]\n\
              [--password=WORD] [--port=PORT] [--socket=SOCKET]\n\
              [--no-timestamp] [--ibbackup=IBBACKUP-BINARY]\n\
@@ -748,7 +677,7 @@ innobackupex [--compress] [--compress-threads=NUMBER-OF-THREADS] [--compress-chu
              [--incremental] [--incremental-basedir]\n\
              [--incremental-dir] [--incremental-force-scan] [--incremental-lsn]\n\
              [--incremental-history-name=NAME] [--incremental-history-uuid=UUID]\n\
-             [--close-files] [--compact]     \n\
+             [--close-files]\n\
              BACKUP-ROOT-DIR\n\
 \n\
 innobackupex --apply-log [--use-memory=B]\n\
@@ -760,8 +689,7 @@ innobackupex --copy-back [--defaults-file=MY.CNF] [--defaults-group=GROUP-NAME]
 \n\
 innobackupex --move-back [--defaults-file=MY.CNF] [--defaults-group=GROUP-NAME] BACKUP-DIR\n\
 \n\
-innobackupex [--decompress] [--decrypt=ENCRYPTION-ALGORITHM]\n\
-             [--encrypt-key=LITERAL-ENCRYPTION-KEY] | [--encryption-key-file=MY.KEY]\n\
+innobackupex [--decompress]\n\
              [--parallel=NUMBER-OF-FORKS] BACKUP-DIR\n\
 \n\
 DESCRIPTION\n\
@@ -798,15 +726,12 @@ it moves files to their original locations rather than copies them. As this\n\
 option removes backup files, it must be used with caution. It may be useful in\n\
 cases when there is not enough free disk space to copy files.\n\
 \n\
-The --decompress --decrypt command will decrypt and/or decompress a backup made\n\
-with the --compress and/or --encrypt options. When decrypting, the encryption\n\
-algorithm and key used when the backup was taken MUST be provided via the\n\
-specified options. --decrypt and --decompress may be used together at the same\n\
-time to completely normalize a previously compressed and encrypted backup. The\n\
---parallel option will allow multiple files to be decrypted and/or decompressed\n\
+The --decompress command will decompress a backup made\n\
+with the --compress option. The\n\
+--parallel option will allow multiple files to be decompressed\n\
 simultaneously. In order to decompress, the qpress utility MUST be installed\n\
 and accessable within the path. This process will remove the original\n\
-compressed/encrypted files and leave the results in the same location.\n\
+compressed files and leave the results in the same location.\n\
 \n\
 On success the exit code innobackupex is 0. A non-zero exit code \n\
 indicates an error.\n");
@@ -839,14 +764,6 @@ ibx_get_one_option(int optid,
 			opt_ibx_history = "";
 		}
 		break;
-	case OPT_DECRYPT:
-		if (argument == NULL) {
-			ibx_msg("Missing --decrypt argument, must specify a "
-				"valid encryption  algorithm.\n");
-			return(1);
-		}
-		opt_ibx_decrypt = true;
-		break;
 	case OPT_STREAM:
     if (!strcasecmp(argument, "xbstream"))
 			xtrabackup_stream_fmt = XB_STREAM_FMT_XBSTREAM;
@@ -866,15 +783,6 @@ ibx_get_one_option(int optid,
 		}
 		xtrabackup_compress = TRUE;
 		break;
-	case OPT_ENCRYPT:
-		if (argument == NULL)
-		{
-			msg("Missing --encrypt argument, must specify a "
-				"valid encryption algorithm.\n");
-			return 1;
-		}
-		xtrabackup_encrypt = TRUE;
-		break;
 	case 'p':
 		if (argument)
 		{
@@ -928,7 +836,7 @@ ibx_handle_options(int *argc, char ***argv)
 		ibx_mode = IBX_MODE_COPY_BACK;
 	} else if (opt_ibx_move_back) {
 		ibx_mode = IBX_MODE_MOVE_BACK;
-	} else if (opt_ibx_decrypt || opt_ibx_decompress) {
+	} else if (opt_ibx_decompress) {
 		ibx_mode = IBX_MODE_DECRYPT_DECOMPRESS;
 	} else {
 		ibx_mode = IBX_MODE_BACKUP;
@@ -1006,8 +914,6 @@ ibx_init()
 	opt_lock_wait_query_type = opt_ibx_lock_wait_query_type;
 	opt_kill_long_query_type = opt_ibx_kill_long_query_type;
 
-	opt_decrypt_algo = opt_ibx_decrypt_algo;
-
 	opt_kill_long_queries_timeout = opt_ibx_kill_long_queries_timeout;
 	opt_lock_wait_timeout = opt_ibx_lock_wait_timeout;
 	opt_lock_wait_threshold = opt_ibx_lock_wait_threshold;
@@ -1015,18 +921,12 @@ ibx_init()
 	opt_safe_slave_backup_timeout = opt_ibx_safe_slave_backup_timeout;
 
 	opt_history = opt_ibx_history;
-	opt_decrypt = opt_ibx_decrypt;
 
 	/* setup xtrabackup options */
 	xb_close_files = ibx_xb_close_files;
 	xtrabackup_compress_alg = ibx_xtrabackup_compress_alg;
 	xtrabackup_compress_threads = ibx_xtrabackup_compress_threads;
 	xtrabackup_compress_chunk_size = ibx_xtrabackup_compress_chunk_size;
-	xtrabackup_encrypt_algo = ibx_xtrabackup_encrypt_algo;
-	xtrabackup_encrypt_key = ibx_xtrabackup_encrypt_key;
-	xtrabackup_encrypt_key_file = ibx_xtrabackup_encrypt_key_file;
-	xtrabackup_encrypt_threads = ibx_xtrabackup_encrypt_threads;
-	xtrabackup_encrypt_chunk_size = ibx_xtrabackup_encrypt_chunk_size;
 	xtrabackup_export = ibx_xtrabackup_export;
 	xtrabackup_extra_lsndir = ibx_xtrabackup_extra_lsndir;
 	xtrabackup_incremental_basedir = ibx_xtrabackup_incremental_basedir;
@@ -1107,7 +1007,7 @@ ibx_init()
 	case IBX_MODE_DECRYPT_DECOMPRESS:
 		xtrabackup_decrypt_decompress = TRUE;
 		xtrabackup_target_dir = ibx_position_arg;
-		run = "decrypt and decompress";
+		run = "decompress";
 		break;
 	default:
 		ut_error;
diff --git a/extra/mariabackup/xb0xb.h b/extra/mariabackup/xb0xb.h
index cb1aedd5d13..a8b17f59579 100644
--- a/extra/mariabackup/xb0xb.h
+++ b/extra/mariabackup/xb0xb.h
@@ -44,19 +44,6 @@ dberr_t*	err,	/*!< out: this is set to DB_ERROR if an error
                 os_file_dir_t	dir,	/*!< in: directory stream */
                 os_file_stat_t*	info)	/*!< in/out: buffer where the
                                       info is returned */;
-buf_block_t* btr_node_ptr_get_child(
-  const rec_t*	node_ptr,/*!< in: node pointer */
-  dict_index_t*	index,	/*!< in: index */
-  const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
-  mtr_t*		mtr)	/*!< in: mtr */;
-
-buf_block_t*
-btr_root_block_get(
-/*===============*/
-const dict_index_t*	index,	/*!< in: index tree */
-ulint			mode,	/*!< in: either RW_S_LATCH
-                or RW_X_LATCH */
-                mtr_t*			mtr)	/*!< in: mtr */;
 fil_space_t*
 fil_space_get_by_name(const char *);
 ibool
diff --git a/extra/mariabackup/xbcrypt.c b/extra/mariabackup/xbcrypt.c
deleted file mode 100644
index 3da70e171f7..00000000000
--- a/extra/mariabackup/xbcrypt.c
+++ /dev/null
@@ -1,696 +0,0 @@
-/******************************************************
-Copyright (c) 2013 Percona LLC and/or its affiliates.
-
-The xbcrypt utility: decrypt files in the XBCRYPT format.
-
-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-1301, USA
-
-*******************************************************/
-
-#include <my_base.h>
-#include <my_getopt.h>
-#include "common.h"
-#include "xbcrypt.h"
-#include "xbcrypt_common.h"
-#include "crc_glue.h"
-
-#if !defined(GCRYPT_VERSION_NUMBER) || (GCRYPT_VERSION_NUMBER < 0x010600)
-GCRY_THREAD_OPTION_PTHREAD_IMPL;
-#endif
-
-#define XBCRYPT_VERSION "1.1"
-
-typedef enum {
-	RUN_MODE_NONE,
-	RUN_MODE_ENCRYPT,
-	RUN_MODE_DECRYPT
-} run_mode_t;
-
-const char *xbcrypt_encrypt_algo_names[] =
-{ "NONE", "AES128", "AES192", "AES256", NullS};
-TYPELIB xbcrypt_encrypt_algo_typelib=
-{array_elements(xbcrypt_encrypt_algo_names)-1,"",
-	xbcrypt_encrypt_algo_names, NULL};
-
-static run_mode_t	opt_run_mode = RUN_MODE_ENCRYPT;
-static char 		*opt_input_file = NULL;
-static char 		*opt_output_file = NULL;
-static ulong 		opt_encrypt_algo;
-static char 		*opt_encrypt_key_file = NULL;
-static void 		*opt_encrypt_key = NULL;
-static ulonglong	opt_encrypt_chunk_size = 0;
-static my_bool		opt_verbose = FALSE;
-
-static uint 		encrypt_algos[] = { GCRY_CIPHER_NONE,
-					    GCRY_CIPHER_AES128,
-					    GCRY_CIPHER_AES192,
-					    GCRY_CIPHER_AES256 };
-static int		encrypt_algo = 0;
-static int		encrypt_mode = GCRY_CIPHER_MODE_CTR;
-static uint 		encrypt_key_len = 0;
-static size_t 		encrypt_iv_len = 0;
-
-static struct my_option my_long_options[] =
-{
-	{"help", '?', "Display this help and exit.",
-	 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"decrypt", 'd', "Decrypt data input to output.",
-	 0, 0, 0,
-	 GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"input", 'i', "Optional input file. If not specified, input"
-	 " will be read from standard input.",
-	 &opt_input_file, &opt_input_file, 0,
-	 GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"output", 'o', "Optional output file. If not specified, output"
-	 " will be written to standard output.",
-	 &opt_output_file, &opt_output_file, 0,
-	 GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"encrypt-algo", 'a', "Encryption algorithm.",
-	 &opt_encrypt_algo, &opt_encrypt_algo, &xbcrypt_encrypt_algo_typelib,
-	 GET_ENUM, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"encrypt-key", 'k', "Encryption key.",
-	 &opt_encrypt_key, &opt_encrypt_key, 0,
-	 GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"encrypt-key-file", 'f', "File which contains encryption key.",
-	 &opt_encrypt_key_file, &opt_encrypt_key_file, 0,
-	 GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-	{"encrypt-chunk-size", 's', "Size of working buffer for encryption in"
-	 " bytes. The default value is 64K.",
-	 &opt_encrypt_chunk_size, &opt_encrypt_chunk_size, 0,
-	GET_ULL, REQUIRED_ARG, (1 << 16), 1024, ULONGLONG_MAX, 0, 0, 0},
-
-	{"verbose", 'v', "Display verbose status output.",
-	 &opt_verbose, &opt_verbose,
-	  0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-	{0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
-};
-
-static
-int
-get_options(int *argc, char ***argv);
-
-static
-my_bool
-get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
-	       char *argument __attribute__((unused)));
-
-static
-void
-print_version(void);
-
-static
-void
-usage(void);
-
-static
-int
-mode_decrypt(File filein, File fileout);
-
-static
-int
-mode_encrypt(File filein, File fileout);
-
-int
-main(int argc, char **argv)
-{
-#if !defined(GCRYPT_VERSION_NUMBER) || (GCRYPT_VERSION_NUMBER < 0x010600)
-	gcry_error_t 		gcry_error;
-#endif
-	File filein = 0;
-	File fileout = 0;
-
-	MY_INIT(argv[0]);
-
-	crc_init();
-
-	if (get_options(&argc, &argv)) {
-		goto err;
-	}
-
-	/* Acording to gcrypt docs (and my testing), setting up the threading
-	   callbacks must be done first, so, lets give it a shot */
-#if !defined(GCRYPT_VERSION_NUMBER) || (GCRYPT_VERSION_NUMBER < 0x010600)
-	gcry_error = gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
-	if (gcry_error) {
-		msg("%s: unable to set libgcrypt thread cbs - "
-		    "%s : %s\n", my_progname,
-		    gcry_strsource(gcry_error),
-		    gcry_strerror(gcry_error));
-		return 1;
-	}
-#endif
-
-	/* Version check should be the very first call because it
-	makes sure that important subsystems are intialized. */
-	if (!gcry_control(GCRYCTL_ANY_INITIALIZATION_P)) {
-		const char	*gcrypt_version;
-		gcrypt_version = gcry_check_version(NULL);
-		/* No other library has already initialized libgcrypt. */
-		if (!gcrypt_version) {
-			msg("%s: failed to initialize libgcrypt\n",
-			    my_progname);
-			return 1;
-		} else if (opt_verbose) {
-			msg("%s: using gcrypt %s\n", my_progname,
-			    gcrypt_version);
-		}
-	}
-	gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
-	gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
-
-	/* Determine the algorithm */
-	encrypt_algo = encrypt_algos[opt_encrypt_algo];
-
-	/* Set up the iv length */
-	encrypt_iv_len = gcry_cipher_get_algo_blklen(encrypt_algo);
-
-	/* Now set up the key */
-	if (opt_encrypt_key == NULL && opt_encrypt_key_file == NULL) {
-		msg("%s: no encryption key or key file specified.\n",
-		    my_progname);
-		return 1;
-	} else if (opt_encrypt_key && opt_encrypt_key_file) {
-		msg("%s: both encryption key and key file specified.\n",
-		    my_progname);
-		return 1;
-	} else if (opt_encrypt_key_file) {
-		if (!xb_crypt_read_key_file(opt_encrypt_key_file,
-					    &opt_encrypt_key,
-					    &encrypt_key_len)) {
-			msg("%s: unable to read encryption key file \"%s\".\n",
-			    opt_encrypt_key_file, my_progname);
-			return 1;
-		}
-	} else {
-		encrypt_key_len = strlen(opt_encrypt_key);
-	}
-
-	if (opt_input_file) {
-		MY_STAT 	mystat;
-
-		if (opt_verbose)
-			msg("%s: input file \"%s\".\n", my_progname,
-			    opt_input_file);
-
-		if (my_stat(opt_input_file, &mystat, MYF(MY_WME)) == NULL) {
-			goto err;
-		}
-		if (!MY_S_ISREG(mystat.st_mode)) {
-			msg("%s: \"%s\" is not a regular file, exiting.\n",
-			    my_progname, opt_input_file);
-			goto err;
-		}
-		if ((filein = my_open(opt_input_file, O_RDONLY, MYF(MY_WME)))
-		     < 0) {
-			msg("%s: failed to open \"%s\".\n", my_progname,
-			     opt_input_file);
-			goto err;
-		}
-	} else {
-		if (opt_verbose)
-			msg("%s: input from standard input.\n", my_progname);
-		filein = fileno(stdin);
-	}
-
-	if (opt_output_file) {
-		if (opt_verbose)
-			msg("%s: output file \"%s\".\n", my_progname,
-			    opt_output_file);
-
-		if ((fileout = my_create(opt_output_file, 0,
-					 O_WRONLY|O_BINARY|O_EXCL|O_NOFOLLOW,
-					 MYF(MY_WME))) < 0) {
-			msg("%s: failed to create output file \"%s\".\n",
-			    my_progname, opt_output_file);
-			goto err;
-		}
-	} else {
-		if (opt_verbose)
-			msg("%s: output to standard output.\n", my_progname);
-		fileout = fileno(stdout);
-	}
-
-	if (opt_run_mode == RUN_MODE_DECRYPT
-	    && mode_decrypt(filein, fileout)) {
-		goto err;
-	} else if (opt_run_mode == RUN_MODE_ENCRYPT
-		   && mode_encrypt(filein, fileout)) {
-		goto err;
-	}
-
-	if (opt_input_file && filein) {
-		my_close(filein, MYF(MY_WME));
-	}
-	if (opt_output_file && fileout) {
-		my_close(fileout, MYF(MY_WME));
-	}
-
-	my_cleanup_options(my_long_options);
-
-	my_end(0);
-
-	return EXIT_SUCCESS;
-err:
-	if (opt_input_file && filein) {
-		my_close(filein, MYF(MY_WME));
-	}
-	if (opt_output_file && fileout) {
-		my_close(fileout, MYF(MY_WME));
-	}
-
-	my_cleanup_options(my_long_options);
-
-	my_end(0);
-
-	exit(EXIT_FAILURE);
-
-}
-
-
-static
-size_t
-my_xb_crypt_read_callback(void *userdata, void *buf, size_t len)
-{
-	File* file = (File *) userdata;
-	return xb_read_full(*file, buf, len);
-}
-
-static
-int
-mode_decrypt(File filein, File fileout)
-{
-	xb_rcrypt_t		*xbcrypt_file = NULL;
-	void			*chunkbuf = NULL;
-	size_t			chunksize;
-	size_t			originalsize;
-	void			*ivbuf = NULL;
-	size_t			ivsize;
-	void			*decryptbuf = NULL;
-	size_t			decryptbufsize = 0;
-	ulonglong		ttlchunksread = 0;
-	ulonglong		ttlbytesread = 0;
-	xb_rcrypt_result_t	result;
-	gcry_cipher_hd_t	cipher_handle;
-	gcry_error_t		gcry_error;
-	my_bool			hash_appended;
-
-	if (encrypt_algo != GCRY_CIPHER_NONE) {
-		gcry_error = gcry_cipher_open(&cipher_handle,
-					      encrypt_algo,
-					      encrypt_mode, 0);
-		if (gcry_error) {
-			msg("%s:decrypt: unable to open libgcrypt"
-			    " cipher - %s : %s\n", my_progname,
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			return 1;
-		}
-
-		gcry_error = gcry_cipher_setkey(cipher_handle,
-						opt_encrypt_key,
-						encrypt_key_len);
-		if (gcry_error) {
-			msg("%s:decrypt: unable to set libgcrypt cipher"
-			    "key - %s : %s\n", my_progname,
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			goto err;
-		}
-	}
-
-	/* Initialize the xb_crypt format reader */
-	xbcrypt_file = xb_crypt_read_open(&filein, my_xb_crypt_read_callback);
-	if (xbcrypt_file == NULL) {
-		msg("%s:decrypt: xb_crypt_read_open() failed.\n", my_progname);
-		goto err;
-	}
-
-	/* Walk the encrypted chunks, decrypting them and writing out */
-	while ((result = xb_crypt_read_chunk(xbcrypt_file, &chunkbuf,
-					     &originalsize, &chunksize,
-					     &ivbuf, &ivsize, &hash_appended))
-		== XB_CRYPT_READ_CHUNK) {
-
-		if (encrypt_algo != GCRY_CIPHER_NONE) {
-			gcry_error = gcry_cipher_reset(cipher_handle);
-			if (gcry_error) {
-				msg("%s:decrypt: unable to reset libgcrypt"
-				    " cipher - %s : %s\n", my_progname,
-				    gcry_strsource(gcry_error),
-				    gcry_strerror(gcry_error));
-				goto err;
-			}
-
-			if (ivsize) {
-				gcry_error = gcry_cipher_setctr(cipher_handle,
-								ivbuf,
-								ivsize);
-			}
-			if (gcry_error) {
-				msg("%s:decrypt: unable to set cipher iv - "
-				    "%s : %s\n", my_progname,
-				    gcry_strsource(gcry_error),
-				    gcry_strerror(gcry_error));
-				continue;
-			}
-
-			if (decryptbufsize < originalsize) {
-				decryptbuf = my_realloc(decryptbuf,
-					originalsize,
-					MYF(MY_WME | MY_ALLOW_ZERO_PTR));
-				decryptbufsize = originalsize;
-			}
-
-			/* Try to decrypt it */
-			gcry_error = gcry_cipher_decrypt(cipher_handle,
-							 decryptbuf,
-							 originalsize,
-							 chunkbuf,
-							 chunksize);
-			if (gcry_error) {
-				msg("%s:decrypt: unable to decrypt chunk - "
-				    "%s : %s\n", my_progname,
-				    gcry_strsource(gcry_error),
-				    gcry_strerror(gcry_error));
-				gcry_cipher_close(cipher_handle);
-					goto err;
-			}
-
-		} else {
-			decryptbuf = chunkbuf;
-		}
-
-		if (hash_appended) {
-			uchar hash[XB_CRYPT_HASH_LEN];
-
-			originalsize -= XB_CRYPT_HASH_LEN;
-
-			/* ensure that XB_CRYPT_HASH_LEN is the correct length
-			of XB_CRYPT_HASH hashing algorithm output */
-			xb_a(gcry_md_get_algo_dlen(XB_CRYPT_HASH) ==
-			     XB_CRYPT_HASH_LEN);
-			gcry_md_hash_buffer(XB_CRYPT_HASH, hash, decryptbuf,
-					    originalsize);
-			if (memcmp(hash, (char *) decryptbuf + originalsize,
-				   XB_CRYPT_HASH_LEN) != 0) {
-				msg("%s:%s invalid plaintext hash. "
-				    "Wrong encrytion key specified?\n",
-				    my_progname, __FUNCTION__);
-				result = XB_CRYPT_READ_ERROR;
-				goto err;
-			}
-		}
-
-		/* Write it out */
-		if (my_write(fileout, (const uchar *) decryptbuf, originalsize,
-			     MYF(MY_WME | MY_NABP))) {
-			msg("%s:decrypt: unable to write output chunk.\n",
-			    my_progname);
-			goto err;
-		}
-		ttlchunksread++;
-		ttlbytesread += chunksize;
-		if (opt_verbose)
-			msg("%s:decrypt: %llu chunks read, %llu bytes read\n.",
-		    	    my_progname, ttlchunksread, ttlbytesread);
-	}
-
-	xb_crypt_read_close(xbcrypt_file);
-
-	if (encrypt_algo != GCRY_CIPHER_NONE)
-		gcry_cipher_close(cipher_handle);
-
-	if (decryptbuf && decryptbufsize)
-		my_free(decryptbuf);
-
-	if (opt_verbose)
-		msg("\n%s:decrypt: done\n", my_progname);
-
-	return 0;
-err:
-	if (xbcrypt_file)
-		xb_crypt_read_close(xbcrypt_file);
-
-	if (encrypt_algo != GCRY_CIPHER_NONE)
-		gcry_cipher_close(cipher_handle);
-
-	if (decryptbuf && decryptbufsize)
-		my_free(decryptbuf);
-
-	return 1;
-}
-
-static
-ssize_t
-my_xb_crypt_write_callback(void *userdata, const void *buf, size_t len)
-{
-	File* file = (File *) userdata;
-
-	ssize_t ret = my_write(*file, buf, len, MYF(MY_WME));
-	posix_fadvise(*file, 0, 0, POSIX_FADV_DONTNEED);
-	return ret;
-}
-
-static
-int
-mode_encrypt(File filein, File fileout)
-{
-	size_t			bytesread;
-	size_t			chunkbuflen;
-	uchar			*chunkbuf = NULL;
-	void			*ivbuf = NULL;
-	size_t			encryptbuflen = 0;
-	size_t			encryptedlen = 0;
-	void			*encryptbuf = NULL;
-	ulonglong		ttlchunkswritten = 0;
-	ulonglong		ttlbyteswritten = 0;
-	xb_wcrypt_t		*xbcrypt_file = NULL;
-	gcry_cipher_hd_t	cipher_handle;
-	gcry_error_t		gcry_error;
-
-	if (encrypt_algo != GCRY_CIPHER_NONE) {
-		gcry_error = gcry_cipher_open(&cipher_handle,
-					      encrypt_algo,
-					      encrypt_mode, 0);
-		if (gcry_error) {
-			msg("%s:encrypt: unable to open libgcrypt cipher - "
-			    "%s : %s\n", my_progname,
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			return 1;
-		}
-
-		gcry_error = gcry_cipher_setkey(cipher_handle,
-						opt_encrypt_key,
-						encrypt_key_len);
-		if (gcry_error) {
-			msg("%s:encrypt: unable to set libgcrypt cipher key - "
-			    "%s : %s\n", my_progname,
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			goto err;
-		}
-	}
-
-	posix_fadvise(filein, 0, 0, POSIX_FADV_SEQUENTIAL);
-
-	xbcrypt_file = xb_crypt_write_open(&fileout,
-					   my_xb_crypt_write_callback);
-	if (xbcrypt_file == NULL) {
-		msg("%s:encrypt: xb_crypt_write_open() failed.\n",
-		    my_progname);
-		goto err;
-	}
-
-	ivbuf = my_malloc(encrypt_iv_len, MYF(MY_FAE));
-
-	/* now read in data in chunk size, encrypt and write out */
-	chunkbuflen = opt_encrypt_chunk_size + XB_CRYPT_HASH_LEN;
-	chunkbuf = (uchar *) my_malloc(chunkbuflen, MYF(MY_FAE));
-	while ((bytesread = my_read(filein, chunkbuf, opt_encrypt_chunk_size,
-				    MYF(MY_WME))) > 0) {
-
-		size_t origbuflen = bytesread + XB_CRYPT_HASH_LEN;
-
-		/* ensure that XB_CRYPT_HASH_LEN is the correct length
-		of XB_CRYPT_HASH hashing algorithm output */
-		xb_a(XB_CRYPT_HASH_LEN == gcry_md_get_algo_dlen(XB_CRYPT_HASH));
-		gcry_md_hash_buffer(XB_CRYPT_HASH, chunkbuf + bytesread,
-				    chunkbuf, bytesread);
-
-		if (encrypt_algo != GCRY_CIPHER_NONE) {
-			gcry_error = gcry_cipher_reset(cipher_handle);
-
-			if (gcry_error) {
-				msg("%s:encrypt: unable to reset cipher - "
-				    "%s : %s\n", my_progname,
-				    gcry_strsource(gcry_error),
-				    gcry_strerror(gcry_error));
-				goto err;
-			}
-
-			xb_crypt_create_iv(ivbuf, encrypt_iv_len);
-			gcry_error = gcry_cipher_setctr(cipher_handle,
-							ivbuf,
-							encrypt_iv_len);
-
-			if (gcry_error) {
-				msg("%s:encrypt: unable to set cipher iv - "
-				    "%s : %s\n", my_progname,
-				    gcry_strsource(gcry_error),
-				    gcry_strerror(gcry_error));
-				continue;
-			}
-
-			if (encryptbuflen < origbuflen) {
-				encryptbuf = my_realloc(encryptbuf, origbuflen,
-					MYF(MY_WME | MY_ALLOW_ZERO_PTR));
-				encryptbuflen = origbuflen;
-			}
-
-			gcry_error = gcry_cipher_encrypt(cipher_handle,
-							 encryptbuf,
-							 encryptbuflen,
-							 chunkbuf,
-							 origbuflen);
-
-			encryptedlen = origbuflen;
-
-			if (gcry_error) {
-				msg("%s:encrypt: unable to encrypt chunk - "
-				    "%s : %s\n", my_progname,
-				    gcry_strsource(gcry_error),
-				    gcry_strerror(gcry_error));
-				gcry_cipher_close(cipher_handle);
-				goto err;
-			}
-		} else {
-			encryptedlen = origbuflen;
-			encryptbuf = chunkbuf;
-		}
-
-		if (xb_crypt_write_chunk(xbcrypt_file, encryptbuf,
-					 bytesread + XB_CRYPT_HASH_LEN,
-					 encryptedlen, ivbuf, encrypt_iv_len)) {
-			msg("%s:encrypt: abcrypt_write_chunk() failed.\n",
-			    my_progname);
-			goto err;
-		}
-
-		ttlchunkswritten++;
-		ttlbyteswritten += encryptedlen;
-
-		if (opt_verbose)
-			msg("%s:encrypt: %llu chunks written, %llu bytes "
-			    "written\n.", my_progname, ttlchunkswritten,
-			    ttlbyteswritten);
-	}
-
-	my_free(ivbuf);
-	my_free(chunkbuf);
-
-	if (encryptbuf && encryptbuflen)
-		my_free(encryptbuf);
-
-	xb_crypt_write_close(xbcrypt_file);
-
-	if (encrypt_algo != GCRY_CIPHER_NONE)
-		gcry_cipher_close(cipher_handle);
-
-	if (opt_verbose)
-		msg("\n%s:encrypt: done\n", my_progname);
-
-	return 0;
-err:
-	if (chunkbuf)
-		my_free(chunkbuf);
-
-	if (encryptbuf && encryptbuflen)
-		my_free(encryptbuf);
-
-	if (xbcrypt_file)
-		xb_crypt_write_close(xbcrypt_file);
-
-	if (encrypt_algo != GCRY_CIPHER_NONE)
-		gcry_cipher_close(cipher_handle);
-
-	return 1;
-}
-
-static
-int
-get_options(int *argc, char ***argv)
-{
-	int ho_error;
-
-	if ((ho_error= handle_options(argc, argv, my_long_options,
-				      get_one_option))) {
-		exit(EXIT_FAILURE);
-	}
-
-	return 0;
-}
-
-static
-my_bool
-get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
-	       char *argument __attribute__((unused)))
-{
-	switch (optid) {
-	case 'd':
-		opt_run_mode = RUN_MODE_DECRYPT;
-		break;
-	case '?':
-		usage();
-		exit(0);
-	}
-
-	return FALSE;
-}
-
-static
-void
-print_version(void)
-{
-	printf("%s  Ver %s for %s (%s)\n", my_progname, XBCRYPT_VERSION,
-	       SYSTEM_TYPE, MACHINE_TYPE);
-}
-
-static
-void
-usage(void)
-{
-	print_version();
-	puts("Copyright (C) 2011 Percona Inc.");
-	puts("This software comes with ABSOLUTELY NO WARRANTY. "
-	     "This is free software,\nand you are welcome to modify and "
-	     "redistribute it under the GPL license.\n");
-
-	puts("Encrypt or decrypt files in the XBCRYPT format.\n");
-
-	puts("Usage: ");
-	printf("  %s [OPTIONS...]"
- 	       " # read data from specified input, encrypting or decrypting "
-	       " and writing the result to the specified output.\n",
-	       my_progname);
-	puts("\nOptions:");
-	my_print_help(my_long_options);
-}
diff --git a/extra/mariabackup/xbcrypt.h b/extra/mariabackup/xbcrypt.h
deleted file mode 100644
index 0e832266847..00000000000
--- a/extra/mariabackup/xbcrypt.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/******************************************************
-Copyright (c) 2011 Percona LLC and/or its affiliates.
-
-Encryption interface for XtraBackup.
-
-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-1301, USA
-
-*******************************************************/
-
-#ifndef XBCRYPT_H
-#define XBCRYPT_H
-
-#include <my_base.h>
-#include "common.h"
-
-#define XB_CRYPT_CHUNK_MAGIC1 "XBCRYP01"
-#define XB_CRYPT_CHUNK_MAGIC2 "XBCRYP02"
-#define XB_CRYPT_CHUNK_MAGIC3 "XBCRYP03" /* must be same size as ^^ */
-#define XB_CRYPT_CHUNK_MAGIC_CURRENT XB_CRYPT_CHUNK_MAGIC3
-#define XB_CRYPT_CHUNK_MAGIC_SIZE (sizeof(XB_CRYPT_CHUNK_MAGIC1)-1)
-
-#define XB_CRYPT_HASH GCRY_MD_SHA256
-#define XB_CRYPT_HASH_LEN 32
-
-/******************************************************************************
-Write interface */
-typedef struct xb_wcrypt_struct xb_wcrypt_t;
-
-/* Callback on write for i/o, must return # of bytes written or -1 on error */
-typedef ssize_t xb_crypt_write_callback(void *userdata,
-					const void *buf, size_t len);
-
-xb_wcrypt_t *xb_crypt_write_open(void *userdata,
-				 xb_crypt_write_callback *onwrite);
-
-/* Takes buffer, original length, encrypted length iv and iv length, formats
-   output buffer and calls write callback.
-   Returns 0 on success, 1 on error */
-int xb_crypt_write_chunk(xb_wcrypt_t *crypt, const void *buf, size_t olen,
-			 size_t elen, const void *iv, size_t ivlen);
-
-/* Returns 0 on success, 1 on error */
-int xb_crypt_write_close(xb_wcrypt_t *crypt);
-
-/******************************************************************************
-Read interface */
-typedef struct xb_rcrypt_struct xb_rcrypt_t;
-
-/* Callback on read for i/o, must return # of bytes read or -1 on error */
-typedef size_t xb_crypt_read_callback(void *userdata, void *buf, size_t len);
-
-xb_rcrypt_t *xb_crypt_read_open(void *userdata,
-				  xb_crypt_read_callback *onread);
-
-typedef enum {
-	XB_CRYPT_READ_CHUNK,
-	XB_CRYPT_READ_INCOMPLETE,
-	XB_CRYPT_READ_EOF,
-	XB_CRYPT_READ_ERROR
-} xb_rcrypt_result_t;
-
-xb_rcrypt_result_t xb_crypt_read_chunk(xb_rcrypt_t *crypt, void **buf,
-				       size_t *olen, size_t *elen, void **iv,
-				       size_t *ivlen, my_bool *hash_appended);
-
-int xb_crypt_read_close(xb_rcrypt_t *crypt);
-
-#endif
diff --git a/extra/mariabackup/xbcrypt_common.c b/extra/mariabackup/xbcrypt_common.c
deleted file mode 100644
index 0cdb54dc66d..00000000000
--- a/extra/mariabackup/xbcrypt_common.c
+++ /dev/null
@@ -1,328 +0,0 @@
-/******************************************************
-Copyright (c) 2013, 2017 Percona LLC and/or its affiliates.
-
-Encryption configuration file interface for XtraBackup.
-
-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-1301, USA
-
-*******************************************************/
-
-#include <my_base.h>
-#include "common.h"
-#include "xbcrypt.h"
-#include "xbcrypt_common.h"
-
-/* Encryption options */
-char		*ds_encrypt_key = NULL;
-char		*ds_encrypt_key_file = NULL;
-ulong		ds_encrypt_algo;
-
-static uint	encrypt_key_len;
-static uint	encrypt_iv_len;
-
-static const uint encrypt_mode = GCRY_CIPHER_MODE_CTR;
-
-static uint encrypt_algos[] = { GCRY_CIPHER_NONE, GCRY_CIPHER_AES128,
-				GCRY_CIPHER_AES192, GCRY_CIPHER_AES256 };
-static uint encrypt_algo;
-
-#if !defined(GCRYPT_VERSION_NUMBER) || (GCRYPT_VERSION_NUMBER < 0x010600)
-GCRY_THREAD_OPTION_PTHREAD_IMPL;
-#endif
-
-
-my_bool
-xb_crypt_read_key_file(const char *filename, void** key, uint *keylength)
-{
-	FILE *fp;
-
-	if (!(fp = my_fopen(filename, O_RDONLY, MYF(0)))) {
-		msg("%s:%s: unable to open config file \"%s\", errno(%d)\n",
-			my_progname, __FUNCTION__, filename, my_errno);
-		return FALSE;
-	}
-
-	fseek(fp, 0 , SEEK_END);
-	*keylength = ftell(fp);
-	rewind(fp);
-	*key = my_malloc(*keylength, MYF(MY_FAE));
-	*keylength = fread(*key, 1, *keylength, fp);
-	my_fclose(fp, MYF(0));
-	return TRUE;
-}
-
-void
-xb_crypt_create_iv(void* ivbuf, size_t ivlen)
-{
-	gcry_create_nonce(ivbuf, ivlen);
-}
-
-gcry_error_t
-xb_crypt_init(uint *iv_len)
-{
-	gcry_error_t 		gcry_error;
-
-	/* Acording to gcrypt docs (and my testing), setting up the threading
-	   callbacks must be done first, so, lets give it a shot */
-#if !defined(GCRYPT_VERSION_NUMBER) || (GCRYPT_VERSION_NUMBER < 0x010600)
-	gcry_error = gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
-	if (gcry_error) {
-		msg("encryption: unable to set libgcrypt thread cbs - "
-		    "%s : %s\n",
-		    gcry_strsource(gcry_error),
-		    gcry_strerror(gcry_error));
-		return gcry_error;
-	}
-#endif
-
-	/* Version check should be the very next call because it
-	makes sure that important subsystems are intialized. */
-	if (!gcry_control(GCRYCTL_ANY_INITIALIZATION_P)) {
-		const char	*gcrypt_version;
-		gcrypt_version = gcry_check_version(NULL);
-		/* No other library has already initialized libgcrypt. */
-		if (!gcrypt_version) {
-			msg("encryption: failed to initialize libgcrypt\n");
-			return 1;
-		} else {
-			msg("encryption: using gcrypt %s\n", gcrypt_version);
-		}
-	}
-
-	/* Disable the gcry secure memory, not dealing with this for now */
-	gcry_error = gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
-	if (gcry_error) {
-		msg("encryption: unable to disable libgcrypt secmem - "
-		    "%s : %s\n",
-		    gcry_strsource(gcry_error),
-		    gcry_strerror(gcry_error));
-		return gcry_error;
-	}
-
-	/* Finalize gcry initialization. */
-	gcry_error = gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
-	if (gcry_error) {
-		msg("encryption: unable to finish libgcrypt initialization - "
-		    "%s : %s\n",
-		    gcry_strsource(gcry_error),
-		    gcry_strerror(gcry_error));
-		return gcry_error;
-	}
-
-	/* Determine the algorithm */
-	encrypt_algo = encrypt_algos[ds_encrypt_algo];
-
-	/* Set up the iv length */
-	encrypt_iv_len = gcry_cipher_get_algo_blklen(encrypt_algo);
-	xb_a(encrypt_iv_len > 0);
-	if (iv_len != NULL) {
-		*iv_len = encrypt_iv_len;
-	}
-
-	/* Now set up the key */
-	if (ds_encrypt_key == NULL &&
-	    ds_encrypt_key_file == NULL) {
-		msg("encryption: no encryption key or key file specified.\n");
-		return gcry_error;
-	} else if (ds_encrypt_key && ds_encrypt_key_file) {
-		msg("encryption: both encryption key and key file specified.\n");
-		return gcry_error;
-	} else if (ds_encrypt_key_file) {
-		if (!xb_crypt_read_key_file(ds_encrypt_key_file,
-					    (void**)&ds_encrypt_key,
-					    &encrypt_key_len)) {
-			msg("encryption: unable to read encryption key file"
-			    " \"%s\".\n", ds_encrypt_key_file);
-			return gcry_error;
-		}
-	} else if (ds_encrypt_key) {
-		encrypt_key_len = strlen(ds_encrypt_key);
-	} else {
-		msg("encryption: no encryption key or key file specified.\n");
-		return gcry_error;
-	}
-
-	return 0;
-}
-
-gcry_error_t
-xb_crypt_cipher_open(gcry_cipher_hd_t *cipher_handle)
-{
-	if (encrypt_algo != GCRY_CIPHER_NONE) {
-		gcry_error_t 		gcry_error;
-
-		gcry_error = gcry_cipher_open(cipher_handle,
-					      encrypt_algo,
-					      encrypt_mode, 0);
-		if (gcry_error) {
-			msg("encryption: unable to open libgcrypt"
-			    " cipher - %s : %s\n",
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			gcry_cipher_close(*cipher_handle);
-			return gcry_error;
-		}
-
-		gcry_error = gcry_cipher_setkey(*cipher_handle,
-						ds_encrypt_key,
-						encrypt_key_len);
-		if (gcry_error) {
-			msg("encryption: unable to set libgcrypt"
-			    " cipher key - %s : %s\n",
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			gcry_cipher_close(*cipher_handle);
-			return gcry_error;
-		}
-		return gcry_error;
-	}
-	return 0;
-}
-
-void
-xb_crypt_cipher_close(gcry_cipher_hd_t cipher_handle)
-{
-	if (encrypt_algo != GCRY_CIPHER_NONE)
-		gcry_cipher_close(cipher_handle);
-}
-
-gcry_error_t
-xb_crypt_decrypt(gcry_cipher_hd_t cipher_handle, const uchar *from,
-		 size_t from_len, uchar *to, size_t *to_len,
-		 const uchar *iv, size_t iv_len, my_bool hash_appended)
-{
-	*to_len = from_len;
-
-	if (encrypt_algo != GCRY_CIPHER_NONE) {
-
-		gcry_error_t	gcry_error;
-
-		gcry_error = gcry_cipher_reset(cipher_handle);
-		if (gcry_error) {
-			msg("%s:encryption: unable to reset libgcrypt"
-			    " cipher - %s : %s\n", my_progname,
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			return gcry_error;
-		}
-
-		if (iv_len > 0) {
-			gcry_error = gcry_cipher_setctr(cipher_handle,
-							iv, iv_len);
-		}
-		if (gcry_error) {
-			msg("%s:encryption: unable to set cipher iv - "
-			    "%s : %s\n", my_progname,
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			return gcry_error;
-		}
-
-		/* Try to decrypt it */
-		gcry_error = gcry_cipher_decrypt(cipher_handle, to, *to_len,
-						 from, from_len);
-		if (gcry_error) {
-			msg("%s:encryption: unable to decrypt chunk - "
-			    "%s : %s\n", my_progname,
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			gcry_cipher_close(cipher_handle);
-			return gcry_error;
-		}
-
-		if (hash_appended) {
-			uchar hash[XB_CRYPT_HASH_LEN];
-
-			*to_len -= XB_CRYPT_HASH_LEN;
-
-			/* ensure that XB_CRYPT_HASH_LEN is the correct length
-			of XB_CRYPT_HASH hashing algorithm output */
-			xb_ad(gcry_md_get_algo_dlen(XB_CRYPT_HASH) ==
-			      XB_CRYPT_HASH_LEN);
-			gcry_md_hash_buffer(XB_CRYPT_HASH, hash, to,
-					    *to_len);
-			if (memcmp(hash, (char *) to + *to_len,
-				   XB_CRYPT_HASH_LEN) != 0) {
-				msg("%s:%s invalid plaintext hash. "
-				    "Wrong encrytion key specified?\n",
-				    my_progname, __FUNCTION__);
-				return 1;
-			}
-		}
-
-	} else {
-		memcpy(to, from, *to_len);
-	}
-
-	return 0;
-}
-
-gcry_error_t
-xb_crypt_encrypt(gcry_cipher_hd_t cipher_handle, const uchar *from,
-		 size_t from_len, uchar *to, size_t *to_len, uchar *iv)
-{
-	gcry_error_t 		gcry_error;
-
-	/* ensure that XB_CRYPT_HASH_LEN is the correct length
-	of XB_CRYPT_HASH hashing algorithm output */
-	xb_ad(gcry_md_get_algo_dlen(XB_CRYPT_HASH) ==
-	      XB_CRYPT_HASH_LEN);
-
-	memcpy(to, from, from_len);
-	gcry_md_hash_buffer(XB_CRYPT_HASH, to + from_len,
-			    from, from_len);
-
-	*to_len = from_len;
-
-	if (encrypt_algo != GCRY_CIPHER_NONE) {
-
-		gcry_error = gcry_cipher_reset(cipher_handle);
-		if (gcry_error) {
-			msg("encrypt: unable to reset cipher - "
-			    "%s : %s\n",
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			return gcry_error;
-		}
-
-		xb_crypt_create_iv(iv, encrypt_iv_len);
-		gcry_error = gcry_cipher_setctr(cipher_handle, iv,
-						encrypt_iv_len);
-		if (gcry_error) {
-			msg("encrypt: unable to set cipher ctr - "
-			    "%s : %s\n",
-			    gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			return gcry_error;
-		}
-
-		gcry_error = gcry_cipher_encrypt(cipher_handle, to,
-						 *to_len + XB_CRYPT_HASH_LEN,
-						 to,
-						 from_len + XB_CRYPT_HASH_LEN);
-		if (gcry_error) {
-			msg("encrypt: unable to encrypt buffer - "
-			    "%s : %s\n", gcry_strsource(gcry_error),
-			    gcry_strerror(gcry_error));
-			return gcry_error;
-		}
-	} else {
-		memcpy(to, from, from_len + XB_CRYPT_HASH_LEN);
-	}
-
-	*to_len += XB_CRYPT_HASH_LEN;
-
-	return 0;
-}
-#endif
\ No newline at end of file
diff --git a/extra/mariabackup/xbcrypt_common.h b/extra/mariabackup/xbcrypt_common.h
deleted file mode 100644
index 85d13c01fc4..00000000000
--- a/extra/mariabackup/xbcrypt_common.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/******************************************************
-Copyright (c) 2017 Percona LLC and/or its affiliates.
-
-Encryption datasink implementation for XtraBackup.
-
-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-1301, USA
-
-*******************************************************/
-
-#include <my_base.h>
-#if HAVE_GCRYPT
-#if GCC_VERSION >= 4002
-/* Workaround to avoid "gcry_ac_* is deprecated" warnings in gcrypt.h */
-#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <gcrypt.h>
-
-extern char		*ds_encrypt_key;
-extern char		*ds_encrypt_key_file;
-extern int		ds_encrypt_threads;
-extern ulong		ds_encrypt_algo;
-
-/******************************************************************************
-Utility interface */
-my_bool xb_crypt_read_key_file(const char *filename,
-			       void** key, uint *keylength);
-
-void xb_crypt_create_iv(void* ivbuf, size_t ivlen);
-
-/* Initialize gcrypt and setup encryption key and IV lengths */
-gcry_error_t
-xb_crypt_init(uint *iv_len);
-
-/* Setup gcrypt cipher */
-gcry_error_t
-xb_crypt_cipher_open(gcry_cipher_hd_t *cipher_handle);
-
-/* Close gcrypt cipher */
-void
-xb_crypt_cipher_close(gcry_cipher_hd_t cipher_handle);
-
-/* Decrypt buffer */
-gcry_error_t
-xb_crypt_decrypt(gcry_cipher_hd_t cipher_handle, const uchar *from,
-		 size_t from_len, uchar *to, size_t *to_len, const uchar *iv,
-		 size_t iv_len, my_bool hash_appended);
-
-/* Encrypt buffer */
-gcry_error_t
-xb_crypt_encrypt(gcry_cipher_hd_t cipher_handle, const uchar *from,
-  size_t from_len, uchar *to, size_t *to_len, uchar *iv);
-#endif
diff --git a/extra/mariabackup/xbcrypt_read.c b/extra/mariabackup/xbcrypt_read.c
deleted file mode 100644
index 41790c7035d..00000000000
--- a/extra/mariabackup/xbcrypt_read.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/******************************************************
-Copyright (c) 2013 Percona LLC and/or its affiliates.
-
-The xbcrypt format reader implementation.
-
-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-1301, USA
-
-*******************************************************/
-
-#include "xbcrypt.h"
-#include "crc_glue.h"
-
-struct xb_rcrypt_struct {
-	void				*userdata;
-	xb_crypt_read_callback		*read;
-	void				*buffer;
-	size_t				bufsize;
-	void				*ivbuffer;
-	size_t				ivbufsize;
-	ulonglong			offset;
-};
-
-xb_rcrypt_t *
-xb_crypt_read_open(void *userdata, xb_crypt_read_callback *onread)
-{
-	xb_rcrypt_t	*crypt;
-
-	xb_ad(onread);
-
-	crypt = (xb_rcrypt_t *) my_malloc(sizeof(xb_rcrypt_t), MYF(MY_FAE));
-
-	crypt->userdata = userdata;
-	crypt->read = onread;
-	crypt->buffer = NULL;
-	crypt->bufsize = 0;
-	crypt->offset = 0;
-	crypt->ivbuffer = NULL;
-	crypt->ivbufsize = 0;
-	return crypt;
-}
-
-xb_rcrypt_result_t
-xb_crypt_read_chunk(xb_rcrypt_t *crypt, void **buf, size_t *olen, size_t *elen,
-		    void **iv, size_t *ivlen, my_bool *hash_appended)
-
-{
-	uchar		tmpbuf[XB_CRYPT_CHUNK_MAGIC_SIZE + 8 + 8 + 8 + 4];
-	uchar		*ptr;
-	ulonglong	tmp;
-	ulong		checksum, checksum_exp, version;
-	size_t		bytesread;
-	xb_rcrypt_result_t result = XB_CRYPT_READ_CHUNK;
-
-	if ((bytesread = crypt->read(crypt->userdata, tmpbuf, sizeof(tmpbuf)))
-	    != sizeof(tmpbuf)) {
-		if (bytesread == 0) {
-			result = XB_CRYPT_READ_EOF;
-			goto err;
-		} else {
-			msg("%s:%s: unable to read chunk header data at "
-			    "offset 0x%llx.\n",
-			    my_progname, __FUNCTION__, crypt->offset);
-			result =  XB_CRYPT_READ_ERROR;
-			goto err;
-		}
-	}
-
-	ptr = tmpbuf;
-
-	if (memcmp(ptr, XB_CRYPT_CHUNK_MAGIC3,
-		   XB_CRYPT_CHUNK_MAGIC_SIZE) == 0) {
-		version = 3;
-	} else if (memcmp(ptr, XB_CRYPT_CHUNK_MAGIC2,
-			  XB_CRYPT_CHUNK_MAGIC_SIZE) == 0) {
-		version = 2;
-	} else if (memcmp(ptr, XB_CRYPT_CHUNK_MAGIC1,
-			  XB_CRYPT_CHUNK_MAGIC_SIZE) == 0) {
-		version = 1;
-	} else {
-		msg("%s:%s: wrong chunk magic at offset 0x%llx.\n",
-		    my_progname, __FUNCTION__, crypt->offset);
-		result = XB_CRYPT_READ_ERROR;
-		goto err;
-	}
-
-	ptr += XB_CRYPT_CHUNK_MAGIC_SIZE;
-	crypt->offset += XB_CRYPT_CHUNK_MAGIC_SIZE;
-
-	tmp = uint8korr(ptr);	/* reserved */
-	ptr += 8;
-	crypt->offset += 8;
-
-	tmp = uint8korr(ptr);	/* original size */
-	ptr += 8;
-	if (tmp > INT_MAX) {
-		msg("%s:%s: invalid original size at offset 0x%llx.\n",
-		    my_progname, __FUNCTION__, crypt->offset);
-		result = XB_CRYPT_READ_ERROR;
-		goto err;
-	}
-	crypt->offset += 8;
-	*olen = (size_t)tmp;
-
-	tmp = uint8korr(ptr);	/* encrypted size */
-	ptr += 8;
-	if (tmp > INT_MAX) {
-		msg("%s:%s: invalid encrypted size at offset 0x%llx.\n",
-		    my_progname, __FUNCTION__, crypt->offset);
-		result = XB_CRYPT_READ_ERROR;
-		goto err;
-	}
-	crypt->offset += 8;
-	*elen = (size_t)tmp;
-
-	checksum_exp = uint4korr(ptr);	/* checksum */
-	ptr += 4;
-	crypt->offset += 4;
-
-	/* iv size */
-	if (version == 1) {
-		*ivlen = 0;
-		*iv = 0;
-	} else {
-		if ((bytesread = crypt->read(crypt->userdata, tmpbuf, 8))
-		    != 8) {
-			if (bytesread == 0) {
-				result = XB_CRYPT_READ_EOF;
-				goto err;
-			} else {
-				msg("%s:%s: unable to read chunk iv size at "
-				    "offset 0x%llx.\n",
-				    my_progname, __FUNCTION__, crypt->offset);
-				result =  XB_CRYPT_READ_ERROR;
-				goto err;
-			}
-		}
-
-		tmp = uint8korr(tmpbuf);
-		if (tmp > INT_MAX) {
-			msg("%s:%s: invalid iv size at offset 0x%llx.\n",
-			    my_progname, __FUNCTION__, crypt->offset);
-			result = XB_CRYPT_READ_ERROR;
-			goto err;
-		}
-		crypt->offset += 8;
-		*ivlen = (size_t)tmp;
-	}
-
-	if (*ivlen > crypt->ivbufsize) {
-		crypt->ivbuffer = my_realloc(crypt->ivbuffer, *ivlen,
-					     MYF(MY_WME | MY_ALLOW_ZERO_PTR));
-		if (crypt->ivbuffer == NULL) {
-			msg("%s:%s: failed to increase iv buffer to "
-			    "%llu bytes.\n", my_progname, __FUNCTION__,
-			    (ulonglong)*ivlen);
-			result = XB_CRYPT_READ_ERROR;
-			goto err;
-		}
-		crypt->ivbufsize = *ivlen;
-	}
-
-	if (*ivlen > 0) {
-		if (crypt->read(crypt->userdata, crypt->ivbuffer, *ivlen)
-		    != *ivlen) {
-			msg("%s:%s: failed to read %lld bytes for chunk iv "
-			    "at offset 0x%llx.\n", my_progname, __FUNCTION__,
-			    (ulonglong)*ivlen, crypt->offset);
-			result = XB_CRYPT_READ_ERROR;
-			goto err;
-		}
-		*iv = crypt->ivbuffer;
-	}
-
-	/* for version euqals 2 we need to read in the iv data but do not init
-	CTR with it */
-	if (version == 2) {
-		*ivlen = 0;
-		*iv = 0;
-	}
-
-	if (*olen > crypt->bufsize) {
-		crypt->buffer = my_realloc(crypt->buffer, *olen,
-					   MYF(MY_WME | MY_ALLOW_ZERO_PTR));
-		if (crypt->buffer == NULL) {
-			msg("%s:%s: failed to increase buffer to "
-			    "%llu bytes.\n", my_progname, __FUNCTION__,
-			    (ulonglong)*olen);
-			result = XB_CRYPT_READ_ERROR;
-			goto err;
-		}
-		crypt->bufsize = *olen;
-	}
-
-	if (*elen > 0) {
-		if (crypt->read(crypt->userdata, crypt->buffer, *elen)
-		    != *elen) {
-			msg("%s:%s: failed to read %lld bytes for chunk payload "
-			    "at offset 0x%llx.\n", my_progname, __FUNCTION__,
-			    (ulonglong)*elen, crypt->offset);
-			result = XB_CRYPT_READ_ERROR;
-			goto err;
-		}
-	}
-
-	checksum = crc32_iso3309(0, crypt->buffer, *elen);
-	if (checksum != checksum_exp) {
-		msg("%s:%s invalid checksum at offset 0x%llx, "
-		    "expected 0x%lx, actual 0x%lx.\n", my_progname, __FUNCTION__,
-		    crypt->offset, checksum_exp, checksum);
-		result = XB_CRYPT_READ_ERROR;
-		goto err;
-	}
-
-	crypt->offset += *elen;
-	*buf = crypt->buffer;
-
-	*hash_appended = version > 2;
-
-	goto exit;
-
-err:
-	*buf = NULL;
-	*olen = 0;
-	*elen = 0;
-	*ivlen = 0;
-	*iv = 0;
-exit:
-	return result;
-}
-
-int xb_crypt_read_close(xb_rcrypt_t *crypt)
-{
-	if (crypt->buffer)
-		my_free(crypt->buffer);
-	if (crypt->ivbuffer)
-		my_free(crypt->ivbuffer);
-	my_free(crypt);
-
-	return 0;
-}
-
diff --git a/extra/mariabackup/xbcrypt_write.c b/extra/mariabackup/xbcrypt_write.c
deleted file mode 100644
index 91dbfc4eb29..00000000000
--- a/extra/mariabackup/xbcrypt_write.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/******************************************************
-Copyright (c) 2013 Percona LLC and/or its affiliates.
-
-The xbcrypt format writer implementation.
-
-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-1301, USA
-
-*******************************************************/
-
-#include "xbcrypt.h"
-#include "crc_glue.h"
-
-struct xb_wcrypt_struct {
-	void				*userdata;
-	xb_crypt_write_callback		*write;
-};
-
-xb_wcrypt_t *
-xb_crypt_write_open(void *userdata, xb_crypt_write_callback *onwrite)
-{
-	xb_wcrypt_t	*crypt;
-
-	xb_ad(onwrite);
-
-	crypt = (xb_wcrypt_t *) my_malloc(sizeof(xb_wcrypt_t), MYF(MY_FAE));
-
-	crypt->userdata = userdata;
-	crypt->write = onwrite;
-
-	return crypt;
-}
-
-int xb_crypt_write_chunk(xb_wcrypt_t *crypt, const void *buf, size_t olen,
-			 size_t elen, const void *iv, size_t ivlen)
-{
-	uchar		tmpbuf[XB_CRYPT_CHUNK_MAGIC_SIZE + 8 + 8 + 8 + 4 + 8];
-	uchar		*ptr;
-	ulong		checksum;
-
-	xb_ad(olen <= INT_MAX);
-	if (olen > INT_MAX)
-		return 0;
-
-	xb_ad(elen <= INT_MAX);
-	if (elen > INT_MAX)
-		return 0;
-
-	xb_ad(ivlen <= INT_MAX);
-	if (ivlen > INT_MAX)
-		return 0;
-
-	ptr = tmpbuf;
-
-	memcpy(ptr, XB_CRYPT_CHUNK_MAGIC_CURRENT, XB_CRYPT_CHUNK_MAGIC_SIZE);
-	ptr += XB_CRYPT_CHUNK_MAGIC_SIZE;
-
-	int8store(ptr, (ulonglong)0);	/* reserved */
-	ptr += 8;
-
-	int8store(ptr, (ulonglong)olen); /* original size */
-	ptr += 8;
-
-	int8store(ptr, (ulonglong)elen); /* encrypted (actual) size */
-	ptr += 8;
-
-	checksum = crc32_iso3309(0, buf, elen);
-	int4store(ptr, checksum);	/* checksum */
-	ptr += 4;
-
-	int8store(ptr, (ulonglong)ivlen); /* iv size */
-	ptr += 8;
-
-	xb_ad(ptr <= tmpbuf + sizeof(tmpbuf));
-
-	if (crypt->write(crypt->userdata, tmpbuf, ptr-tmpbuf) == -1)
-		return 1;
-
-	if (crypt->write(crypt->userdata, iv, ivlen) == -1)
-		return 1;
-
-	if (crypt->write(crypt->userdata, buf, elen) == -1)
-		return 1;
-
-	return 0;
-}
-
-int xb_crypt_write_close(xb_wcrypt_t *crypt)
-{
-	my_free(crypt);
-
-	return 0;
-}
-
-
diff --git a/extra/mariabackup/xbstream.c b/extra/mariabackup/xbstream.c
index 2cc47ec7273..edfe20a9e3c 100644
--- a/extra/mariabackup/xbstream.c
+++ b/extra/mariabackup/xbstream.c
@@ -25,9 +25,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 #include <my_pthread.h>
 #include "common.h"
 #include "xbstream.h"
-#include "xbcrypt_common.h"
 #include "datasink.h"
-#include "ds_decrypt.h"
 #include "crc_glue.h"
 
 #define XBSTREAM_VERSION "1.0"
@@ -41,33 +39,18 @@ typedef enum {
 	RUN_MODE_EXTRACT
 } run_mode_t;
 
-const char *xbstream_encrypt_algo_names[] =
-{ "NONE", "AES128", "AES192", "AES256", NullS};
-TYPELIB xbstream_encrypt_algo_typelib=
-{array_elements(xbstream_encrypt_algo_names)-1,"",
-	xbstream_encrypt_algo_names, NULL};
-
 /* Need the following definitions to avoid linking with ds_*.o and their link
 dependencies */
 datasink_t datasink_archive;
 datasink_t datasink_xbstream;
 datasink_t datasink_compress;
 datasink_t datasink_tmpfile;
-datasink_t datasink_encrypt;
 datasink_t datasink_buffer;
 
 static run_mode_t	opt_mode;
 static char *		opt_directory = NULL;
 static my_bool		opt_verbose = 0;
 static int		opt_parallel = 1;
-static ulong 		opt_encrypt_algo;
-static char 		*opt_encrypt_key_file = NULL;
-static void 		*opt_encrypt_key = NULL;
-static int		opt_encrypt_threads = 1;
-
-enum {
-	OPT_ENCRYPT_THREADS = 256
-};
 
 static struct my_option my_long_options[] =
 {
@@ -86,20 +69,6 @@ static struct my_option my_long_options[] =
 	{"parallel", 'p', "Number of worker threads for reading / writing.",
 	 &opt_parallel, &opt_parallel, 0, GET_INT, REQUIRED_ARG,
 	 1, 1, INT_MAX, 0, 0, 0},
-	{"decrypt", 'd', "Decrypt files ending with .xbcrypt.",
-	 &opt_encrypt_algo, &opt_encrypt_algo, &xbstream_encrypt_algo_typelib,
-	 GET_ENUM, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-	{"encrypt-key", 'k', "Encryption key.",
-	 &opt_encrypt_key, &opt_encrypt_key, 0,
-	 GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-	{"encrypt-key-file", 'f', "File which contains encryption key.",
-	 &opt_encrypt_key_file, &opt_encrypt_key_file, 0,
-	 GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-	{"encrypt-threads", OPT_ENCRYPT_THREADS,
-	 "Number of threads for parallel data encryption. "
-	 "The default value is 1.",
-	 &opt_encrypt_threads, &opt_encrypt_threads,
-	 0, GET_INT, REQUIRED_ARG, 1, 1, INT_MAX, 0, 0, 0},
 
 	{0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
 };
@@ -108,7 +77,6 @@ typedef struct {
 	HASH			*filehash;
 	xb_rstream_t		*stream;
 	ds_ctxt_t		*ds_ctxt;
-	ds_ctxt_t		*ds_decrypt_ctxt;
 	pthread_mutex_t		*mutex;
 } extract_ctxt_t;
 
@@ -348,19 +316,6 @@ err:
 	return 1;
 }
 
-/************************************************************************
-Check if string ends with given suffix.
-@return true if string ends with given suffix. */
-static
-my_bool
-ends_with(const char *str, const char *suffix)
-{
-	size_t suffix_len = strlen(suffix);
-	size_t str_len = strlen(str);
-	return(str_len >= suffix_len
-	       && strcmp(str + str_len - suffix_len, suffix) == 0);
-}
-
 static
 file_entry_t *
 file_entry_new(extract_ctxt_t *ctxt, const char *path, uint pathlen)
@@ -380,11 +335,8 @@ file_entry_new(extract_ctxt_t *ctxt, const char *path, uint pathlen)
 	}
 	entry->pathlen = pathlen;
 
-	if (ctxt->ds_decrypt_ctxt && ends_with(path, ".xbcrypt")) {
-		file = ds_open(ctxt->ds_decrypt_ctxt, path, NULL);
-	} else {
-		file = ds_open(ctxt->ds_ctxt, path, NULL);
-	}
+	file = ds_open(ctxt->ds_ctxt, path, NULL);
+
 	if (file == NULL) {
 		msg("%s: failed to create file.\n", my_progname);
 		goto err;
@@ -534,7 +486,6 @@ mode_extract(int n_threads, int argc __attribute__((unused)),
 	xb_rstream_t		*stream = NULL;
 	HASH			filehash;
 	ds_ctxt_t		*ds_ctxt = NULL;
-	ds_ctxt_t		*ds_decrypt_ctxt = NULL;
 	extract_ctxt_t		ctxt;
 	int			i;
 	pthread_t		*tids = NULL;
@@ -574,7 +525,6 @@ mode_extract(int n_threads, int argc __attribute__((unused)),
 	ctxt.stream = stream;
 	ctxt.filehash = &filehash;
 	ctxt.ds_ctxt = ds_ctxt;
-	ctxt.ds_decrypt_ctxt = ds_decrypt_ctxt;
 	ctxt.mutex = &mutex;
 
 	tids = malloc(sizeof(pthread_t) * n_threads);
@@ -604,9 +554,6 @@ exit:
 	if (ds_ctxt != NULL) {
 		ds_destroy(ds_ctxt);
 	}
- 	if (ds_decrypt_ctxt) {
- 		ds_destroy(ds_decrypt_ctxt);
- 	}
 	xb_stream_read_done(stream);
 
 	return ret;
diff --git a/extra/mariabackup/xtrabackup.cc b/extra/mariabackup/xtrabackup.cc
index 28de33a5524..baad5b12118 100644
--- a/extra/mariabackup/xtrabackup.cc
+++ b/extra/mariabackup/xtrabackup.cc
@@ -59,7 +59,6 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #include <btr0sea.h>
 #include <dict0priv.h>
-#include <dict0stats.h>
 #include <lock0lock.h>
 #include <log0recv.h>
 #include <row0mysql.h>
@@ -112,7 +111,6 @@ char xtrabackup_real_target_dir[FN_REFLEN] = "./xtrabackup_backupfiles/";
 char *xtrabackup_target_dir= xtrabackup_real_target_dir;
 my_bool xtrabackup_version = FALSE;
 my_bool xtrabackup_backup = FALSE;
-my_bool xtrabackup_stats = FALSE;
 my_bool xtrabackup_prepare = FALSE;
 my_bool xtrabackup_copy_back = FALSE;
 my_bool xtrabackup_move_back = FALSE;
@@ -144,8 +142,6 @@ char xtrabackup_real_incremental_basedir[FN_REFLEN];
 char xtrabackup_real_extra_lsndir[FN_REFLEN];
 char xtrabackup_real_incremental_dir[FN_REFLEN];
 
-lsn_t xtrabackup_archived_to_lsn = 0; /* for --archived-to-lsn */
-
 char *xtrabackup_tmpdir;
 
 char *xtrabackup_tables = NULL;
@@ -197,21 +193,6 @@ ibool xtrabackup_compress = FALSE;
 uint xtrabackup_compress_threads;
 ulonglong xtrabackup_compress_chunk_size = 0;
 
-const char *xtrabackup_encrypt_algo_names[] =
-{ "NONE", "AES128", "AES192", "AES256", NullS};
-TYPELIB xtrabackup_encrypt_algo_typelib=
-{array_elements(xtrabackup_encrypt_algo_names)-1,"",
-	xtrabackup_encrypt_algo_names, NULL};
-
-ibool xtrabackup_encrypt = FALSE;
-ulong xtrabackup_encrypt_algo;
-char *xtrabackup_encrypt_key = NULL;
-char *xtrabackup_encrypt_key_file = NULL;
-uint xtrabackup_encrypt_threads;
-ulonglong xtrabackup_encrypt_chunk_size = 0;
-
-ulint xtrabackup_rebuild_threads = 1;
-
 /* sleep interval beetween log copy iterations in log copying thread
 in milliseconds (default is 1 second) */
 ulint xtrabackup_log_copy_interval = 1000;
@@ -271,7 +252,6 @@ are determined in innobase_init below: */
 char*	innobase_ignored_opt			= NULL;
 char*	innobase_data_home_dir			= NULL;
 char*	innobase_data_file_path 		= NULL;
-char*	innobase_log_arch_dir			= NULL;/* unused */
 /* The following has a misleading name: starting from 4.0.5, this also
 affects Windows: */
 char*	innobase_unix_file_flush_method		= NULL;
@@ -280,7 +260,6 @@ char*	innobase_unix_file_flush_method		= NULL;
 values */
 
 ulong	innobase_fast_shutdown			= 1;
-my_bool innobase_log_archive			= FALSE;/* unused */
 my_bool innobase_use_doublewrite    = TRUE;
 my_bool innobase_use_checksums      = TRUE;
 my_bool innobase_use_large_pages    = FALSE;
@@ -303,21 +282,11 @@ ulong	innobase_active_counter	= 0;
 
 static char *xtrabackup_debug_sync = NULL;
 
-my_bool xtrabackup_compact = FALSE;
-my_bool xtrabackup_rebuild_indexes = FALSE;
-
 my_bool xtrabackup_incremental_force_scan = FALSE;
 
 /* The flushed lsn which is read from data files */
 lsn_t	flushed_lsn= 0;
 
-/* The size of archived log file */
-ib_int64_t xtrabackup_arch_file_size = 0ULL;
-/* The minimal LSN of found archived log files */
-lsn_t xtrabackup_arch_first_file_lsn = 0ULL;
-/* The maximum LSN of found archived log files */
-lsn_t xtrabackup_arch_last_file_lsn = 0ULL;
-
 ulong xb_open_files_limit= 0;
 char *xb_plugin_dir;
 char *xb_plugin_load;
@@ -382,8 +351,6 @@ TYPELIB query_type_typelib= {array_elements(query_type_names) - 1, "",
 ulong opt_lock_wait_query_type;
 ulong opt_kill_long_query_type;
 
-ulong opt_decrypt_algo = 0;
-
 uint opt_kill_long_queries_timeout = 0;
 uint opt_lock_wait_timeout = 0;
 uint opt_lock_wait_threshold = 0;
@@ -391,7 +358,6 @@ uint opt_debug_sleep_before_unlock = 0;
 uint opt_safe_slave_backup_timeout = 0;
 
 const char *opt_history = NULL;
-my_bool opt_decrypt = FALSE;
 
 #if defined(HAVE_OPENSSL)
 my_bool opt_ssl_verify_server_cert = FALSE;
@@ -495,7 +461,6 @@ enum options_xtrabackup
   OPT_XTRA_TARGET_DIR = 1000,     /* make sure it is larger
                                      than OPT_MAX_CLIENT_OPTION */
   OPT_XTRA_BACKUP,
-  OPT_XTRA_STATS,
   OPT_XTRA_PREPARE,
   OPT_XTRA_EXPORT,
   OPT_XTRA_APPLY_LOG_ONLY,
@@ -507,7 +472,6 @@ enum options_xtrabackup
   OPT_XTRA_INCREMENTAL_BASEDIR,
   OPT_XTRA_EXTRA_LSNDIR,
   OPT_XTRA_INCREMENTAL_DIR,
-  OPT_XTRA_ARCHIVED_TO_LSN,
   OPT_XTRA_TABLES,
   OPT_XTRA_TABLES_FILE,
   OPT_XTRA_DATABASES,
@@ -518,11 +482,6 @@ enum options_xtrabackup
   OPT_XTRA_COMPRESS,
   OPT_XTRA_COMPRESS_THREADS,
   OPT_XTRA_COMPRESS_CHUNK_SIZE,
-  OPT_XTRA_ENCRYPT,
-  OPT_XTRA_ENCRYPT_KEY,
-  OPT_XTRA_ENCRYPT_KEY_FILE,
-  OPT_XTRA_ENCRYPT_THREADS,
-  OPT_XTRA_ENCRYPT_CHUNK_SIZE,
   OPT_LOG,
   OPT_INNODB,
   OPT_INNODB_CHECKSUMS,
@@ -535,8 +494,6 @@ enum options_xtrabackup
   OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,
   OPT_INNODB_FLUSH_METHOD,
   OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
-  OPT_INNODB_LOG_ARCH_DIR,
-  OPT_INNODB_LOG_ARCHIVE,
   OPT_INNODB_LOG_GROUP_HOME_DIR,
   OPT_INNODB_MAX_DIRTY_PAGES_PCT,
   OPT_INNODB_MAX_PURGE_LAG,
@@ -568,9 +525,6 @@ enum options_xtrabackup
   OPT_INNODB_THREAD_CONCURRENCY,
   OPT_INNODB_THREAD_SLEEP_DELAY,
   OPT_XTRA_DEBUG_SYNC,
-  OPT_XTRA_COMPACT,
-  OPT_XTRA_REBUILD_INDEXES,
-  OPT_XTRA_REBUILD_THREADS,
   OPT_INNODB_CHECKSUM_ALGORITHM,
   OPT_INNODB_UNDO_DIRECTORY,
   OPT_INNODB_UNDO_TABLESPACES,
@@ -597,7 +551,6 @@ enum options_xtrabackup
   OPT_DECOMPRESS,
   OPT_INCREMENTAL_HISTORY_NAME,
   OPT_INCREMENTAL_HISTORY_UUID,
-  OPT_DECRYPT,
   OPT_REMOVE_ORIGINAL,
   OPT_LOCK_WAIT_QUERY_TYPE,
   OPT_KILL_LONG_QUERY_TYPE,
@@ -628,9 +581,6 @@ struct my_option xb_client_options[] =
   {"backup", OPT_XTRA_BACKUP, "take backup to target-dir",
    (G_PTR*) &xtrabackup_backup, (G_PTR*) &xtrabackup_backup,
    0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"stats", OPT_XTRA_STATS, "calc statistic of datadir (offline mysqld is recommended)",
-   (G_PTR*) &xtrabackup_stats, (G_PTR*) &xtrabackup_stats,
-   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"prepare", OPT_XTRA_PREPARE, "prepare a backup for starting mysql server on the backup.",
    (G_PTR*) &xtrabackup_prepare, (G_PTR*) &xtrabackup_prepare,
    0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
@@ -669,10 +619,6 @@ struct my_option xb_client_options[] =
   {"incremental-dir", OPT_XTRA_INCREMENTAL_DIR, "(for --prepare): apply .delta files and logfile in the specified directory.",
    (G_PTR*) &xtrabackup_incremental_dir, (G_PTR*) &xtrabackup_incremental_dir,
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
- {"to-archived-lsn", OPT_XTRA_ARCHIVED_TO_LSN,
-   "Don't apply archived logs with bigger log sequence number.",
-   (G_PTR*) &xtrabackup_archived_to_lsn, (G_PTR*) &xtrabackup_archived_to_lsn, 0,
-   GET_LL, REQUIRED_ARG, 0, 0, LONGLONG_MAX, 0, 0, 0},
   {"tables", OPT_XTRA_TABLES, "filtering by regexp for table names.",
    (G_PTR*) &xtrabackup_tables, (G_PTR*) &xtrabackup_tables,
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
@@ -724,46 +670,6 @@ struct my_option xb_client_options[] =
    (G_PTR*) &xtrabackup_compress_chunk_size, (G_PTR*) &xtrabackup_compress_chunk_size,
    0, GET_ULL, REQUIRED_ARG, (1 << 16), 1024, ULONGLONG_MAX, 0, 0, 0},
 
-  {"encrypt", OPT_XTRA_ENCRYPT, "Encrypt individual backup files using the "
-   "specified encryption algorithm.",
-   &xtrabackup_encrypt_algo, &xtrabackup_encrypt_algo,
-   &xtrabackup_encrypt_algo_typelib, GET_ENUM, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-  {"encrypt-key", OPT_XTRA_ENCRYPT_KEY, "Encryption key to use.",
-   (G_PTR*) &xtrabackup_encrypt_key, (G_PTR*) &xtrabackup_encrypt_key, 0,
-   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-  {"encrypt-key-file", OPT_XTRA_ENCRYPT_KEY_FILE, "File which contains encryption key to use.",
-   (G_PTR*) &xtrabackup_encrypt_key_file, (G_PTR*) &xtrabackup_encrypt_key_file, 0,
-   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-
-  {"encrypt-threads", OPT_XTRA_ENCRYPT_THREADS,
-   "Number of threads for parallel data encryption. The default value is 1.",
-   (G_PTR*) &xtrabackup_encrypt_threads, (G_PTR*) &xtrabackup_encrypt_threads,
-   0, GET_UINT, REQUIRED_ARG, 1, 1, UINT_MAX, 0, 0, 0},
-
-  {"encrypt-chunk-size", OPT_XTRA_ENCRYPT_CHUNK_SIZE,
-   "Size of working buffer(S) for encryption threads in bytes. The default value is 64K.",
-   (G_PTR*) &xtrabackup_encrypt_chunk_size, (G_PTR*) &xtrabackup_encrypt_chunk_size,
-   0, GET_ULL, REQUIRED_ARG, (1 << 16), 1024, ULONGLONG_MAX, 0, 0, 0},
-
-  {"compact", OPT_XTRA_COMPACT,
-   "Create a compact backup by skipping secondary index pages.",
-   (G_PTR*) &xtrabackup_compact, (G_PTR*) &xtrabackup_compact,
-   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-
-  {"rebuild_indexes", OPT_XTRA_REBUILD_INDEXES,
-   "Rebuild secondary indexes in InnoDB tables after applying the log. "
-   "Only has effect with --prepare.",
-   (G_PTR*) &xtrabackup_rebuild_indexes, (G_PTR*) &xtrabackup_rebuild_indexes,
-   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-
-  {"rebuild_threads", OPT_XTRA_REBUILD_THREADS,
-   "Use this number of threads to rebuild indexes in a compact backup. "
-   "Only has effect with --prepare and --rebuild-indexes.",
-   (G_PTR*) &xtrabackup_rebuild_threads, (G_PTR*) &xtrabackup_rebuild_threads,
-   0, GET_UINT, REQUIRED_ARG, 1, 1, UINT_MAX, 0, 0, 0},
-
   {"incremental-force-scan", OPT_XTRA_INCREMENTAL_FORCE_SCAN,
    "Perform a full-scan incremental backup even in the presence of changed "
    "page bitmap data",
@@ -934,18 +840,6 @@ struct my_option xb_client_options[] =
    (uchar*) &opt_incremental_history_uuid, 0, GET_STR,
    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
-  {"decrypt", OPT_DECRYPT, "Decrypts all files with the .xbcrypt "
-   "extension in a backup previously made with --encrypt option.",
-   &opt_decrypt_algo, &opt_decrypt_algo,
-   &xtrabackup_encrypt_algo_typelib, GET_ENUM, REQUIRED_ARG,
-   0, 0, 0, 0, 0, 0},
-
-  {"remove-original", OPT_REMOVE_ORIGINAL, "Remove .qp and .xbcrypt files "
-   "after decryption and decompression.",
-   (uchar *) &opt_remove_original,
-   (uchar *) &opt_remove_original,
-   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-
   {"ftwrl-wait-query-type", OPT_LOCK_WAIT_QUERY_TYPE,
    "This option specifies which types of queries are allowed to complete "
    "before innobackupex will issue the global lock. Default is all.",
@@ -1125,9 +1019,6 @@ Disable with --skip-innodb-doublewrite.", (G_PTR*) &innobase_use_doublewrite,
    (G_PTR*) &innobase_force_recovery, (G_PTR*) &innobase_force_recovery, 0,
    GET_LONG, REQUIRED_ARG, 0, 0, 6, 0, 1, 0},
 
-  {"innodb_log_arch_dir", OPT_INNODB_LOG_ARCH_DIR,
-   "Where full logs should be archived.", (G_PTR*) &innobase_log_arch_dir,
-   (G_PTR*) &innobase_log_arch_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   {"innodb_log_buffer_size", OPT_INNODB_LOG_BUFFER_SIZE,
    "The size of the buffer which InnoDB uses to write log to the log files on disk.",
    (G_PTR*) &innobase_log_buffer_size, (G_PTR*) &innobase_log_buffer_size, 0,
@@ -1466,24 +1357,6 @@ xb_get_one_option(int optid,
     }
     xtrabackup_compress = TRUE;
     break;
-  case OPT_XTRA_ENCRYPT:
-    if (argument == NULL)
-    {
-      msg("Missing --encrypt argument, must specify a valid encryption "
-          " algorithm.\n");
-      return 1;
-    }
-    xtrabackup_encrypt = TRUE;
-    break;
-  case OPT_DECRYPT:
-    if (argument == NULL) {
-      msg("Missing --decrypt argument, must specify a "
-          "valid encryption  algorithm.\n");
-      return(1);
-    }
-    opt_decrypt = TRUE;
-    xtrabackup_decrypt_decompress = true;
-    break;
   case OPT_DECOMPRESS:
     opt_decompress = TRUE;
     xtrabackup_decrypt_decompress = true;
@@ -1637,7 +1510,7 @@ innodb_init_param(void)
 	/* Set InnoDB initialization parameters according to the values
 	read from MySQL .cnf file */
 
-	if (xtrabackup_backup || xtrabackup_stats) {
+	if (xtrabackup_backup) {
 		msg("xtrabackup: using the following InnoDB configuration:\n");
 	} else {
 		msg("xtrabackup: using the following InnoDB configuration "
@@ -1648,7 +1521,7 @@ innodb_init_param(void)
 
 	/* The default dir for data files is the datadir of MySQL */
 
-	srv_data_home = ((xtrabackup_backup || xtrabackup_stats) && innobase_data_home_dir
+	srv_data_home = (xtrabackup_backup && innobase_data_home_dir
 			 ? innobase_data_home_dir : default_path);
 	msg("xtrabackup:   innodb_data_home_dir = %s\n", srv_data_home);
 
@@ -1697,8 +1570,7 @@ mem_free_and_error:
 
 	/* The default dir for log files is the datadir of MySQL */
 
-	if (!((xtrabackup_backup || xtrabackup_stats) &&
-	      srv_log_group_home_dir)) {
+	if (!(xtrabackup_backup && srv_log_group_home_dir)) {
 		srv_log_group_home_dir = default_path;
 	}
 	if (xtrabackup_prepare && xtrabackup_incremental_dir) {
@@ -1731,7 +1603,6 @@ mem_free_and_error:
 	msg("xtrabackup:   innodb_log_file_size = %lld\n",
 	    (long long int) srv_log_file_size);
 
-	srv_log_archive_on = (ulint) innobase_log_archive;
 	srv_log_buffer_size = (ulint) innobase_log_buffer_size;
 
         /* We set srv_pool_size here in units of 1 kB. InnoDB internally
@@ -1760,11 +1631,8 @@ mem_free_and_error:
 
 	os_use_large_pages = (ibool) innobase_use_large_pages;
 	os_large_page_size = (ulint) innobase_large_page_size;
-
-	if (!innobase_log_arch_dir) {
-		static char default_dir[3] = "./";
-		srv_arch_dir = default_dir;
-	}
+	static char default_dir[3] = "./";
+	srv_arch_dir = default_dir;
 	row_rollback_on_timeout = (ibool) innobase_rollback_on_timeout;
 
 	srv_file_per_table = (my_bool) innobase_file_per_table;
@@ -1984,13 +1852,11 @@ xtrabackup_print_metadata(char *buf, size_t buf_len)
 		 "from_lsn = " UINT64PF "\n"
 		 "to_lsn = " UINT64PF "\n"
 		 "last_lsn = " UINT64PF "\n"
-		 "compact = %d\n"
 		 "recover_binlog_info = %d\n",
 		 metadata_type,
 		 metadata_from_lsn,
 		 metadata_to_lsn,
 		 metadata_last_lsn,
-		 MY_TEST(false),
 		 MY_TEST(opt_binlog_info == BINLOG_INFO_LOCKLESS));
 }
 
@@ -2428,25 +2294,13 @@ xb_get_copy_action(const char *dflt)
 
 	if (xtrabackup_stream) {
 		if (xtrabackup_compress) {
-			if (xtrabackup_encrypt) {
-				action = "Compressing, encrypting and streaming";
-			} else {
-				action = "Compressing and streaming";
-			}
-		} else if (xtrabackup_encrypt) {
-			action = "Encrypting and streaming";
+			action = "Compressing and streaming";
 		} else {
 			action = "Streaming";
 		}
 	} else {
 		if (xtrabackup_compress) {
-			if (xtrabackup_encrypt) {
-				action = "Compressing and encrypting";
-			} else {
-				action = "Compressing";
-			}
-		} else if (xtrabackup_encrypt) {
-			action = "Encrypting";
+			action = "Compressing";
 		} else {
 			action = dflt;
 		}
@@ -3012,28 +2866,6 @@ xtrabackup_init_datasinks(void)
 		ds_redo = ds_meta = ds_data;
 	}
 
-	/* Encryption */
-	if (xtrabackup_encrypt) {
-		ds_ctxt_t	*ds;
-
-
-
-		ds = ds_create(xtrabackup_target_dir, DS_TYPE_ENCRYPT);
-		xtrabackup_add_datasink(ds);
-
-		ds_set_pipe(ds, ds_data);
-		if (ds_data != ds_meta) {
-			ds_data = ds;
-			ds = ds_create(xtrabackup_target_dir, DS_TYPE_ENCRYPT);
-			xtrabackup_add_datasink(ds);
-
-			ds_set_pipe(ds, ds_meta);
-			ds_redo = ds_meta = ds;
-		} else {
-			ds_redo = ds_data = ds_meta = ds;
-		}
-	}
-
 	/* Compression for ds_data and ds_redo */
 	if (xtrabackup_compress) {
 		ds_ctxt_t	*ds;
@@ -4243,431 +4075,6 @@ reread_log_header:
 	}
 }
 
-/* ================= stats ================= */
-static my_bool
-xtrabackup_stats_level(
-	dict_index_t*	index,
-	ulint		level)
-{
-	ulint	space;
-	page_t*	page;
-
-	rec_t*	node_ptr;
-
-	ulint	right_page_no;
-
-	page_cur_t	cursor;
-
-	mtr_t	mtr;
-	mem_heap_t*	heap	= mem_heap_create(256);
-
-	ulint*	offsets = NULL;
-
-	ulonglong n_pages, n_pages_extern;
-	ulonglong sum_data, sum_data_extern;
-	ulonglong n_recs;
-	ulint	page_size;
-	buf_block_t*	block;
-	ulint	zip_size;
-
-	n_pages = sum_data = n_recs = 0;
-	n_pages_extern = sum_data_extern = 0;
-
-
-	if (level == 0)
-		fprintf(stdout, "        leaf pages: ");
-	else
-		fprintf(stdout, "     level %lu pages: ", level);
-
-	mtr_start(&mtr);
-
-	mtr_x_lock(&(index->lock), &mtr);
-	block = btr_root_block_get(index, RW_X_LATCH, &mtr);
-	page = buf_block_get_frame(block);
-
-	space = page_get_space_id(page);
-	zip_size = fil_space_get_zip_size(space);
-
-	while (level != btr_page_get_level(page, &mtr)) {
-
-		ut_a(space == buf_block_get_space(block));
-		ut_a(space == page_get_space_id(page));
-		ut_a(!page_is_leaf(page));
-
-		page_cur_set_before_first(block, &cursor);
-		page_cur_move_to_next(&cursor);
-
-		node_ptr = page_cur_get_rec(&cursor);
-		offsets = rec_get_offsets(node_ptr, index, offsets,
-					ULINT_UNDEFINED, &heap);
-		block = btr_node_ptr_get_child(node_ptr, index, offsets, &mtr);
-		page = buf_block_get_frame(block);
-	}
-
-loop:
-	mem_heap_empty(heap);
-	offsets = NULL;
-	mtr_x_lock(&(index->lock), &mtr);
-
-	right_page_no = btr_page_get_next(page, &mtr);
-
-
-	/*=================================*/
-	//fprintf(stdout, "%lu ", (ulint) buf_frame_get_page_no(page));
-
-	n_pages++;
-	sum_data += page_get_data_size(page);
-	n_recs += page_get_n_recs(page);
-
-
-	if (level == 0) {
-		page_cur_t	cur;
-		ulint	n_fields;
-		ulint	i;
-		mem_heap_t*	local_heap	= NULL;
-		ulint	offsets_[REC_OFFS_NORMAL_SIZE];
-		ulint*	local_offsets	= offsets_;
-
-		*offsets_ = (sizeof offsets_) / sizeof *offsets_;
-
-		page_cur_set_before_first(block, &cur);
-		page_cur_move_to_next(&cur);
-
-		for (;;) {
-			if (page_cur_is_after_last(&cur)) {
-				break;
-			}
-
-			local_offsets = rec_get_offsets(cur.rec, index, local_offsets,
-						ULINT_UNDEFINED, &local_heap);
-			n_fields = rec_offs_n_fields(local_offsets);
-
-			for (i = 0; i < n_fields; i++) {
-				if (rec_offs_nth_extern(local_offsets, i)) {
-					page_t*	local_page;
-					ulint	space_id;
-					ulint	page_no;
-					ulint	offset;
-					byte*	blob_header;
-					ulint	part_len;
-					mtr_t	local_mtr;
-					ulint	local_len;
-					byte*	data;
-					buf_block_t*	local_block;
-
-					data = rec_get_nth_field(cur.rec, local_offsets, i, &local_len);
-
-					ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE);
-					local_len -= BTR_EXTERN_FIELD_REF_SIZE;
-
-					space_id = mach_read_from_4(data + local_len + BTR_EXTERN_SPACE_ID);
-					page_no = mach_read_from_4(data + local_len + BTR_EXTERN_PAGE_NO);
-					offset = mach_read_from_4(data + local_len + BTR_EXTERN_OFFSET);
-
-					if (offset != FIL_PAGE_DATA)
-						msg("\nWarning: several record may share same external page.\n");
-
-					for (;;) {
-						mtr_start(&local_mtr);
-
-						local_block = btr_block_get(space_id, zip_size, page_no, RW_S_LATCH, index, &local_mtr);
-						local_page = buf_block_get_frame(local_block);
-						blob_header = local_page + offset;
-#define BTR_BLOB_HDR_PART_LEN		0
-#define BTR_BLOB_HDR_NEXT_PAGE_NO	4
-						//part_len = btr_blob_get_part_len(blob_header);
-						part_len = mach_read_from_4(blob_header + BTR_BLOB_HDR_PART_LEN);
-
-						//page_no = btr_blob_get_next_page_no(blob_header);
-						page_no = mach_read_from_4(blob_header + BTR_BLOB_HDR_NEXT_PAGE_NO);
-
-						offset = FIL_PAGE_DATA;
-
-
-
-
-						/*=================================*/
-						//fprintf(stdout, "[%lu] ", (ulint) buf_frame_get_page_no(page));
-
-						n_pages_extern++;
-						sum_data_extern += part_len;
-
-
-						mtr_commit(&local_mtr);
-
-						if (page_no == FIL_NULL)
-							break;
-					}
-				}
-			}
-
-			page_cur_move_to_next(&cur);
-		}
-	}
-
-
-
-
-	mtr_commit(&mtr);
-	if (right_page_no != FIL_NULL) {
-		mtr_start(&mtr);
-		block = btr_block_get(space, zip_size, right_page_no,
-				      RW_X_LATCH, index, &mtr);
-		page = buf_block_get_frame(block);
-		goto loop;
-	}
-	mem_heap_free(heap);
-
-	if (zip_size) {
-		page_size = zip_size;
-	} else {
-		page_size = UNIV_PAGE_SIZE;
-	}
-
-	if (level == 0)
-		fprintf(stdout, "recs=%llu, ", n_recs);
-
-	fprintf(stdout, "pages=%llu, data=%llu bytes, data/pages=%lld%%",
-		n_pages, sum_data,
-		((sum_data * 100)/ page_size)/n_pages);
-
-
-	if (level == 0 && n_pages_extern) {
-		putc('\n', stdout);
-		/* also scan blob pages*/
-		fprintf(stdout, "    external pages: ");
-
-		fprintf(stdout, "pages=%llu, data=%llu bytes, data/pages=%lld%%",
-			n_pages_extern, sum_data_extern,
-			((sum_data_extern * 100)/ page_size)/n_pages_extern);
-	}
-
-	putc('\n', stdout);
-
-	if (level > 0) {
-		xtrabackup_stats_level(index, level - 1);
-	}
-
-	return(TRUE);
-}
-
-static void
-xtrabackup_stats_func(int argc, char **argv)
-{
-	ulint n;
-
-	/* cd to datadir */
-
-	if (my_setwd(mysql_real_data_home,MYF(MY_WME)))
-	{
-		msg("xtrabackup: cannot my_setwd %s\n", mysql_real_data_home);
-		exit(EXIT_FAILURE);
-	}
-	msg("xtrabackup: cd to %s\n", mysql_real_data_home);
-	encryption_plugin_prepare_init(argc, argv);
-	mysql_data_home= mysql_data_home_buff;
-	mysql_data_home[0]=FN_CURLIB;		// all paths are relative from here
-	mysql_data_home[1]=0;
-
-	srv_n_purge_threads = 1;
-	/* set read only */
-	srv_read_only_mode = TRUE;
-
-	/* initialize components */
-	if(innodb_init_param())
-		exit(EXIT_FAILURE);
-
-	/* Check if the log files have been created, otherwise innodb_init()
-	will crash when called with srv_read_only == TRUE */
-	for (n = 0; n < srv_n_log_files; n++) {
-		char		logname[FN_REFLEN];
-		ibool		exists;
-		os_file_type_t	type;
-
-		snprintf(logname, sizeof(logname), "%s%c%s%lu",
-			srv_log_group_home_dir, SRV_PATH_SEPARATOR,
-			"ib_logfile", (ulong) n);
-		srv_normalize_path_for_win(logname);
-
-		if (!os_file_status(logname, &exists, &type) || !exists ||
-		    type != OS_FILE_TYPE_FILE) {
-			msg("xtrabackup: Error: "
-			    "Cannot find log file %s.\n", logname);
-			msg("xtrabackup: Error: "
-			    "to use the statistics feature, you need a "
-			    "clean copy of the database including "
-			    "correctly sized log files, so you need to "
-			    "execute with --prepare twice to use this "
-			    "functionality on a backup.\n");
-			exit(EXIT_FAILURE);
-		}
-	}
-
-	msg("xtrabackup: Starting 'read-only' InnoDB instance to gather "
-	    "index statistics.\n"
-	    "xtrabackup: Using %lld bytes for buffer pool (set by "
-	    "--use-memory parameter)\n", xtrabackup_use_memory);
-
-	if(innodb_init())
-		exit(EXIT_FAILURE);
-
-	xb_filters_init();
-
-	fprintf(stdout, "\n\n<INDEX STATISTICS>\n");
-
-	/* gather stats */
-
-	{
-	dict_table_t*	sys_tables;
-	dict_index_t*	sys_index;
-	dict_table_t*	table;
-	btr_pcur_t	pcur;
-	rec_t*		rec;
-	byte*		field;
-	ulint		len;
-	mtr_t		mtr;
-
-	/* Enlarge the fatal semaphore wait timeout during the InnoDB table
-	monitor printout */
-
-	os_increment_counter_by_amount(server_mutex,
-				       srv_fatal_semaphore_wait_threshold,
-				       72000);
-
-	mutex_enter(&(dict_sys->mutex));
-
-	mtr_start(&mtr);
-
-	sys_tables = dict_table_get_low("SYS_TABLES");
-	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);
-
-	btr_pcur_open_at_index_side(TRUE, sys_index, BTR_SEARCH_LEAF, &pcur,
-				    TRUE, 0, &mtr);
-loop:
-	btr_pcur_move_to_next_user_rec(&pcur, &mtr);
-
-	rec = btr_pcur_get_rec(&pcur);
-
-	if (!btr_pcur_is_on_user_rec(&pcur))
-	{
-		/* end of index */
-
-		btr_pcur_close(&pcur);
-		mtr_commit(&mtr);
-
-		mutex_exit(&(dict_sys->mutex));
-
-		/* Restore the fatal semaphore wait timeout */
-		os_increment_counter_by_amount(server_mutex,
-					       srv_fatal_semaphore_wait_threshold,
-					       -72000);
-
-		goto end;
-	}
-
-	field = rec_get_nth_field_old(rec, 0, &len);
-
-	if (!rec_get_deleted_flag(rec, 0)) {
-
-		/* We found one */
-
-                char*	table_name = mem_strdupl((char*) field, len);
-
-		btr_pcur_store_position(&pcur, &mtr);
-
-		mtr_commit(&mtr);
-
-		table = dict_table_get_low(table_name);
-		mem_free(table_name);
-
-		if (table && check_if_skip_table(table->name))
-			goto skip;
-
-
-		if (table == NULL) {
-			fputs("InnoDB: Failed to load table ", stderr);
-			ut_print_namel(stderr, NULL, TRUE, (char*) field, len);
-			putc('\n', stderr);
-		} else {
-			dict_index_t*	index;
-
-			/* The table definition was corrupt if there
-			is no index */
-
-			if (dict_table_get_first_index(table)) {
-				dict_stats_update_transient(table);
-			}
-
-			//dict_table_print_low(table);
-
-			index = UT_LIST_GET_FIRST(table->indexes);
-			while (index != NULL) {
-{
-	ib_int64_t	n_vals;
-
-	if (index->n_user_defined_cols > 0) {
-		n_vals = index->stat_n_diff_key_vals[
-					index->n_user_defined_cols];
-	} else {
-		n_vals = index->stat_n_diff_key_vals[1];
-	}
-
-	fprintf(stdout,
-		"  table: %s, index: %s, space id: %lu, root page: %lu"
-		", zip size: %lu"
-		"\n  estimated statistics in dictionary:\n"
-		"    key vals: %lu, leaf pages: %lu, size pages: %lu\n"
-		"  real statistics:\n",
-		table->name, index->name,
-		(ulong) index->space,
-		(ulong) index->page,
-		(ulong) fil_space_get_zip_size(index->space),
-		(ulong) n_vals,
-		(ulong) index->stat_n_leaf_pages,
-		(ulong) index->stat_index_size);
-
-	{
-		mtr_t	local_mtr;
-		page_t*	root;
-		ulint	page_level;
-
-		mtr_start(&local_mtr);
-
-		mtr_x_lock(&(index->lock), &local_mtr);
-		root = btr_root_get(index, &local_mtr);
-		page_level = btr_page_get_level(root, &local_mtr);
-
-		xtrabackup_stats_level(index, page_level);
-
-		mtr_commit(&local_mtr);
-	}
-
-	putc('\n', stdout);
-}
-				index = UT_LIST_GET_NEXT(indexes, index);
-			}
-		}
-
-skip:
-		mtr_start(&mtr);
-
-		btr_pcur_restore_position(BTR_SEARCH_LEAF, &pcur, &mtr);
-	}
-
-	goto loop;
-	}
-
-end:
-	putc('\n', stdout);
-
-	fflush(stdout);
-
-	xb_filters_free();
-
-	/* shutdown InnoDB */
-	innodb_end();
-}
-
 /* ================= prepare ================= */
 
 static my_bool
@@ -6045,74 +5452,6 @@ xb_export_cfg_write(
 
 }
 
-/********************************************************************//**
-Searches archived log files in archived log directory. The min and max
-LSN's of found files as well as archived log file size are stored in
-xtrabackup_arch_first_file_lsn, xtrabackup_arch_last_file_lsn and
-xtrabackup_arch_file_size respectively.
-@return true on success
-*/
-static
-bool
-xtrabackup_arch_search_files(
-/*=========================*/
-	ib_uint64_t	start_lsn)		/*!< in: filter out log files
-						witch does not contain data
-						with lsn < start_lsn */
-{
-	os_file_dir_t	dir;
-	os_file_stat_t	fileinfo;
-	ut_ad(innobase_log_arch_dir);
-
-	dir = os_file_opendir(innobase_log_arch_dir, FALSE);
-	if (!dir) {
-		msg("xtrabackup: error: cannot open archived log directory %s\n",
-		    innobase_log_arch_dir);
-		return false;
-	}
-
-	while(!os_file_readdir_next_file(innobase_log_arch_dir,
-					 dir,
-					 &fileinfo) ) {
-		lsn_t	log_file_lsn;
-		char*	log_str_end_lsn_ptr;
-
-		if (strncmp(fileinfo.name,
-			    IB_ARCHIVED_LOGS_PREFIX,
-			    sizeof(IB_ARCHIVED_LOGS_PREFIX) - 1)) {
-			continue;
-		}
-
-		log_file_lsn = strtoll(fileinfo.name +
-				       sizeof(IB_ARCHIVED_LOGS_PREFIX) - 1,
-				       &log_str_end_lsn_ptr, 10);
-
-		if (*log_str_end_lsn_ptr) {
-			continue;
-		}
-
-		if (log_file_lsn + (fileinfo.size - LOG_FILE_HDR_SIZE)	< start_lsn) {
-			continue;
-		}
-
-		if (!xtrabackup_arch_first_file_lsn ||
-		    log_file_lsn < xtrabackup_arch_first_file_lsn) {
-			xtrabackup_arch_first_file_lsn = log_file_lsn;
-		}
-		if (log_file_lsn > xtrabackup_arch_last_file_lsn) {
-			xtrabackup_arch_last_file_lsn = log_file_lsn;
-		}
-
-		//TODO: find the more suitable way to extract archived log file
-		//size
-		if (fileinfo.size > (ib_int64_t)xtrabackup_arch_file_size) {
-			xtrabackup_arch_file_size = fileinfo.size;
-		}
-	}
-
-	return xtrabackup_arch_first_file_lsn != 0;
-}
-
 static
 void
 innodb_free_param()
@@ -6178,8 +5517,7 @@ xtrabackup_prepare_func(int argc, char ** argv)
 	xtrabackup_target_dir[1]=0;
 
 	/*
-	  read metadata of target, we don't need metadata reading in the case
-	  archived logs applying
+	  read metadata of target
 	*/
 	sprintf(metadata_path, "%s/%s", xtrabackup_target_dir,
 		XTRABACKUP_METADATA_FILENAME);
@@ -6190,38 +5528,33 @@ xtrabackup_prepare_func(int argc, char ** argv)
 		exit(EXIT_FAILURE);
 	}
 
-	if (!innobase_log_arch_dir)
-	{
-		if (!strcmp(metadata_type, "full-backuped")) {
-			msg("xtrabackup: This target seems to be not prepared "
-			    "yet.\n");
-		} else if (!strcmp(metadata_type, "log-applied")) {
-			msg("xtrabackup: This target seems to be already "
-			    "prepared with --apply-log-only.\n");
-			goto skip_check;
-		} else if (!strcmp(metadata_type, "full-prepared")) {
-			msg("xtrabackup: This target seems to be already "
-			    "prepared.\n");
-		} else {
-			msg("xtrabackup: This target seems not to have correct "
-			    "metadata...\n");
-			exit(EXIT_FAILURE);
-		}
+	if (!strcmp(metadata_type, "full-backuped")) {
+		msg("xtrabackup: This target seems to be not prepared yet.\n");
+	} else if (!strcmp(metadata_type, "log-applied")) {
+		msg("xtrabackup: This target seems to be already "
+		    "prepared with --apply-log-only.\n");
+		goto skip_check;
+	} else if (!strcmp(metadata_type, "full-prepared")) {
+		msg("xtrabackup: This target seems to be already prepared.\n");
+	} else {
+		msg("xtrabackup: This target seems not to have correct "
+		    "metadata...\n");
+		exit(EXIT_FAILURE);
+	}
 
-		if (xtrabackup_incremental) {
-			msg("xtrabackup: error: applying incremental backup "
-			    "needs target prepared with --apply-log-only.\n");
-			exit(EXIT_FAILURE);
-		}
+	if (xtrabackup_incremental) {
+		msg("xtrabackup: error: applying incremental backup "
+		    "needs target prepared with --apply-log-only.\n");
+		exit(EXIT_FAILURE);
+	}
 skip_check:
-		if (xtrabackup_incremental
-		    && metadata_to_lsn != incremental_lsn) {
-			msg("xtrabackup: error: This incremental backup seems "
-			    "not to be proper for the target.\n"
-			    "xtrabackup:  Check 'to_lsn' of the target and "
-			    "'from_lsn' of the incremental.\n");
-			exit(EXIT_FAILURE);
-		}
+	if (xtrabackup_incremental
+	    && metadata_to_lsn != incremental_lsn) {
+		msg("xtrabackup: error: This incremental backup seems "
+		    "not to be proper for the target.\n"
+		    "xtrabackup:  Check 'to_lsn' of the target and "
+		    "'from_lsn' of the incremental.\n");
+		exit(EXIT_FAILURE);
 	}
 
 	/* Create logfiles for recovery from 'xtrabackup_logfile', before start InnoDB */
@@ -6244,7 +5577,7 @@ skip_check:
 
 	xb_filters_init();
 
-	if(!innobase_log_arch_dir && xtrabackup_init_temp_log())
+	if (xtrabackup_init_temp_log())
 		goto error_cleanup;
 
 	if(innodb_init_param()) {
@@ -6253,7 +5586,7 @@ skip_check:
 
 	xb_normalize_init_values();
 
-	if (xtrabackup_incremental || innobase_log_arch_dir) {
+	if (xtrabackup_incremental) {
 		err = xb_data_files_init();
 		if (err != DB_SUCCESS) {
 			msg("xtrabackup: error: xb_data_files_init() failed "
@@ -6270,7 +5603,7 @@ skip_check:
 			goto error_cleanup;
 		}
 	}
-	if (xtrabackup_incremental || innobase_log_arch_dir) {
+	if (xtrabackup_incremental) {
 		xb_data_files_close();
 	}
 	if (xtrabackup_incremental) {
@@ -6306,53 +5639,6 @@ skip_check:
 		srv_n_write_io_threads = 4;
 	}
 
-	if (innobase_log_arch_dir) {
-		srv_arch_dir = innobase_log_arch_dir;
-		srv_archive_recovery = true;
-		if (xtrabackup_archived_to_lsn) {
-			if (xtrabackup_archived_to_lsn < metadata_last_lsn) {
-				msg("xtrabackup: warning: logs applying lsn "
-				    "limit " UINT64PF " is "
-				    "less than metadata last-lsn " UINT64PF
-				    " and will be set to metadata last-lsn value\n",
-				    xtrabackup_archived_to_lsn,
-				    metadata_last_lsn);
-				xtrabackup_archived_to_lsn = metadata_last_lsn;
-			}
-			if (xtrabackup_archived_to_lsn < flushed_lsn) {
-				msg("xtrabackup: error: logs applying "
-				    "lsn limit " UINT64PF " is less than "
-				    "min_flushed_lsn " UINT64PF
-				    ", there is nothing to do\n",
-				    xtrabackup_archived_to_lsn,
-				    flushed_lsn);
-				goto error_cleanup;
-			}
-		}
-		srv_archive_recovery_limit_lsn= xtrabackup_archived_to_lsn;
-		/*
-		  Unfinished transactions are not rolled back during log applying
-		  as they can be finished at the firther files applyings.
-		*/
-		xtrabackup_apply_log_only = srv_apply_log_only = true;
-
-		if (!xtrabackup_arch_search_files(flushed_lsn)) {
-			goto error_cleanup;
-		}
-
-		/*
-		  Check if last log file last lsn is big enough to overlap
-		  last scanned lsn read from metadata.
-		*/
-		if (xtrabackup_arch_last_file_lsn +
-		    xtrabackup_arch_file_size -
-		    LOG_FILE_HDR_SIZE < metadata_last_lsn) {
-			msg("xtrabackup: error: there are no enough archived logs "
-			    "to apply\n");
-			goto error_cleanup;
-		}
-	}
-
 	msg("xtrabackup: Starting InnoDB instance for recovery.\n"
 	    "xtrabackup: Using %lld bytes for buffer pool "
 	    "(set by --use-memory parameter)\n", xtrabackup_use_memory);
@@ -6581,9 +5867,6 @@ next_node:
 		exit(EXIT_FAILURE);
 	}
 
-	if (innobase_log_arch_dir)
-		srv_start_lsn = log_sys->lsn = recv_sys->recovered_lsn;
-
 	/* Check whether the log is applied enough or not. */
 	if ((xtrabackup_incremental
 	     && srv_start_lsn < incremental_to_lsn)
@@ -6756,8 +6039,6 @@ xb_init()
 
 	if (opt_decompress) {
 		mixed_options[n_mixed_options++] = "--decompress";
-	} else if (opt_decrypt) {
-		mixed_options[n_mixed_options++] = "--decrypt";
 	}
 
 	if (xtrabackup_copy_back) {
@@ -7220,24 +6501,11 @@ int main(int argc, char **argv)
 		innobase_file_per_table = TRUE;
 	}
 
-	if (!xtrabackup_prepare &&
-	    (innobase_log_arch_dir || xtrabackup_archived_to_lsn)) {
-
-		/* Default my.cnf can contain innobase_log_arch_dir option set
-		for server, reset it to allow backup. */
-		innobase_log_arch_dir= NULL;
-		xtrabackup_archived_to_lsn= 0;
-		msg("xtrabackup: warning: "
-		    "as --innodb-log-arch-dir and --to-archived-lsn can be used "
-		    "only with --prepare they will be reset\n");
-	}
-
 	/* cannot execute both for now */
 	{
 		int num = 0;
 
 		if (xtrabackup_backup) num++;
-		if (xtrabackup_stats) num++;
 		if (xtrabackup_prepare) num++;
 		if (xtrabackup_copy_back) num++;
 		if (xtrabackup_move_back) num++;
@@ -7258,10 +6526,6 @@ int main(int argc, char **argv)
 	if (xtrabackup_backup)
 		xtrabackup_backup_func();
 
-	/* --stats */
-	if (xtrabackup_stats)
-		xtrabackup_stats_func(argc_server,server_defaults);
-
 	/* --prepare */
 	if (xtrabackup_prepare) {
 		xtrabackup_prepare_func(argc_server, server_defaults);
diff --git a/extra/mariabackup/xtrabackup.h b/extra/mariabackup/xtrabackup.h
index 371466aad2c..eafc848fd43 100644
--- a/extra/mariabackup/xtrabackup.h
+++ b/extra/mariabackup/xtrabackup.h
@@ -81,7 +81,6 @@ extern char		*xtrabackup_tables_exclude;
 extern char		*xtrabackup_databases_exclude;
 
 extern ibool		xtrabackup_compress;
-extern ibool		xtrabackup_encrypt;
 
 extern my_bool		xtrabackup_backup;
 extern my_bool		xtrabackup_prepare;
@@ -92,15 +91,10 @@ extern my_bool		xtrabackup_decrypt_decompress;
 
 extern char		*innobase_data_file_path;
 extern char		*innobase_doublewrite_file;
-extern char		*xtrabackup_encrypt_key;
-extern char		*xtrabackup_encrypt_key_file;
 extern longlong		innobase_log_file_size;
 extern long		innobase_log_files_in_group;
 extern longlong		innobase_page_size;
 
-extern const char	*xtrabackup_encrypt_algo_names[];
-extern TYPELIB		xtrabackup_encrypt_algo_typelib;
-
 extern int		xtrabackup_parallel;
 
 extern my_bool		xb_close_files;
@@ -113,9 +107,6 @@ extern "C"{
 #ifdef __cplusplus
 }
 #endif
-extern ulong		xtrabackup_encrypt_algo;
-extern uint		xtrabackup_encrypt_threads;
-extern ulonglong	xtrabackup_encrypt_chunk_size;
 extern my_bool		xtrabackup_export;
 extern char		*xtrabackup_incremental_basedir;
 extern char		*xtrabackup_extra_lsndir;
@@ -158,8 +149,6 @@ extern TYPELIB		query_type_typelib;
 extern ulong		opt_lock_wait_query_type;
 extern ulong		opt_kill_long_query_type;
 
-extern ulong		opt_decrypt_algo;
-
 extern uint		opt_kill_long_queries_timeout;
 extern uint		opt_lock_wait_timeout;
 extern uint		opt_lock_wait_threshold;
@@ -167,7 +156,6 @@ extern uint		opt_debug_sleep_before_unlock;
 extern uint		opt_safe_slave_backup_timeout;
 
 extern const char	*opt_history;
-extern my_bool		opt_decrypt;
 
 enum binlog_info_enum { BINLOG_INFO_OFF, BINLOG_INFO_LOCKLESS, BINLOG_INFO_ON,
 			BINLOG_INFO_AUTO};