Merge 10.2 into 10.3

2 files changed, 92 insertions, 88 deletions

diff --git a/extra/innochecksum.cc b/extra/innochecksum.cc
index 1af2d6e54a4..6db22081c84 100644
--- a/extra/innochecksum.cc
+++ b/extra/innochecksum.cc
@@ -85,9 +85,9 @@ typedef void fil_space_t;
 /* Global variables */
 static bool			verbose;
 static bool			just_count;
-static unsigned long long	start_page;
-static unsigned long long	end_page;
-static unsigned long long	do_page;
+static uint32_t			start_page;
+static uint32_t			end_page;
+static uint32_t			do_page;
 static bool			use_end_page;
 static bool			do_one_page;
 static my_bool do_leaf;
@@ -100,9 +100,9 @@ ulong srv_page_size;
 ulong srv_page_size_shift;
 page_size_t			univ_page_size(0, 0, false);
 /* Current page number (0 based). */
-unsigned long long		cur_page_num;
+uint32_t		cur_page_num;
 /* Current space. */
-unsigned long long		cur_space;
+uint32_t		cur_space;
 /* Skip the checksum verification. */
 static bool			no_check;
 /* Enabled for strict checksum verification. */
@@ -492,11 +492,11 @@ is_page_corrupted(
 	/* enable if page is corrupted. */
 	bool is_corrupted;
 	/* use to store LSN values. */
-	ulint logseq;
-	ulint logseqfield;
+	uint32_t logseq;
+	uint32_t logseqfield;
 	ulint page_type = mach_read_from_2(buf+FIL_PAGE_TYPE);
-	uint key_version = mach_read_from_4(buf+FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION);
-	ulint space_id = mach_read_from_4(
+	uint32_t key_version = mach_read_from_4(buf+FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION);
+	uint32_t space_id = mach_read_from_4(
 		buf + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
 
 	if (mach_read_from_4(buf + FIL_PAGE_OFFSET) != cur_page_num
@@ -509,8 +509,8 @@ is_page_corrupted(
 
 		if (is_log_enabled) {
 			fprintf(log_file,
-				"page id mismatch space::" ULINTPF
-				" page::%llu \n",
+				"page id mismatch space::" UINT32PF
+				" page::" UINT32PF " \n",
 				space_id, cur_page_num);
 		}
 
@@ -537,13 +537,14 @@ is_page_corrupted(
 
 		if (is_log_enabled) {
 			fprintf(log_file,
-				"space::" ULINTPF " page::%llu"
-				"; log sequence number:first = " ULINTPF
-				"; second = " ULINTPF "\n",
+				"space::" UINT32PF " page::" UINT32PF
+				"; log sequence number:first = " UINT32PF
+				"; second = " UINT32PF "\n",
 				space_id, cur_page_num, logseq, logseqfield);
 			if (logseq != logseqfield) {
 				fprintf(log_file,
-					"Fail; space::" ULINTPF " page::%llu"
+					"Fail; space::" UINT32PF
+					" page::" UINT32PF
 					" invalid (fails log "
 					"sequence number check)\n",
 					space_id, cur_page_num);
@@ -565,9 +566,9 @@ is_page_corrupted(
 								page_size);
 		if (is_corrupted && log_file) {
 			fprintf(log_file,
-				"[page id: space=" ULINTPF
-				", page_number=%llu] may be corrupted;"
-				" key_version=%u\n",
+				"[page id: space=" UINT32PF
+				", page_number=" UINT32PF "] may be corrupted;"
+				" key_version=" UINT32PF "\n",
 				space_id, cur_page_num,
 				mach_read_from_4(
 					FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION
@@ -678,8 +679,8 @@ update_checksum(
 
 		mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM, checksum);
 		if (is_log_enabled) {
-			fprintf(log_file, "page::%llu; Updated checksum ="
-				" %u\n", cur_page_num, checksum);
+			fprintf(log_file, "page::" UINT32PF "; Updated checksum ="
+				" " UINT32PF "\n", cur_page_num, checksum);
 		}
 
 	} else {
@@ -709,8 +710,8 @@ update_checksum(
 
 		mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM, checksum);
 		if (is_log_enabled) {
-			fprintf(log_file, "page::%llu; Updated checksum field1"
-				" = %u\n", cur_page_num, checksum);
+			fprintf(log_file, "page::" UINT32PF "; Updated checksum field1"
+				" = " UINT32PF "\n", cur_page_num, checksum);
 		}
 
 		if (write_check == SRV_CHECKSUM_ALGORITHM_STRICT_INNODB
@@ -723,8 +724,8 @@ update_checksum(
 				FIL_PAGE_END_LSN_OLD_CHKSUM,checksum);
 
 		if (is_log_enabled) {
-			fprintf(log_file, "page::%llu; Updated checksum "
-				"field2 = %u\n", cur_page_num, checksum);
+			fprintf(log_file, "page::" UINT32PF "; Updated checksum "
+				"field2 = " UINT32PF "\n", cur_page_num, checksum);
 		}
 
 	}
@@ -798,7 +799,7 @@ write_file(
 
 	if (page_size
 		!= fwrite(buf, 1, page_size, file == stdin ? stdout : file)) {
-		fprintf(stderr, "Failed to write page::%llu to %s: %s\n",
+		fprintf(stderr, "Failed to write page::" UINT32PF " to %s: %s\n",
 			cur_page_num, filename, strerror(errno));
 
 		return(false);
@@ -816,8 +817,8 @@ write_file(
 }
 
 // checks using current xdes page whether the page is free
-static bool page_is_free(const byte *xdes, page_size_t page_size,
-                         ulonglong page_no)
+static inline bool is_page_free(const byte *xdes, page_size_t page_size,
+                                uint32_t page_no)
 {
   const byte *des=
       xdes + XDES_ARR_OFFSET +
@@ -842,12 +843,10 @@ parse_page(
 	bool is_encrypted)
 {
 	unsigned long long id;
-	ulint undo_page_type;
+	uint16_t undo_page_type;
 	char str[20]={'\0'};
 	ulint n_recs;
-	ulint page_no;
-	ulint left_page_no;
-	ulint right_page_no;
+	uint32_t page_no, left_page_no, right_page_no;
 	ulint data_bytes;
 	bool is_leaf;
 	ulint size_range_id;
@@ -862,7 +861,7 @@ parse_page(
 	switch (mach_read_from_2(page + FIL_PAGE_TYPE)) {
 
 	case FIL_PAGE_INDEX: {
-		uint key_version = mach_read_from_4(page + FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION);
+		uint32_t key_version = mach_read_from_4(page + FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION);
 		page_type.n_fil_page_index++;
 
 		/* If page is encrypted we can't read index header */
@@ -886,7 +885,7 @@ parse_page(
 			is_leaf = (!*(const uint16*) (page + (PAGE_HEADER + PAGE_LEVEL)));
 
 			if (page_type_dump) {
-				fprintf(file, "#::%llu\t\t|\t\tIndex page\t\t\t|"
+				fprintf(file, "#::" UINT32PF "\t\t|\t\tIndex page\t\t\t|"
 					"\tindex id=%llu,", cur_page_num, id);
 
 				fprintf(file,
@@ -905,13 +904,13 @@ parse_page(
 				size_range_id = SIZE_RANGES_FOR_PAGE + 1;
 			}
 			if (per_page_details) {
-				printf("index id=%llu page " ULINTPF " leaf %d n_recs " ULINTPF " data_bytes " ULINTPF
+				printf("index id=%llu page " UINT32PF " leaf %d n_recs " ULINTPF " data_bytes " ULINTPF
 					"\n", id, page_no, is_leaf, n_recs, data_bytes);
 			}
 			/* update per-index statistics */
 			{
 				per_index_stats &index = index_ids[id];
-				if (page_is_free(xdes, page_size, page_no)) {
+				if (is_page_free(xdes, page_size, page_no)) {
 					index.free_pages++;
 					return;
 				}
@@ -939,8 +938,8 @@ parse_page(
 				index.pages_in_size_range[size_range_id] ++;
 			}
 		} else {
-			fprintf(file, "#::%llu\t\t|\t\tEncrypted Index page\t\t\t|"
-				"\tkey_version %u,%s\n", cur_page_num, key_version, str);
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tEncrypted Index page\t\t\t|"
+				"\tkey_version " UINT32PF ",%s\n", cur_page_num, key_version, str);
 		}
 
 		break;
@@ -950,7 +949,7 @@ parse_page(
 		undo_page_type = mach_read_from_2(page +
 				     TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_TYPE);
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tUndo log page\t\t\t|",
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tUndo log page\t\t\t|",
 				cur_page_num);
 		}
 		page_type.n_undo++;
@@ -1002,7 +1001,7 @@ parse_page(
 	case FIL_PAGE_INODE:
 		page_type.n_fil_page_inode++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tInode page\t\t\t|"
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tInode page\t\t\t|"
 				"\t%s\n",cur_page_num, str);
 		}
 		break;
@@ -1010,7 +1009,7 @@ parse_page(
 	case FIL_PAGE_IBUF_FREE_LIST:
 		page_type.n_fil_page_ibuf_free_list++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tInsert buffer free list"
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tInsert buffer free list"
 				" page\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1018,7 +1017,7 @@ parse_page(
 	case FIL_PAGE_TYPE_ALLOCATED:
 		page_type.n_fil_page_type_allocated++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tFreshly allocated "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tFreshly allocated "
 				"page\t\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1026,7 +1025,7 @@ parse_page(
 	case FIL_PAGE_IBUF_BITMAP:
 		page_type.n_fil_page_ibuf_bitmap++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tInsert Buffer "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tInsert Buffer "
 				"Bitmap\t\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1034,15 +1033,15 @@ parse_page(
 	case FIL_PAGE_TYPE_SYS:
 		page_type.n_fil_page_type_sys++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tSystem page\t\t\t|"
-				"\t%s\n",cur_page_num, str);
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tSystem page\t\t\t|"
+				"\t%s\n", cur_page_num, str);
 		}
 		break;
 
 	case FIL_PAGE_TYPE_TRX_SYS:
 		page_type.n_fil_page_type_trx_sys++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tTransaction system "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tTransaction system "
 				"page\t\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1050,7 +1049,7 @@ parse_page(
 	case FIL_PAGE_TYPE_FSP_HDR:
 		page_type.n_fil_page_type_fsp_hdr++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tFile Space "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tFile Space "
 				"Header\t\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1058,7 +1057,7 @@ parse_page(
 	case FIL_PAGE_TYPE_XDES:
 		page_type.n_fil_page_type_xdes++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tExtent descriptor "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tExtent descriptor "
 				"page\t\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1066,7 +1065,7 @@ parse_page(
 	case FIL_PAGE_TYPE_BLOB:
 		page_type.n_fil_page_type_blob++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tBLOB page\t\t\t|\t%s\n",
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tBLOB page\t\t\t|\t%s\n",
 				cur_page_num, str);
 		}
 		break;
@@ -1074,7 +1073,7 @@ parse_page(
 	case FIL_PAGE_TYPE_ZBLOB:
 		page_type.n_fil_page_type_zblob++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tCompressed BLOB "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tCompressed BLOB "
 				"page\t\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1082,7 +1081,7 @@ parse_page(
 	case FIL_PAGE_TYPE_ZBLOB2:
 		page_type.n_fil_page_type_zblob2++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tSubsequent Compressed "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tSubsequent Compressed "
 				"BLOB page\t|\t%s\n", cur_page_num, str);
 		}
 			break;
@@ -1090,7 +1089,7 @@ parse_page(
 	case FIL_PAGE_PAGE_COMPRESSED:
 		page_type.n_fil_page_type_page_compressed++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tPage compressed "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tPage compressed "
 				"page\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1098,7 +1097,7 @@ parse_page(
 	case FIL_PAGE_PAGE_COMPRESSED_ENCRYPTED:
 		page_type.n_fil_page_type_page_compressed_encrypted++;
 		if (page_type_dump) {
-			fprintf(file, "#::%llu\t\t|\t\tPage compressed encrypted "
+			fprintf(file, "#::" UINT32PF "\t\t|\t\tPage compressed encrypted "
 				"page\t|\t%s\n", cur_page_num, str);
 		}
 		break;
@@ -1250,14 +1249,14 @@ static struct my_option innochecksum_options[] = {
   {"count", 'c', "Print the count of pages in the file and exits.",
     &just_count, &just_count, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"start_page", 's', "Start on this page number (0 based).",
-    &start_page, &start_page, 0, GET_ULL, REQUIRED_ARG,
-    0, 0, ULLONG_MAX, 0, 1, 0},
+    &start_page, &start_page, 0, GET_UINT, REQUIRED_ARG,
+    0, 0, FIL_NULL, 0, 1, 0},
   {"end_page", 'e', "End at this page number (0 based).",
-    &end_page, &end_page, 0, GET_ULL, REQUIRED_ARG,
-    0, 0, ULLONG_MAX, 0, 1, 0},
+    &end_page, &end_page, 0, GET_UINT, REQUIRED_ARG,
+    0, 0, FIL_NULL, 0, 1, 0},
   {"page", 'p', "Check only this page (0 based).",
-    &do_page, &do_page, 0, GET_ULL, REQUIRED_ARG,
-    0, 0, ULLONG_MAX, 0, 1, 0},
+    &do_page, &do_page, 0, GET_UINT, REQUIRED_ARG,
+    0, 0, FIL_NULL, 0, 1, 0},
   {"strict-check", 'C', "Specify the strict checksum algorithm by the user.",
     &strict_check, &strict_check, &innochecksum_algorithms_typelib,
     GET_ENUM, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
@@ -1451,14 +1450,14 @@ bool check_encryption(
 		return false;
 	}
 
-	uint min_key_version = mach_read_from_4
+	uint32_t min_key_version = mach_read_from_4
 		(page + offset + MAGIC_SZ + 2 + iv_length);
 
-	uint key_id = mach_read_from_4
+	uint32_t key_id = mach_read_from_4
 		(page + offset + MAGIC_SZ + 2 + iv_length + 4);
 
 	if (type == CRYPT_SCHEME_1 && is_log_enabled) {
-		fprintf(log_file,"Tablespace %s encrypted key_version %u key_id %u\n",
+		fprintf(log_file,"Tablespace %s encrypted key_version " UINT32PF " key_id " UINT32PF "\n",
 			filename, min_key_version, key_id);
 	}
 
@@ -1489,7 +1488,7 @@ int verify_checksum(
 		buf, page_size, is_encrypted, is_compressed);
 
 	if (is_corrupted) {
-		fprintf(stderr, "Fail: page::%llu invalid\n",
+		fprintf(stderr, "Fail: page::" UINT32PF " invalid\n",
 			cur_page_num);
 
 		(*mismatch_count)++;
@@ -1575,7 +1574,7 @@ int main(
 	/* size of file (has to be 64 bits) */
 	unsigned long long int	size		= 0;
 	/* number of pages in file */
-	ulint		pages;
+	uint32_t	pages;
 
 	off_t		offset			= 0;
 	/* count the no. of page corrupted. */
@@ -1780,7 +1779,7 @@ int main(
 		}
 
 		if (per_page_details) {
-			printf("page %llu ", cur_page_num);
+			printf("page " UINT32PF " ", cur_page_num);
 		}
 
 		memcpy(xdes, buf, physical_page_size);
@@ -1789,29 +1788,29 @@ int main(
 			parse_page(buf, xdes, fil_page_type, page_size, is_encrypted);
 		}
 
-		pages = (ulint) (size / page_size.physical());
+		pages = uint32_t(size / page_size.physical());
 
 		if (just_count) {
-			if (read_from_stdin) {
-				fprintf(stderr, "Number of pages:" ULINTPF "\n", pages);
-			} else {
-				printf("Number of pages:" ULINTPF "\n", pages);
-			}
+			fprintf(read_from_stdin ? stderr : stdout,
+				"Number of pages:" UINT32PF "\n", pages);
 			continue;
 		} else if (verbose && !read_from_stdin) {
 			if (is_log_enabled) {
 				fprintf(log_file, "file %s = %llu bytes "
-					"(" ULINTPF " pages)\n", filename, size, pages);
+					"(" UINT32PF " pages)\n",
+					filename, size, pages);
 				if (do_one_page) {
 					fprintf(log_file, "Innochecksum: "
-						"checking page::%llu;\n",
+						"checking page::"
+						UINT32PF ";\n",
 						do_page);
 				}
 			}
 		} else {
 			if (is_log_enabled) {
 				fprintf(log_file, "Innochecksum: checking "
-					"pages in range::%llu to %llu\n",
+					"pages in range::" UINT32PF
+					" to " UINT32PF "\n",
 					start_page, use_end_page ?
 					end_page : (pages - 1));
 			}
@@ -1855,8 +1854,8 @@ int main(
 				the desired page. */
 				partial_page_read = false;
 
-				offset = (off_t) start_page
-					* (off_t) page_size.physical();
+				offset = off_t(ulonglong(start_page)
+					       * page_size.physical());
 #ifdef _WIN32
 				if (_fseeki64(fil_in, offset, SEEK_SET)) {
 #else
@@ -1901,12 +1900,7 @@ int main(
 					count++;
 
 					if (!bytes || feof(fil_in)) {
-						fprintf(stderr, "Error: Unable "
-							"to seek to necessary "
-							"offset");
-
-						exit_status = 1;
-						goto my_exit;
+						goto unexpected_eof;
 					}
 				}
 			}
@@ -1923,6 +1917,15 @@ int main(
 			partial_page_read = false;
 
 			if (!bytes && feof(fil_in)) {
+				if (cur_page_num == start_page) {
+unexpected_eof:
+					fputs("Error: Unable "
+					      "to seek to necessary offset\n",
+					      stderr);
+
+					exit_status = 1;
+					goto my_exit;
+				}
 				break;
 			}
 
@@ -1962,10 +1965,10 @@ first_non_zero:
 
 			/* If no-check is enabled, skip the
 			checksum verification.*/
-			if (!no_check
-			    && !page_is_free(xdes, page_size, cur_page_num)
-			    && !skip_page
-			    && (exit_status = verify_checksum(
+			if (!no_check &&
+			    !is_page_free(xdes, page_size, cur_page_num) &&
+			    !skip_page &&
+			    (exit_status = verify_checksum(
 						buf, page_size,
 						is_encrypted, is_compressed,
 						&mismatch_count))) {
@@ -1983,7 +1986,7 @@ first_non_zero:
 			}
 
 			if (per_page_details) {
-				printf("page %llu ", cur_page_num);
+				printf("page " UINT32PF " ", cur_page_num);
 			}
 
 			if (page_get_page_no(buf) % physical_page_size == 0) {
@@ -2003,10 +2006,10 @@ first_non_zero:
 					if (!lastt) {
 						lastt= now;
 					} else if (now - lastt >= 1 && is_log_enabled) {
-						fprintf(log_file, "page::%llu "
+						fprintf(log_file, "page::" UINT32PF " "
 							"okay: %.3f%% done\n",
 							(cur_page_num - 1),
-							(float) cur_page_num / pages * 100);
+							(double) cur_page_num / pages * 100);
 						lastt = now;
 					}
 				}
diff --git a/extra/mariabackup/CMakeLists.txt b/extra/mariabackup/CMakeLists.txt
index adaf82b325e..f84bb1aabd2 100644
--- a/extra/mariabackup/CMakeLists.txt
+++ b/extra/mariabackup/CMakeLists.txt
@@ -15,6 +15,7 @@
 
 
 OPTION(WITH_MARIABACKUP "Include mariabackup" ON)
+ADD_FEATURE_INFO(MARIABACKUP WITH_MARIABACKUP "MariaDB Backup Utility")
 IF(NOT WITH_MARIABACKUP)
   RETURN()
 ENDIF()