InnoDB/XtraDB Encryption cleanup.

Step 1:
-- Remove page encryption from dictionary (per table
encryption will be handled by storing crypt_data to page 0)
-- Remove encryption/compression from os0file and all functions
before that (compression will be added to buf0buf.cc)
-- Use same CRYPT_SCHEME_1 for all encryption methods
-- Do some code cleanups to confort InnoDB coding style

1 files changed, 20 insertions, 418 deletions

diff --git a/storage/innobase/os/os0file.cc b/storage/innobase/os/os0file.cc
index d49f5f9900d..1287ee76819 100644
--- a/storage/innobase/os/os0file.cc
+++ b/storage/innobase/os/os0file.cc
@@ -43,9 +43,9 @@ Created 10/21/1995 Heikki Tuuri
 #include "srv0srv.h"
 #include "srv0start.h"
 #include "fil0fil.h"
+#include "fil0crypt.h"
 #include "fsp0fsp.h"
 #include "fil0pagecompress.h"
-#include "fil0pageencryption.h"
 #include "buf0buf.h"
 #include "srv0mon.h"
 #include "srv0srv.h"
@@ -224,49 +224,14 @@ struct os_aio_slot_t{
 					completed */
 	ulint           bitmap;
 
-	byte*           page_compression_page; /*!< Memory allocated for
-					       page compressed page and
-					       freed after the write
-					       has been completed */
-
-	byte*           page_encryption_page; /*!< Memory allocated for
-					      page encrypted page and
-					      freed after the write
-					      has been completed */
-
-	ibool           page_compression;
-	ulint           page_compression_level;
-
-	ibool           page_encryption;
-	ulint           page_encryption_key;
-
 	ulint*          write_size;     /*!< Actual write size initialized
 					after fist successfull trim
 					operation for this page and if
 					initialized we do not trim again if
 					actual page size does not decrease. */
 
-	byte*           page_buf;       /*!< Actual page buffer for
-					page compressed pages, do not
-					free this */
-
-	byte*           page_buf2;       /*!< Actual page buffer for
-					 page encrypted pages, do not
-					 free this */
-	byte*           tmp_encryption_buf; /*!< a temporal buffer used by page encryption */
-
-	ibool           page_compression_success;
-	/*!< TRUE if page compression was successfull, false if not */
-	ibool           page_encryption_success;
-	/*!< TRUE if page encryption was successfull, false if not */
-
-	lsn_t           lsn;       /* lsn of the newest modification */
-
 	ulint           file_block_size;/*!< file block size */
 
-	bool            encrypt_later;  /*!< should the page be encrypted
-					before write */
-
 #ifdef WIN_ASYNC_IO
 	HANDLE		handle;		/*!< handle object we need in the
 					OVERLAPPED struct */
@@ -403,39 +368,6 @@ os_file_trim(
 /*=========*/
 	os_aio_slot_t*	slot); /*!< in: slot structure     */
 
-/**********************************************************************//**
-Allocate memory for temporal buffer used for page compression. This
-buffer is freed later. */
-UNIV_INTERN
-void
-os_slot_alloc_page_buf(
-/*===================*/
-	os_aio_slot_t*	slot); /*!< in: slot structure     */
-
-#ifdef HAVE_LZO
-/**********************************************************************//**
-Allocate memory for temporal memory used for page compression when
-LZO compression method is used */
-UNIV_INTERN
-void
-os_slot_alloc_lzo_mem(
-/*===================*/
-	os_aio_slot_t*   slot); /*!< in: slot structure     */
-#endif
-
-/**********************************************************************//**
-Allocate memory for temporal buffer used for page encryption. This
-buffer is freed later. */
-UNIV_INTERN
-void
-os_slot_alloc_page_buf2(
-	os_aio_slot_t*	slot); /*!< in: slot structure */
-/**********************************************************************//**
-Allocate memory for temporal buffer used for page encryption. */
-UNIV_INTERN
-void
-os_slot_alloc_tmp_encryption_buf(
-	os_aio_slot_t* slot); /*!< in: slot structure */
 /****************************************************************//**
 Does error handling when a file operation fails.
 @return	TRUE if we should retry the operation */
@@ -2891,9 +2823,7 @@ os_file_read_func(
 	os_file_t	file,	/*!< in: handle to a file */
 	void*		buf,	/*!< in: buffer where to read */
 	os_offset_t	offset,	/*!< in: file offset where to read */
-	ulint		n,	/*!< in: number of bytes to read */
-	ibool		compressed) /*!< in: is this file space
-				    compressed ? */
+	ulint		n)	/*!< in: number of bytes to read */
 {
 #ifdef __WIN__
 	BOOL		ret;
@@ -3024,9 +2954,7 @@ os_file_read_no_error_handling_func(
 	os_file_t	file,	/*!< in: handle to a file */
 	void*		buf,	/*!< in: buffer where to read */
 	os_offset_t	offset,	/*!< in: file offset where to read */
-	ulint		n,	/*!< in: number of bytes to read */
-	ibool		compressed) /*!< in: is this file space
-				     compressed ? */
+	ulint		n)	/*!< in: number of bytes to read */
 {
 #ifdef __WIN__
 	BOOL		ret;
@@ -4184,9 +4112,8 @@ os_aio_array_free(
 /*==============*/
 	os_aio_array_t*& array)	/*!< in, own: array to free */
 {
-	ulint	i;
 #ifdef WIN_ASYNC_IO
-
+	ulint i;
 	for (i = 0; i < array->n_slots; i++) {
 		os_aio_slot_t*	slot = os_aio_array_get_nth_slot(array, i);
 		CloseHandle(slot->handle);
@@ -4207,31 +4134,6 @@ os_aio_array_free(
 	}
 #endif /* LINUX_NATIVE_AIO */
 
-	for (i = 0; i < array->n_slots; i++) {
-		os_aio_slot_t* slot = os_aio_array_get_nth_slot(array, i);
-
-		if (slot->page_compression_page) {
-			ut_free(slot->page_compression_page);
-			slot->page_compression_page = NULL;
-		}
-
-		if (slot->lzo_mem) {
-			ut_free(slot->lzo_mem);
-			slot->lzo_mem = NULL;
-		}
-
-		if (slot->page_encryption_page) {
-			ut_free(slot->page_encryption_page);
-			slot->page_encryption_page = NULL;
-		}
-
-		if (slot->tmp_encryption_buf) {
-			ut_free(slot->tmp_encryption_buf);
-			slot->tmp_encryption_buf = NULL;
-		}
-	}
-
-
 	ut_free(array->slots);
 	ut_free(array);
 
@@ -4566,22 +4468,11 @@ os_aio_array_reserve_slot(
 				to write */
 	os_offset_t	offset,	/*!< in: file offset */
 	ulint		len,	/*!< in: length of the block to read or write */
-	ulint*		write_size,/*!< in/out: Actual write size initialized
+	ulint*		write_size)/*!< in/out: Actual write size initialized
 			       after fist successfull trim
 			       operation for this page and if
 			       initialized we do not trim again if
 			       actual page size does not decrease. */
-	ibool		page_compression, /*!< in: is page compression used
-					  on this file space */
-	ulint		page_compression_level, /*!< page compression
-						level to be used */
-	ibool		page_encryption, /*!< in: is page encryption used
-					  on this file space */
-	ulint		page_encryption_key, /*!< in: page encryption key
-						 to be used */
-	lsn_t		lsn,		/*!< in: lsn of the newest modification */
-	bool		encrypt_later)  /*!< in: should we encrypt before
-					writing the page */
 {
 	os_aio_slot_t*	slot = NULL;
 #ifdef WIN_ASYNC_IO
@@ -4669,95 +4560,13 @@ found:
 	slot->len      = len;
 	slot->type     = type;
 	slot->offset   = offset;
-	slot->lsn      = lsn;
 	slot->io_already_done = FALSE;
-	slot->page_compression_success = FALSE;
-	slot->page_encryption_success = FALSE;
 	slot->write_size = write_size;
-	slot->page_compression_level = page_compression_level;
-	slot->page_compression = page_compression;
-	slot->page_encryption_key = page_encryption_key;
-	slot->page_encryption = page_encryption;
-	slot->encrypt_later = encrypt_later;
 
 	if (message1) {
 		slot->file_block_size = fil_node_get_block_size(message1);
 	}
 
-	/* If the space is page compressed and this is write operation
-	   then we compress the page */
-	if (message1 && type == OS_FILE_WRITE && page_compression ) {
-		ulint           real_len = len;
-		byte*           tmp = NULL;
-
-		/* Release the array mutex while compressing */
-		os_mutex_exit(array->mutex);
-
-		// We allocate memory for page compressed buffer if and only
-		// if it is not yet allocated.
-		os_slot_alloc_page_buf(slot);
-
-#ifdef HAVE_LZO
-		if (innodb_compression_algorithm == 3) {
-			os_slot_alloc_lzo_mem(slot);
-		}
-#endif
-
-		/* Call page compression */
-		tmp = fil_compress_page(
-                        fil_node_get_space_id(slot->message1),
-			(byte *)buf,
-			slot->page_buf,
-			len,
-			page_compression_level,
-			fil_node_get_block_size(slot->message1),
-			&real_len,
-			slot->lzo_mem
-		);
-
-		/* If compression succeeded, set up the length and buffer */
-		if (tmp != buf) {
-			len = real_len;
-			buf = slot->page_buf;
-			slot->len = real_len;
-			slot->page_compression_success = TRUE;
-		} else {
-			slot->page_compression_success = FALSE;
-		}
-
-		/* Take array mutex back, not sure if this is really needed
-		below */
-		os_mutex_enter(array->mutex);
-
-	}
-
-	/* If the space is page encryption and this is write operation
-	   then we encrypt the page */
-	if (message1 && type == OS_FILE_WRITE && (page_encryption == 1 || encrypt_later)) {
-		ut_a(page_encryption == 1 || srv_encrypt_tables == 1);
-		/* Release the array mutex while encrypting */
-		os_mutex_exit(array->mutex);
-
-		// We allocate memory for page encrypted buffer if and only
-		// if it is not yet allocated.
-		os_slot_alloc_page_buf2(slot);
-
-		fil_space_encrypt(
-			fil_node_get_space_id(slot->message1),
-			slot->offset,
-			slot->lsn,
-			(byte *)buf,
-			slot->len,
-			slot->page_buf2,
-			slot->page_encryption_key);
-
-		slot->page_encryption_success = TRUE;
-		buf = slot->page_buf2;
-
-		/* Take array mutex back */
-		os_mutex_enter(array->mutex);
-	}
-
 	slot->buf      = static_cast<byte*>(buf);
 
 #ifdef WIN_ASYNC_IO
@@ -5037,22 +4846,11 @@ os_aio_func(
 				(can be used to identify a completed
 				aio operation); ignored if mode is
 				OS_AIO_SYNC */
-	ulint*		write_size,/*!< in/out: Actual write size initialized
+	ulint*		write_size)/*!< in/out: Actual write size initialized
 			       after fist successfull trim
 			       operation for this page and if
 			       initialized we do not trim again if
 			       actual page size does not decrease. */
-	ibool		page_compression, /*!< in: is page compression used
-					  on this file space */
-	ulint		page_compression_level, /*!< page compression
-						 level to be used */
-   	ibool		page_encryption, /*!< in: is page encryption used
-					  on this file space */
-	ulint		page_encryption_key, /*!< in: page encryption key
-					     to be used */
-	lsn_t		lsn,		/*!< in: lsn of the newest modification */
-	bool		encrypt_later)  /*!< in: should we encrypt page
-					before write */
 {
 	os_aio_array_t*	array;
 	os_aio_slot_t*	slot;
@@ -5104,8 +4902,7 @@ os_aio_func(
 		and os_file_write_func() */
 
 		if (type == OS_FILE_READ) {
-			ret = os_file_read_func(file, buf, offset, n,
-					         page_compression);
+			ret = os_file_read_func(file, buf, offset, n);
 		} else {
 
 			ut_ad(!srv_read_only_mode);
@@ -5163,9 +4960,7 @@ try_again:
 	}
 
 	slot = os_aio_array_reserve_slot(type, array, message1, message2, file,
-		name, buf, offset, n, write_size,
-		page_compression, page_compression_level,
-		page_encryption, page_encryption_key, lsn, encrypt_later);
+		name, buf, offset, n, write_size);
 
 	if (type == OS_FILE_READ) {
 		if (srv_use_native_aio) {
@@ -5192,18 +4987,9 @@ try_again:
 		if (srv_use_native_aio) {
 			os_n_file_writes++;
 #ifdef WIN_ASYNC_IO
-			if (page_encryption && slot->page_encryption_success) {
-				buffer = slot->page_buf2;
-				n = slot->len;
-			} else {
-				if (page_compression && slot->page_compression_success) {
-					buffer = slot->page_buf;
-					n = slot->len;
-				} else {
-					buffer = buf;
-				}
-			}
 
+			n = slot->len;
+			buffer = buf;
 			ret = WriteFile(file, buffer, (DWORD) n, &len,
 					&(slot->control));
 
@@ -5409,27 +5195,9 @@ os_aio_windows_handle(
 
  		switch (slot->type) {
  		case OS_FILE_WRITE:
-			if (slot->message1
-			    && slot->page_encryption
-			    && slot->page_encryption_success) {
-				ret_val = os_file_write(slot->name,
-                                                        slot->file,
-                                                        slot->page_buf2,
-                                                        slot->offset,
-                                                        slot->len);
-			} else {
-				if (slot->message1
-				    && slot->page_compression
-				    && slot->page_compression_success) {
-					ret = WriteFile(slot->file, slot->page_buf,
-						(DWORD) slot->len, &len,
-						&(slot->control));
-				} else {
-					ret = WriteFile(slot->file, slot->buf,
-						(DWORD) slot->len, &len,
-						&(slot->control));
-				}
- 			}
+			ret = WriteFile(slot->file, slot->buf,
+					(DWORD) slot->len, &len,
+					&(slot->control));
 			break;
 		case OS_FILE_READ:
 			ret = ReadFile(slot->file, slot->buf,
@@ -5460,47 +5228,9 @@ os_aio_windows_handle(
 		ret_val = ret && len == slot->len;
 	}
 
-	if (slot->type == OS_FILE_READ) {
-		if (fil_page_is_compressed_encrypted(slot->buf) ||
-		    fil_page_is_encrypted(slot->buf)) {
-			ut_ad(slot->message1 != NULL);
-			os_slot_alloc_page_buf2(slot);
-			os_slot_alloc_tmp_encryption_buf(slot);
-
-			// Decrypt the data
-			fil_space_decrypt(
-				fil_node_get_space_id(slot->message1),
-				slot->buf,
-				slot->len,
-				slot->page_buf2);
-			// Copy decrypted buffer back to buf
-			memcpy(slot->buf, slot->page_buf2, slot->len);
-		}
-		if (fil_page_is_compressed(slot->buf)) {
-			/* We allocate memory for page compressed buffer if
-                           and only if it is not yet allocated. */
-			os_slot_alloc_page_buf(slot);
-#ifdef HAVE_LZO
-			if (fil_page_is_lzo_compressed(slot->buf)) {
-				os_slot_alloc_lzo_mem(slot);
-			}
-#endif
-			fil_decompress_page(
-                                            slot->page_buf,
-                                            slot->buf,
-                                            slot->len,
-                                            slot->write_size);
-		}
-	} else {
-		/* OS_FILE_WRITE */
-		if (slot->page_compression_success &&
-			(fil_page_is_compressed(slot->page_buf) ||
-			 fil_page_is_compressed_encrypted(slot->buf))) {
-			if (srv_use_trim && os_fallocate_failed == FALSE) {
-				// Deallocate unused blocks from file system
-				os_file_trim(slot);
-			}
-		}
+	if (slot->type == OS_FILE_WRITE && srv_use_trim && os_fallocate_failed == FALSE) {
+		// Deallocate unused blocks from file system
+		os_file_trim(slot);
 	}
 
 	os_aio_array_free_slot(array, slot);
@@ -5592,50 +5322,9 @@ retry:
 			/* We have not overstepped to next segment. */
 			ut_a(slot->pos < end_pos);
 
-			if (slot->type == OS_FILE_READ) {
-				/* If the page is page encrypted we encrypt */
-				if (fil_page_is_compressed_encrypted(slot->buf) ||
-					fil_page_is_encrypted(slot->buf)) {
-					os_slot_alloc_page_buf2(slot);
-					os_slot_alloc_tmp_encryption_buf(slot);
-					ut_ad(slot->message1 != NULL);
-
-					// Decrypt the data
-					fil_space_decrypt(
-						fil_node_get_space_id(slot->message1),
-						slot->buf,
-						slot->len,
-						slot->page_buf2);
-					// Copy decrypted buffer back to buf
-					memcpy(slot->buf, slot->page_buf2, slot->len);
- 				}
-
-				/* If the table is page compressed and this
-                                   is read, we decompress before we announce
-                                   the read is complete. For writes, we free
-                                   the compressed page. */
-				if (fil_page_is_compressed(slot->buf)) {
-					// We allocate memory for page compressed buffer if and only
-					// if it is not yet allocated.
-					os_slot_alloc_page_buf(slot);
-#ifdef HAVE_LZO
-					if (fil_page_is_lzo_compressed(slot->buf)) {
-						os_slot_alloc_lzo_mem(slot);
-					}
-#endif
-
-					fil_decompress_page(slot->page_buf, slot->buf, slot->len, slot->write_size);
-				}
-			} else {
-				/* OS_FILE_WRITE */
-				if (slot->page_compression_success &&
-					(fil_page_is_compressed(slot->page_buf) ||
-					 fil_page_is_compressed_encrypted(slot->buf))) {
-					if (srv_use_trim && os_fallocate_failed == FALSE) {
-						// Deallocate unused blocks from file system
-						os_file_trim(slot);
-					}
-				}
+			if (slot->type == OS_FILE_WRITE && srv_use_trim && os_fallocate_failed == FALSE) {
+				// Deallocate unused blocks from file system
+				os_file_trim(slot);
 			}
 
 			/* Mark this request as completed. The error handling
@@ -6080,8 +5769,7 @@ consecutive_loop:
 	} else {
 		ret = os_file_read(
 			aio_slot->file, combined_buf,
-			aio_slot->offset, total_len,
-			aio_slot->page_compression);
+			aio_slot->offset, total_len);
 	}
 
 	srv_set_io_thread_op_info(global_segment, "file i/o done");
@@ -6653,92 +6341,6 @@ os_file_trim(
 }
 #endif /* !UNIV_HOTBACKUP */
 
-/**********************************************************************//**
-Allocate memory for temporal buffer used for page encryption. This
-buffer is freed later. */
-UNIV_INTERN
-void
-os_slot_alloc_page_buf2(
-/*===================*/
-	os_aio_slot_t*   slot) /*!< in: slot structure     */
-{
-	ut_a(slot != NULL);
-
-	if(slot->page_buf2 == NULL) {
-		byte*           cbuf2;
-		byte*           cbuf;
-
-		cbuf2 = static_cast<byte *>(ut_malloc(UNIV_PAGE_SIZE*2));
-		cbuf = static_cast<byte *>(ut_align(cbuf2, UNIV_PAGE_SIZE));
-		slot->page_encryption_page = static_cast<byte *>(cbuf2);
-		slot->page_buf2 = static_cast<byte *>(cbuf);
-		memset(slot->page_encryption_page, 0, UNIV_PAGE_SIZE*2);
-	}
-}
-
-/**********************************************************************//**
-Allocate memory for temporal buffer used for page compression. This
-buffer is freed later. */
-UNIV_INTERN
-void
-os_slot_alloc_page_buf(
-/*===================*/
-	os_aio_slot_t*   slot) /*!< in: slot structure     */
-{
-	ut_a(slot != NULL);
-	if (slot->page_buf == NULL) {
-		byte*           cbuf2;
-		byte*           cbuf;
-		ulint           asize = UNIV_PAGE_SIZE;
-#ifdef HAVE_SNAPPY
-		asize += snappy_max_compressed_length(asize) - UNIV_PAGE_SIZE;
-#endif
-
-		/* We allocate extra to avoid memory overwrite on compression */
-		cbuf2 = static_cast<byte *>(ut_malloc(asize*2));
-		cbuf = static_cast<byte *>(ut_align(cbuf2, UNIV_PAGE_SIZE));
-		slot->page_compression_page = static_cast<byte *>(cbuf2);
-		slot->page_buf = static_cast<byte *>(cbuf);
-		ut_a(slot->page_buf != NULL);
-		memset(slot->page_compression_page, 0, asize*2);
-	}
-}
-
-#ifdef HAVE_LZO
-/**********************************************************************//**
-Allocate memory for temporal memory used for page compression when
-LZO compression method is used */
-UNIV_INTERN
-void
-os_slot_alloc_lzo_mem(
-/*===================*/
-	os_aio_slot_t*   slot) /*!< in: slot structure     */
-{
-	ut_a(slot != NULL);
-	if(slot->lzo_mem == NULL) {
-		slot->lzo_mem = static_cast<byte *>(ut_malloc(LZO1X_1_15_MEM_COMPRESS));
-		ut_a(slot->lzo_mem != NULL);
-		memset(slot->lzo_mem, 0, LZO1X_1_15_MEM_COMPRESS);
-	}
-}
-#endif
-
-/**********************************************************************//**
-Allocate memory for temporal buffer used for page encryption. */
-UNIV_INTERN
-void
-os_slot_alloc_tmp_encryption_buf(
-/*=============================*/
-	os_aio_slot_t* slot) /*!< in: slot structure */
-{
-	ut_a(slot != NULL);
-	if (slot->tmp_encryption_buf == NULL) {
-		slot->tmp_encryption_buf = static_cast<byte *>(ut_malloc(64));
-		memset(slot->tmp_encryption_buf, 0, 64);
-	}
-}
-
-
 /***********************************************************************//**
 Try to get number of bytes per sector from file system.
 @return	file block size */