Many files:

  Multiple tablespaces for InnoDB
sql_table.cc:
  Tell explicitly that InnoDB should retrieve all columns in CHECKSUM TABLE
sql_update.cc, sql_select.cc, my_base.h:
  More descriptive flag name HA_EXTRA_RETRIEVE_ALL_COLS

2 files changed, 239 insertions, 128 deletions

diff --git a/innobase/srv/srv0srv.c b/innobase/srv/srv0srv.c
index a886cbee22a..e16073c171c 100644
--- a/innobase/srv/srv0srv.c
+++ b/innobase/srv/srv0srv.c
@@ -75,6 +75,10 @@ names, where the file name itself may also contain a path */
 char*	srv_data_home 	= NULL;
 char*	srv_arch_dir 	= NULL;
 
+ibool	srv_file_per_table = FALSE;	/* store to its own file each table
+					created by an user; data dictionary
+					tables are in the system tablespace
+					0 */
 ulint	srv_n_data_files = 0;
 char**	srv_data_file_names = NULL;
 ulint*	srv_data_file_sizes = NULL;	/* size in database pages */ 
@@ -162,6 +166,8 @@ char*   srv_file_flush_method_str = NULL;
 ulint   srv_unix_file_flush_method = SRV_UNIX_FDATASYNC;
 ulint   srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
 
+ulint	srv_max_n_open_files	  = 300;
+
 /* The InnoDB main thread tries to keep the ratio of modified pages
 in the buffer pool to all database pages in the buffer pool smaller than
 the following number. But it is not guaranteed that the value stays below
@@ -1444,7 +1450,7 @@ srv_read_initfile(
 
 		srv_log_group_home_dirs[i] = ut_malloc(ut_strlen(str_buf) + 1);
 		ut_memcpy(srv_log_group_home_dirs[i], str_buf,
-							ut_strlen(str_buf) + 1);
+						ut_strlen(str_buf) + 1);
 	}
 
 	err = srv_read_init_val(initfile, "INNOBASE_LOG_ARCH_DIR",
@@ -2325,7 +2331,7 @@ srv_sprintf_innodb_monitor(
 	char*	buf_end	= buf + len - 2000;
 	double	time_elapsed;
 	time_t	current_time;
-	ulint	n_reserved;
+	ulint   n_reserved;
 
 	mutex_enter(&srv_innodb_monitor_mutex);
 
@@ -2436,7 +2442,8 @@ srv_sprintf_innodb_monitor(
 
 	if (mem_out_of_mem_err_msg_count > 0) {
 	        buf += sprintf(buf,
-	"Mem allocation has spilled out of additional mem pool %lu times\n");
+	"Mem allocation has spilled out of additional mem pool %lu times\n",
+					mem_out_of_mem_err_msg_count);
 	}
 
 	if (srv_use_awe) {
@@ -2453,15 +2460,15 @@ srv_sprintf_innodb_monitor(
 		       "ROW OPERATIONS\n"
 		       "--------------\n");
 	buf += sprintf(buf,
-	"%ld queries inside InnoDB, %lu queries in queue\n",
-			srv_conc_n_threads, srv_conc_n_waiting_threads);
+        "%ld queries inside InnoDB, %lu queries in queue\n",
+                        srv_conc_n_threads, srv_conc_n_waiting_threads);
 
-	n_reserved = fil_space_get_n_reserved_extents(0);
-	if (n_reserved > 0) {
-	        buf += sprintf(buf,
-	"%lu tablespace extents now reserved for B-tree split operations\n",
-						    n_reserved);
-	}
+        n_reserved = fil_space_get_n_reserved_extents(0);
+        if (n_reserved > 0) {
+                buf += sprintf(buf,
+        "%lu tablespace extents now reserved for B-tree split operations\n",
+                                                    n_reserved);
+        }
 
 #ifdef UNIV_LINUX
 	buf += sprintf(buf,
@@ -2701,8 +2708,13 @@ srv_error_monitor_thread(
 			os_thread_create */
 {
 	ulint	cnt	= 0;
+	dulint	old_lsn;
+	dulint	new_lsn;
 
 	UT_NOT_USED(arg);
+
+	old_lsn = srv_start_lsn;
+
 #ifdef UNIV_DEBUG_THREAD_CREATION
 	printf("Error monitor thread starts, id %lu\n",
 			      os_thread_pf(os_thread_get_curr_id()));
@@ -2714,6 +2726,25 @@ loop:
 
 	os_thread_sleep(2000000);
 
+	/* Try to track a strange bug reported by Harald Fuchs and others,
+	where the lsn seems to decrease at times */
+
+	new_lsn = log_get_lsn();
+
+	if (ut_dulint_cmp(new_lsn, old_lsn) < 0) {
+		ut_print_timestamp(stderr);
+		fprintf(stderr,
+"  InnoDB: Error: old log sequence number %lu %lu was greater\n"
+"InnoDB: than the new log sequence number %lu %lu!\n"
+"InnoDB: Please send a bug report to mysql@lists.mysql.com\n",
+		ut_dulint_get_high(old_lsn),
+		ut_dulint_get_low(old_lsn),
+		ut_dulint_get_high(new_lsn),
+		ut_dulint_get_low(new_lsn));
+	}
+
+	old_lsn = new_lsn;
+
 	if (difftime(time(NULL), srv_last_monitor_time) > 60) {
 		/* We referesh InnoDB Monitor values so that averages are
 		printed from at most 60 last seconds */
@@ -2903,6 +2934,9 @@ loop:
 		srv_main_thread_op_info = (char*)"flushing log";
 		log_buffer_flush_to_disk();
 
+		srv_main_thread_op_info = (char*)"making checkpoint";
+		log_free_check();
+
 		/* If there were less than 5 i/os during the
 		one second sleep, we assume that there is free
 		disk i/o capacity available, and it makes sense to
diff --git a/innobase/srv/srv0start.c b/innobase/srv/srv0start.c
index f0ff1167f4d..5de87038bde 100644
--- a/innobase/srv/srv0start.c
+++ b/innobase/srv/srv0start.c
@@ -30,6 +30,7 @@ Created 2/16/1996 Heikki Tuuri
 #include "page0cur.h"
 #include "trx0trx.h"
 #include "dict0boot.h"
+#include "dict0load.h"
 #include "trx0sys.h"
 #include "dict0crea.h"
 #include "btr0btr.h"
@@ -56,6 +57,14 @@ Created 2/16/1996 Heikki Tuuri
 #include "srv0start.h"
 #include "que0que.h"
 
+
+/* Log sequence number immediately after startup */
+dulint		srv_start_lsn;
+/* Log sequence number at shutdown */
+dulint		srv_shutdown_lsn;
+
+ibool		srv_start_raw_disk_in_use  = FALSE;
+
 ibool           srv_start_has_been_called  = FALSE;
 
 ulint           srv_sizeof_trx_t_in_ha_innodb_cc;
@@ -87,13 +96,6 @@ ibool srv_os_test_mutex_is_locked = FALSE;
 #define SRV_N_PENDING_IOS_PER_THREAD 	OS_AIO_N_PENDING_IOS_PER_THREAD
 #define SRV_MAX_N_PENDING_SYNC_IOS	100
 
-/* The following limit may be too big in some old operating systems:
-we may get an assertion failure in os0file.c */
-
-#define SRV_MAX_N_OPEN_FILES		500
-
-#define SRV_LOG_SPACE_FIRST_ID		1000000000
-
 /*************************************************************************
 Reads the data files and their sizes from a character string given in
 the .cnf file. */
@@ -137,7 +139,8 @@ srv_parse_data_file_paths_and_sizes(
 
 		while ((*str != ':' && *str != '\0')
 		       || (*str == ':'
-			   && (*(str + 1) == '\\' || *(str + 1) == '/'))) {
+			   && (*(str + 1) == '\\' || *(str + 1) == '/'
+					     || *(str + 1) == ':'))) {
 			str++;
 		}
 
@@ -234,11 +237,15 @@ srv_parse_data_file_paths_and_sizes(
 	while (*str != '\0') {
 		path = str;
 
-		/* Note that we must ignore the ':' in a Windows path */
+		/* Note that we must step over the ':' in a Windows path;
+		a Windows path normally looks like C:\ibdata\ibdata1:1G, but
+		a Windows raw partition may have a specification like
+		\\.\C::1Gnewraw or \\.\PHYSICALDRIVE2:1Gnewraw */
 
 		while ((*str != ':' && *str != '\0')
 		       || (*str == ':'
-			   && (*(str + 1) == '\\' || *(str + 1) == '/'))) {
+			   && (*(str + 1) == '\\' || *(str + 1) == '/'
+			        || *(str + 1) == ':'))) {
 			str++;
 		}
 
@@ -452,7 +459,8 @@ Normalizes a directory path for Windows: converts slashes to backslashes. */
 void
 srv_normalize_path_for_win(
 /*=======================*/
-	char*	str __attribute__((unused)))	/* in/out: null-terminated character string */
+	char*	str __attribute__((unused)))	/* in/out: null-terminated
+							   character string */
 {
 #ifdef __WIN__
 	ulint	i;
@@ -510,7 +518,7 @@ srv_calc_low32(
 				expressed in bytes */
 	ulint	file_size)	/* in: file size in database pages */
 {
-	return(0xFFFFFFFF & (file_size << UNIV_PAGE_SIZE_SHIFT));
+	return(0xFFFFFFFFUL & (file_size << UNIV_PAGE_SIZE_SHIFT));
 }
 
 /*************************************************************************
@@ -563,7 +571,7 @@ open_or_create_log_file(
 	files[i] = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL,
 						OS_LOG_FILE, &ret);
 	if (ret == FALSE) {
-		if (os_file_get_last_error() != OS_FILE_ALREADY_EXISTS) {
+		if (os_file_get_last_error(FALSE) != OS_FILE_ALREADY_EXISTS) {
 			fprintf(stderr,
 			"InnoDB: Error in creating or opening %s\n", name);
 				
@@ -640,7 +648,7 @@ open_or_create_log_file(
 	ut_a(fil_validate());
 
 	fil_node_create(name, srv_log_file_size,
-					2 * k + SRV_LOG_SPACE_FIRST_ID);
+				2 * k + SRV_LOG_SPACE_FIRST_ID, FALSE);
 
 	/* If this is the first log group, create the file space object
 	for archived logs */
@@ -648,7 +656,8 @@ open_or_create_log_file(
 	if (k == 0 && i == 0) {
 		arch_space_id = 2 * k + 1 + SRV_LOG_SPACE_FIRST_ID;
 
-	    	fil_space_create((char*) "arch_log_space", arch_space_id, FIL_LOG);
+	    	fil_space_create((char*) "arch_log_space", arch_space_id,
+								FIL_LOG);
 	} else {
 		arch_space_id = ULINT_UNDEFINED;
 	}
@@ -708,18 +717,32 @@ open_or_create_data_files(
 
 		sprintf(name, "%s%s", srv_data_home, srv_data_file_names[i]);
 	
-		files[i] = os_file_create(name, OS_FILE_CREATE,
+		if (srv_data_file_is_raw_partition[i] == 0) {
+
+			/* First we try to create the file: if it already
+			exists, ret will get value FALSE */
+
+			files[i] = os_file_create(name, OS_FILE_CREATE,
 					OS_FILE_NORMAL, OS_DATA_FILE, &ret);
 
-		if (srv_data_file_is_raw_partition[i] == SRV_NEW_RAW) {
+			if (ret == FALSE && os_file_get_last_error(FALSE) !=
+						OS_FILE_ALREADY_EXISTS) {
+				fprintf(stderr,
+				"InnoDB: Error in creating or opening %s\n",
+				name);
+
+				return(DB_ERROR);
+			}
+		} else if (srv_data_file_is_raw_partition[i] == SRV_NEW_RAW) {
 			/* The partition is opened, not created; then it is
 			written over */
 
+			srv_start_raw_disk_in_use = TRUE;
 			srv_created_new_raw = TRUE;
 
 			files[i] = os_file_create(
-				name, OS_FILE_OPEN, OS_FILE_NORMAL,
-						OS_DATA_FILE, &ret);
+				name, OS_FILE_OPEN_RAW, OS_FILE_NORMAL,
+							OS_DATA_FILE, &ret);
 			if (!ret) {
 				fprintf(stderr,
 				"InnoDB: Error in opening %s\n", name);
@@ -727,19 +750,15 @@ open_or_create_data_files(
 				return(DB_ERROR);
 			}
 		} else if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
+			srv_start_raw_disk_in_use = TRUE;
+
 			ret = FALSE;
+		} else {
+			ut_a(0);
 		}
 
 		if (ret == FALSE) {
-			if (srv_data_file_is_raw_partition[i] != SRV_OLD_RAW
-			    && os_file_get_last_error() !=
-						OS_FILE_ALREADY_EXISTS) {
-				fprintf(stderr,
-				"InnoDB: Error in creating or opening %s\n",
-				name);
-
-				return(DB_ERROR);
-			}
+			/* We open the data file */
 
 			if (one_created) {
 				fprintf(stderr,
@@ -750,71 +769,80 @@ open_or_create_data_files(
 				return(DB_ERROR);
 			}
 				
-			files[i] = os_file_create(
-				name, OS_FILE_OPEN, OS_FILE_NORMAL,
-						OS_DATA_FILE, &ret);
+			if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
+				files[i] = os_file_create(
+					name, OS_FILE_OPEN_RAW, OS_FILE_NORMAL,
+							 OS_DATA_FILE, &ret);
+			} else {
+				files[i] = os_file_create(
+					name, OS_FILE_OPEN, OS_FILE_NORMAL,
+							 OS_DATA_FILE, &ret);
+			}
+
 			if (!ret) {
 				fprintf(stderr,
 				"InnoDB: Error in opening %s\n", name);
-				os_file_get_last_error();
+				os_file_get_last_error(TRUE);
 
 				return(DB_ERROR);
 			}
 
-			if (srv_data_file_is_raw_partition[i] != SRV_OLD_RAW) {
-			
-				ret = os_file_get_size(files[i], &size,
-								&size_high);
-				ut_a(ret);
-				/* Round size downward to megabytes */
+			if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
+
+				goto skip_size_check;
+			}
+
+			ret = os_file_get_size(files[i], &size, &size_high);
+			ut_a(ret);
+			/* Round size downward to megabytes */
 		
-				rounded_size_pages = (size / (1024 * 1024)
+			rounded_size_pages = (size / (1024 * 1024)
 							+ 4096 * size_high)
 					     << (20 - UNIV_PAGE_SIZE_SHIFT);
 
-				if (i == srv_n_data_files - 1
+			if (i == srv_n_data_files - 1
 				    && srv_auto_extend_last_data_file) {
 
-				    	if (srv_data_file_sizes[i] >
+				if (srv_data_file_sizes[i] >
 				    		rounded_size_pages
 				    	   || (srv_last_file_size_max > 0
 				    	      && srv_last_file_size_max <
 				    	       rounded_size_pages)) {
 				    	       	
-						fprintf(stderr,
+					fprintf(stderr,
 "InnoDB: Error: auto-extending data file %s is of a different size\n"
 "InnoDB: %lu pages (rounded down to MB) than specified in the .cnf file:\n"
 "InnoDB: initial %lu pages, max %lu (relevant if non-zero) pages!\n",
 		  name, rounded_size_pages,
 		  srv_data_file_sizes[i], srv_last_file_size_max);
 
-						return(DB_ERROR);
-					}
-				    	     
-				    	srv_data_file_sizes[i] =
-				    			rounded_size_pages;
+					return(DB_ERROR);
 				}
+				    	     
+				srv_data_file_sizes[i] = rounded_size_pages;
+			}
 				
-				if (rounded_size_pages
-						!= srv_data_file_sizes[i]) {
+			if (rounded_size_pages != srv_data_file_sizes[i]) {
 
-					fprintf(stderr,
+				fprintf(stderr,
 "InnoDB: Error: data file %s is of a different size\n"
 "InnoDB: %lu pages (rounded down to MB)\n"
 "InnoDB: than specified in the .cnf file %lu pages!\n", name,
 						rounded_size_pages,
 						srv_data_file_sizes[i]);
 				
-					return(DB_ERROR);
-				}
+				return(DB_ERROR);
 			}
-
+skip_size_check:
 			fil_read_flushed_lsn_and_arch_log_no(files[i],
 					one_opened,
 					min_flushed_lsn, min_arch_log_no,
 					max_flushed_lsn, max_arch_log_no);
 			one_opened = TRUE;
 		} else {
+		        /* We created the data file and now write it full of
+			zeros */
+
 			one_created = TRUE;
 
 			if (i > 0) {
@@ -862,7 +890,13 @@ open_or_create_data_files(
 
 		ut_a(fil_validate());
 
-		fil_node_create(name, srv_data_file_sizes[i], 0);
+		if (srv_data_file_is_raw_partition[i]) {
+
+		        fil_node_create(name, srv_data_file_sizes[i], 0, TRUE);
+		} else {
+		        fil_node_create(name, srv_data_file_sizes[i], 0,
+									FALSE);
+		}
 	}
 
 	ios = 0;
@@ -972,9 +1006,11 @@ innobase_start_or_create_for_mysql(void)
 	ulint	tablespace_size_in_header;
 	ulint	err;
 	ulint	i;
-	ulint	k;
+	ibool	srv_file_per_table_original_value  = srv_file_per_table;
 	mtr_t   mtr;
 
+	srv_file_per_table = FALSE; /* system tables are created in tablespace
+									0 */
 #ifdef UNIV_DEBUG
 	fprintf(stderr,
 "InnoDB: !!!!!!!!!!!!!! UNIV_DEBUG switched on !!!!!!!!!!!!!!!\n"); 
@@ -999,7 +1035,6 @@ innobase_start_or_create_for_mysql(void)
 	fprintf(stderr,
 "InnoDB: !!!!!!!!!!!!!! UNIV_SIMULATE_AWE switched on !!!!!!!!!!!!!!!!!\n");
 #endif
-
         if (srv_sizeof_trx_t_in_ha_innodb_cc != (ulint)sizeof(trx_t)) {
 	        fprintf(stderr,
   "InnoDB: Error: trx_t size is %lu in ha_innodb.cc but %lu in srv0start.c\n"
@@ -1122,7 +1157,6 @@ innobase_start_or_create_for_mysql(void)
 
 	if (!os_aio_use_native_aio) {
  		/* In simulated aio we currently have use only for 4 threads */
-
 		srv_n_file_io_threads = 4;
 
 		os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD
@@ -1136,7 +1170,7 @@ innobase_start_or_create_for_mysql(void)
 					SRV_MAX_N_PENDING_SYNC_IOS);
 	}
 	
-	fil_init(SRV_MAX_N_OPEN_FILES);
+	fil_init(srv_max_n_open_files);
 
 	if (srv_use_awe) {
 		fprintf(stderr,
@@ -1168,7 +1202,6 @@ innobase_start_or_create_for_mysql(void)
 
 	for (i = 0; i < srv_n_file_io_threads; i++) {
 		n[i] = i;
-
 		os_thread_create(io_handler_thread, n + i, thread_ids + i);
     	}
 
@@ -1181,7 +1214,6 @@ innobase_start_or_create_for_mysql(void)
 	}
 
 	if (srv_n_log_files * srv_log_file_size >= 262144) {
-
 		fprintf(stderr,
 		"InnoDB: Error: combined size of log files must be < 4 GB\n");
 
@@ -1227,42 +1259,25 @@ innobase_start_or_create_for_mysql(void)
 		return((int) err);
 	}
 
-	if (!create_new_db) {
-		/* If we are using the doublewrite method, we will
-		check if there are half-written pages in data files,
-		and restore them from the doublewrite buffer if
-		possible */
-		
-		if (srv_force_recovery < SRV_FORCE_NO_LOG_REDO) {
-		
-			trx_sys_doublewrite_restore_corrupt_pages();
-		}
-	}
-
 	srv_normalize_path_for_win(srv_arch_dir);
 	srv_arch_dir = srv_add_path_separator_if_needed(srv_arch_dir);
+		
+	for (i = 0; i < srv_n_log_files; i++) {
+		err = open_or_create_log_file(create_new_db, &log_file_created,
+							     log_opened, 0, i);
+		if (err != DB_SUCCESS) {
 
-	for (k = 0; k < srv_n_log_groups; k++) {
-
-		for (i = 0; i < srv_n_log_files; i++) {
-
-			err = open_or_create_log_file(create_new_db,
-						&log_file_created,
-						log_opened, k, i);
-			if (err != DB_SUCCESS) {
-
-				return((int) err);
-			}
-
-			if (log_file_created) {
-				log_created = TRUE;
-			} else {
-				log_opened = TRUE;
-			}
+			return((int) err);
+		}
 
-			if ((log_opened && create_new_db)
+		if (log_file_created) {
+			log_created = TRUE;
+		} else {
+			log_opened = TRUE;
+		}
+		if ((log_opened && create_new_db)
 			    		|| (log_opened && log_created)) {
-				fprintf(stderr, 
+			fprintf(stderr, 
 	"InnoDB: Error: all log files must be created at the same time.\n"
 	"InnoDB: All log files must be created also in database creation.\n"
 	"InnoDB: If you want bigger or smaller log files, shut down the\n"
@@ -1270,14 +1285,16 @@ innobase_start_or_create_for_mysql(void)
 	"InnoDB: Then delete the existing log files. Edit the .cnf file\n"
 	"InnoDB: and start the database again.\n");
 
-				return(DB_ERROR);
-			}
-			
+			return(DB_ERROR);
 		}
 	}
 
-	if (log_created && !create_new_db && !srv_archive_recovery) {
+	/* Open all log files and data files in the system tablespace: we
+	keep them open until database shutdown */
 
+	fil_open_log_and_system_tablespace_files();
+
+	if (log_created && !create_new_db && !srv_archive_recovery) {
 		if (ut_dulint_cmp(max_flushed_lsn, min_flushed_lsn) != 0
 				|| max_arch_log_no != min_arch_log_no) {
 			fprintf(stderr, 
@@ -1323,7 +1340,6 @@ innobase_start_or_create_for_mysql(void)
 	} else if (srv_archive_recovery) {
 		fprintf(stderr,
 	"InnoDB: Starting archive recovery from a backup...\n");
-	
 		err = recv_recovery_from_archive_start(
 					min_flushed_lsn,
 					srv_archive_recovery_limit_lsn,
@@ -1332,14 +1348,11 @@ innobase_start_or_create_for_mysql(void)
 
 			return(DB_ERROR);
 		}
-
 		/* Since ibuf init is in dict_boot, and ibuf is needed
 		in any disk i/o, first call dict_boot */
 
 		dict_boot();
-
 		trx_sys_init_at_db_start();
-		
                 srv_startup_is_before_trx_rollback_phase = FALSE;
 
 		/* Initialize the fsp free limit global variable in the log
@@ -1349,7 +1362,7 @@ innobase_start_or_create_for_mysql(void)
 		recv_recovery_from_archive_finish();
 	} else {
 		/* We always try to do a recovery, even if the database had
-		been shut down normally */
+		been shut down normally: this is the normal startup path */
 		
 		err = recv_recovery_from_checkpoint_start(LOG_CHECKPOINT,
 							ut_dulint_max,
@@ -1413,6 +1426,14 @@ innobase_start_or_create_for_mysql(void)
 		}
 	}
 
+	if (!create_new_db && srv_force_recovery == 0) {
+		/* After a crash recovery we only check that the info in data
+		dictionary is consistent with what we already know about space
+		id's from the call of fil_load_single_table_tablespaces(). */
+
+		dict_check_tablespaces_or_store_max_id(recv_needed_recovery);
+	}
+
 	if (srv_measure_contention) {
 	  	/* os_thread_create(&test_measure_cont, NULL, thread_ids +
                              	     SRV_MAX_N_IO_THREADS); */
@@ -1425,17 +1446,27 @@ innobase_start_or_create_for_mysql(void)
 	and prints InnoDB monitor info */
 	
 	os_thread_create(&srv_lock_timeout_and_monitor_thread, NULL,
-					thread_ids + 2 + SRV_MAX_N_IO_THREADS);	
+				thread_ids + 2 + SRV_MAX_N_IO_THREADS);	
 
 	/* Create the thread which warns of long semaphore waits */
 	os_thread_create(&srv_error_monitor_thread, NULL,
-					thread_ids + 3 + SRV_MAX_N_IO_THREADS);	
+				thread_ids + 3 + SRV_MAX_N_IO_THREADS);	
 	srv_was_started = TRUE;
 	srv_is_being_started = FALSE;
 
+#ifdef UNIV_DEBUG
+        /* Wait a while so that creates threads have time to suspend themselves
+	before we switch sync debugging on; otherwise a thread may execute
+	mutex_enter() before the checks are on, and mutex_exit() after the
+	checks are on. */
+
+        os_thread_sleep(2000000);
+#endif
 	sync_order_checks_on = TRUE;
 
-	if (srv_use_doublewrite_buf && trx_doublewrite == NULL) {
+        if (srv_use_doublewrite_buf && trx_doublewrite == NULL) {
+		/* Create the doublewrite buffer to a new tablespace */
+
 		trx_sys_create_doublewrite_buf();
 	}
 
@@ -1445,8 +1476,8 @@ innobase_start_or_create_for_mysql(void)
 		return((int)DB_ERROR);
 	}
 	
-	/* Create the master thread which monitors the database
-	server, and does purge and other utility operations */
+	/* Create the master thread which does purge and other utility
+	operations */
 
 	os_thread_create(&srv_master_thread, NULL, thread_ids + 1 +
 							SRV_MAX_N_IO_THREADS);
@@ -1478,7 +1509,7 @@ innobase_start_or_create_for_mysql(void)
  			tablespace_size_in_header, sum_of_data_file_sizes);
 	}
 
-	/* Check that os_fast_mutexes work as exptected */
+	/* Check that os_fast_mutexes work as expected */
 	os_fast_mutex_init(&srv_os_test_mutex);
 
 	if (0 != os_fast_mutex_trylock(&srv_os_test_mutex)) {
@@ -1498,7 +1529,10 @@ innobase_start_or_create_for_mysql(void)
 
 	if (srv_print_verbose_log) {
 	  	ut_print_timestamp(stderr);
-	  	fprintf(stderr, "  InnoDB: Started\n");
+	  	fprintf(stderr,
+"  InnoDB: Started; log sequence number %lu %lu\n",
+			ut_dulint_get_high(srv_start_lsn),
+			ut_dulint_get_low(srv_start_lsn));
 	}
 
 	if (srv_force_recovery > 0) {
@@ -1509,6 +1543,47 @@ innobase_start_or_create_for_mysql(void)
 
 	fflush(stderr);
 
+	if (trx_doublewrite_must_reset_space_ids) {
+		fprintf(stderr,
+"InnoDB: You are upgrading to an InnoDB version which allows multiple\n"
+"InnoDB: tablespaces. Wait that purge and insert buffer merge run to\n"
+"InnoDB: completion...\n");
+		for (;;) {
+			os_thread_sleep(1000000);
+
+			if (0 == strcmp(srv_main_thread_op_info,
+					"waiting for server activity")) {
+
+				ut_a(ibuf_is_empty());
+				
+				break;
+			}
+		}
+		fprintf(stderr,
+"InnoDB: Full purge and insert buffer merge completed.\n");
+
+	        trx_sys_mark_upgraded_to_multiple_tablespaces();
+
+		fprintf(stderr,
+"InnoDB: You have now successfully upgraded to the multiple tablespaces\n"
+"InnoDB: format. You should not downgrade again to an earlier version of\n"
+"InnoDB: InnoDB!\n");
+	}
+
+	if (srv_force_recovery == 0) {
+		/* In the insert buffer we may have even bigger tablespace
+		id's, because we may have dropped those tablespaces, but
+		insert buffer merge has not had time to clean the records from
+		the ibuf tree. */
+
+		ibuf_update_max_tablespace_id();
+	}
+
+	srv_file_per_table = srv_file_per_table_original_value;
+
+        fprintf(stderr,
+"TODO: make sure MySQL sets field->query_id right in prepare/execute\n");
+
 	return((int) DB_SUCCESS);
 }
 
@@ -1526,17 +1601,16 @@ innobase_shutdown_for_mysql(void)
 	  	if (srv_is_being_started) {
 	    		ut_print_timestamp(stderr);
             		fprintf(stderr, 
-	"  InnoDB: Warning: shutting down a not properly started\n");
-            		fprintf(stderr, 
-	"                 InnoDB: or created database!\n");
+"  InnoDB: Warning: shutting down a not properly started\n"
+"                 InnoDB: or created database!\n");
 	  	}
 
 	  	return(DB_SUCCESS);
 	}
 
-	/* 1. Flush buffer pool to disk, write the current lsn to
+	/* 1. Flush the buffer pool to disk, write the current lsn to
 	the tablespace header(s), and copy all log data to archive.
-	The step 1 is the real InnoDB shutdown. The remaining steps
+	The step 1 is the real InnoDB shutdown. The remaining steps 2 - ...
 	just free data structures after the shutdown. */
 
 	logs_empty_and_mark_files_at_shutdown();
@@ -1560,16 +1634,16 @@ innobase_shutdown_for_mysql(void)
 	        /* NOTE: IF YOU CREATE THREADS IN INNODB, YOU MUST EXIT THEM
 	        HERE OR EARLIER */
 		
-		/* 1. Let the lock timeout thread exit */
+		/* a. Let the lock timeout thread exit */
 		os_event_set(srv_lock_timeout_thread_event);		
 
-		/* 2. srv error monitor thread exits automatically, no need
+		/* b. srv error monitor thread exits automatically, no need
 		to do anything here */
 
-		/* 3. We wake the master thread so that it exits */
+		/* c. We wake the master thread so that it exits */
 		srv_wake_master_thread();
 
-		/* 4. Exit the i/o threads */
+		/* d. Exit the i/o threads */
 
 		os_aio_wake_all_threads_at_shutdown();
 
@@ -1628,7 +1702,10 @@ innobase_shutdown_for_mysql(void)
 
 	if (srv_print_verbose_log) {
 	        ut_print_timestamp(stderr);
-	        fprintf(stderr, "  InnoDB: Shutdown completed\n");
+	        fprintf(stderr,
+"  InnoDB: Shutdown completed; log sequence number %lu %lu\n",
+			       ut_dulint_get_high(srv_shutdown_lsn),
+			       ut_dulint_get_low(srv_shutdown_lsn));
 	}
 
 	return((int) DB_SUCCESS);