srv0start.c 38.3 KB
Newer Older
1
/************************************************************************
2
Starts the InnoDB database server
3

4
(c) 1996-2000 Innobase Oy
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

Created 2/16/1996 Heikki Tuuri
*************************************************************************/

#include "os0proc.h"
#include "sync0sync.h"
#include "ut0mem.h"
#include "mem0mem.h"
#include "mem0pool.h"
#include "data0data.h"
#include "data0type.h"
#include "dict0dict.h"
#include "buf0buf.h"
#include "buf0flu.h"
#include "buf0rea.h"
#include "os0file.h"
#include "os0thread.h"
#include "fil0fil.h"
#include "fsp0fsp.h"
#include "rem0rec.h"
#include "rem0cmp.h"
#include "mtr0mtr.h"
#include "log0log.h"
#include "log0recv.h"
#include "page0page.h"
#include "page0cur.h"
#include "trx0trx.h"
#include "dict0boot.h"
#include "trx0sys.h"
#include "dict0crea.h"
#include "btr0btr.h"
#include "btr0pcur.h"
#include "btr0cur.h"
#include "btr0sea.h"
#include "rem0rec.h"
#include "srv0srv.h"
#include "que0que.h"
#include "usr0sess.h"
#include "lock0lock.h"
#include "trx0roll.h"
#include "trx0purge.h"
#include "row0ins.h"
#include "row0sel.h"
#include "row0upd.h"
#include "row0row.h"
#include "row0mysql.h"
#include "lock0lock.h"
#include "ibuf0ibuf.h"
#include "pars0pars.h"
#include "btr0sea.h"
#include "srv0start.h"
#include "que0que.h"

unknown's avatar
unknown committed
58 59
ibool           srv_start_has_been_called  = FALSE;

60 61
ulint           srv_sizeof_trx_t_in_ha_innodb_cc;

62
ibool           srv_startup_is_before_trx_rollback_phase = FALSE;
unknown's avatar
unknown committed
63 64 65
ibool           srv_is_being_started = FALSE;
ibool           srv_was_started      = FALSE;

unknown's avatar
Merge  
unknown committed
66 67 68 69
/* At a shutdown the value first climbs to SRV_SHUTDOWN_CLEANUP
and then to SRV_SHUTDOWN_LAST_PHASE */
ulint		srv_shutdown_state = 0;

70 71 72 73 74 75 76 77 78 79
ibool		measure_cont	= FALSE;

os_file_t	files[1000];

mutex_t		ios_mutex;
ulint		ios;

ulint		n[SRV_MAX_N_IO_THREADS + 5];
os_thread_id_t	thread_ids[SRV_MAX_N_IO_THREADS + 5];

unknown's avatar
unknown committed
80 81 82 83 84 85
/* We use this mutex to test the return value of pthread_mutex_trylock
   on successful locking. HP-UX does NOT return 0, though Linux et al do. */
os_fast_mutex_t srv_os_test_mutex;

ibool srv_os_test_mutex_is_locked = FALSE;

86 87 88
#define SRV_N_PENDING_IOS_PER_THREAD 	OS_AIO_N_PENDING_IOS_PER_THREAD
#define SRV_MAX_N_PENDING_SYNC_IOS	100

89 90 91 92
/* 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
93 94 95

#define SRV_LOG_SPACE_FIRST_ID		1000000000

unknown's avatar
unknown committed
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
/*************************************************************************
Reads the data files and their sizes from a character string given in
the .cnf file. */

ibool
srv_parse_data_file_paths_and_sizes(
/*================================*/
					/* out: TRUE if ok, FALSE if parsing
					error */
	char*	str,			/* in: the data file path string */
	char***	data_file_names,	/* out, own: array of data file
					names */
	ulint**	data_file_sizes,	/* out, own: array of data file sizes
					in megabytes */
	ulint**	data_file_is_raw_partition,/* out, own: array of flags
					showing which data files are raw
					partitions */
	ulint*	n_data_files,		/* out: number of data files */
	ibool*	is_auto_extending,	/* out: TRUE if the last data file is
					auto-extending */
	ulint*	max_auto_extend_size)	/* out: max auto extend size for the
					last file if specified, 0 if not */
{
	char*	input_str;
	char*	endp;
	char*	path;
	ulint	size;
	ulint	i	= 0;

	*is_auto_extending = FALSE;
	*max_auto_extend_size = 0;

	input_str = str;
	
	/* First calculate the number of data files and check syntax:
	path:size[M | G];path:size[M | G]... . Note that a Windows path may
	contain a drive name and a ':'. */

	while (*str != '\0') {
		path = str;

		while ((*str != ':' && *str != '\0')
		       || (*str == ':'
			   && (*(str + 1) == '\\' || *(str + 1) == '/'))) {
			str++;
		}

		if (*str == '\0') {
			return(FALSE);
		}

		str++;

		size = strtoul(str, &endp, 10);

		str = endp;

		if (*str != 'M' && *str != 'G') {
			size = size / (1024 * 1024);
		} else if (*str == 'G') {
		        size = size * 1024;
			str++;
		} else {
		        str++;
		}

	        if (strlen(str) >= ut_strlen(":autoextend")
unknown's avatar
unknown committed
163
	            && 0 == ut_memcmp(str, (char*)":autoextend",
unknown's avatar
unknown committed
164 165 166 167 168
						ut_strlen(":autoextend"))) {

			str += ut_strlen(":autoextend");

	        	if (strlen(str) >= ut_strlen(":max:")
unknown's avatar
unknown committed
169
	            		&& 0 == ut_memcmp(str, (char*)":max:",
unknown's avatar
unknown committed
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
						ut_strlen(":max:"))) {

				str += ut_strlen(":max:");

				size = strtoul(str, &endp, 10);

				str = endp;

				if (*str != 'M' && *str != 'G') {
					size = size / (1024 * 1024);
				} else if (*str == 'G') {
		        		size = size * 1024;
					str++;
				} else {
		        		str++;
				}
			}

			if (*str != '\0') {

				return(FALSE);
			}
		}

	        if (strlen(str) >= 6
			   && *str == 'n'
			   && *(str + 1) == 'e' 
		           && *(str + 2) == 'w') {
		  	str += 3;
		}

	        if (strlen(str) >= 3
			   && *str == 'r'
			   && *(str + 1) == 'a' 
		           && *(str + 2) == 'w') {
		  	str += 3;
		}

		if (size == 0) {
			return(FALSE);
		}

		i++;

		if (*str == ';') {
			str++;
		} else if (*str != '\0') {

			return(FALSE);
		}
	}

	*data_file_names = (char**)ut_malloc(i * sizeof(void*));
	*data_file_sizes = (ulint*)ut_malloc(i * sizeof(ulint));
	*data_file_is_raw_partition = (ulint*)ut_malloc(i * sizeof(ulint));

	*n_data_files = i;

	/* Then store the actual values to our arrays */

	str = input_str;
	i = 0;

	while (*str != '\0') {
		path = str;

		/* Note that we must ignore the ':' in a Windows path */

		while ((*str != ':' && *str != '\0')
		       || (*str == ':'
			   && (*(str + 1) == '\\' || *(str + 1) == '/'))) {
			str++;
		}

		if (*str == ':') {
			/* Make path a null-terminated string */
			*str = '\0';
			str++;
		}

		size = strtoul(str, &endp, 10);

		str = endp;

		if ((*str != 'M') && (*str != 'G')) {
			size = size / (1024 * 1024);
		} else if (*str == 'G') {
		        size = size * 1024;
			str++;
		} else {
		        str++;
		}

		(*data_file_names)[i] = path;
		(*data_file_sizes)[i] = size;

	        if (strlen(str) >= ut_strlen(":autoextend")
unknown's avatar
unknown committed
267
	            && 0 == ut_memcmp(str, (char*)":autoextend",
unknown's avatar
unknown committed
268 269 270 271 272 273 274
						ut_strlen(":autoextend"))) {

			*is_auto_extending = TRUE;

			str += ut_strlen(":autoextend");

	        	if (strlen(str) >= ut_strlen(":max:")
unknown's avatar
unknown committed
275
	            		&& 0 == ut_memcmp(str, (char*)":max:",
unknown's avatar
unknown committed
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
						ut_strlen(":max:"))) {

				str += ut_strlen(":max:");

				size = strtoul(str, &endp, 10);

				str = endp;

				if (*str != 'M' && *str != 'G') {
					size = size / (1024 * 1024);
				} else if (*str == 'G') {
		        		size = size * 1024;
					str++;
				} else {
		        		str++;
				}

				*max_auto_extend_size = size;
			}

			if (*str != '\0') {

				return(FALSE);
			}
		}
		
		(*data_file_is_raw_partition)[i] = 0;

	        if (strlen(str) >= 6
			   && *str == 'n'
			   && *(str + 1) == 'e' 
		           && *(str + 2) == 'w') {
		  	str += 3;
		  	(*data_file_is_raw_partition)[i] = SRV_NEW_RAW;
		}

	        if (strlen(str) >= 3
			   && *str == 'r'
			   && *(str + 1) == 'a' 
		           && *(str + 2) == 'w') {
		 	str += 3;
		  
		  	if ((*data_file_is_raw_partition)[i] == 0) {
		    		(*data_file_is_raw_partition)[i] = SRV_OLD_RAW;
		  	}		  
		}

		i++;

		if (*str == ';') {
			str++;
		}
	}

	return(TRUE);
}

/*************************************************************************
Reads log group home directories from a character string given in
the .cnf file. */

ibool
srv_parse_log_group_home_dirs(
/*==========================*/
					/* out: TRUE if ok, FALSE if parsing
					error */
	char*	str,			/* in: character string */
	char***	log_group_home_dirs)	/* out, own: log group home dirs */
{
	char*	input_str;
	char*	path;
	ulint	i	= 0;

	input_str = str;
	
	/* First calculate the number of directories and check syntax:
	path;path;... */

	while (*str != '\0') {
		path = str;

		while (*str != ';' && *str != '\0') {
			str++;
		}

		i++;

		if (*str == ';') {
			str++;
		} else if (*str != '\0') {

			return(FALSE);
		}
	}

	*log_group_home_dirs = (char**) ut_malloc(i * sizeof(void*));

	/* Then store the actual values to our array */

	str = input_str;
	i = 0;

	while (*str != '\0') {
		path = str;

		while (*str != ';' && *str != '\0') {
			str++;
		}

		if (*str == ';') {
			*str = '\0';
			str++;
		}

		(*log_group_home_dirs)[i] = path;

		i++;
	}

	return(TRUE);
}

398 399 400
/************************************************************************
I/o-handler thread function. */
static
401 402 403 404

#ifndef __WIN__
void*
#else
405
ulint
406
#endif
407 408 409 410 411 412 413 414 415
io_handler_thread(
/*==============*/
	void*	arg)
{
	ulint	segment;
	ulint	i;
	
	segment = *((ulint*)arg);

416
#ifdef UNIV_DEBUG_THREAD_CREATION
unknown's avatar
unknown committed
417 418
	printf("Io handler thread %lu starts, id %lu\n", segment,
			  os_thread_pf(os_thread_get_curr_id()));
419
#endif
420 421 422 423 424 425 426 427
	for (i = 0;; i++) {
		fil_aio_wait(segment);

		mutex_enter(&ios_mutex);
		ios++;
		mutex_exit(&ios_mutex);
	}

428 429 430 431 432 433 434
	/* We count the number of threads in os_thread_exit(). A created
	thread should always use that to exit and not use return() to exit.
	The thread actually never comes here because it is exited in an
	os_event_wait(). */

	os_thread_exit(NULL);

435 436 437
#ifndef __WIN__
	return(NULL);
#else
438
	return(0);
439
#endif
440 441
}

unknown's avatar
unknown committed
442
#ifdef __WIN__
443
#define SRV_PATH_SEPARATOR	'\\'
unknown's avatar
unknown committed
444
#else
445
#define SRV_PATH_SEPARATOR	'/'
unknown's avatar
unknown committed
446 447 448 449
#endif

/*************************************************************************
Normalizes a directory path for Windows: converts slashes to backslashes. */
unknown's avatar
unknown committed
450

unknown's avatar
unknown committed
451 452 453
void
srv_normalize_path_for_win(
/*=======================*/
unknown's avatar
unknown committed
454
	char*	str __attribute__((unused)))	/* in/out: null-terminated character string */
unknown's avatar
unknown committed
455 456 457 458 459 460 461 462 463 464 465 466 467 468
{
#ifdef __WIN__
	ulint	i;

	for (i = 0; i < ut_strlen(str); i++) {

		if (str[i] == '/') {
			str[i] = '\\';
		}
	}
#endif
}
	
/*************************************************************************
469 470
Adds a slash or a backslash to the end of a string if it is missing
and the string is not empty. */
unknown's avatar
unknown committed
471

472
static
unknown's avatar
unknown committed
473 474 475
char*
srv_add_path_separator_if_needed(
/*=============================*/
476
			/* out: string which has the separator if the
477
			string is not empty */
unknown's avatar
unknown committed
478 479 480
	char*	str)	/* in: null-terminated character string */
{
	char*	out_str;
481
	ulint	len	= ut_strlen(str);
unknown's avatar
unknown committed
482

483
	if (len == 0 || str[len - 1] == SRV_PATH_SEPARATOR) {
unknown's avatar
unknown committed
484

485
		return(str);
unknown's avatar
unknown committed
486 487
	}

488 489 490 491
	out_str = ut_malloc(len + 2);
	memcpy(out_str, str, len);
	out_str[len] = SRV_PATH_SEPARATOR;
	out_str[len + 1] = 0;
unknown's avatar
unknown committed
492 493 494 495

	return(out_str);
}

unknown's avatar
Merge  
unknown committed
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
/*************************************************************************
Calculates the low 32 bits when a file size which is given as a number
database pages is converted to the number of bytes. */
static
ulint
srv_calc_low32(
/*===========*/
				/* out: low 32 bytes of file size when
				expressed in bytes */
	ulint	file_size)	/* in: file size in database pages */
{
	return(0xFFFFFFFF & (file_size << UNIV_PAGE_SIZE_SHIFT));
}

/*************************************************************************
Calculates the high 32 bits when a file size which is given as a number
database pages is converted to the number of bytes. */
static
ulint
srv_calc_high32(
/*============*/
				/* out: high 32 bytes of file size when
				expressed in bytes */
	ulint	file_size)	/* in: file size in database pages */
{
	return(file_size >> (32 - UNIV_PAGE_SIZE_SHIFT));
}

524
/*************************************************************************
unknown's avatar
unknown committed
525
Creates or opens the log files and closes them. */
526 527 528 529 530 531 532 533 534
static
ulint
open_or_create_log_file(
/*====================*/
					/* out: DB_SUCCESS or error code */
	ibool	create_new_db,		/* in: TRUE if we should create a
					new database */
	ibool*	log_file_created,	/* out: TRUE if new log file
					created */
unknown's avatar
unknown committed
535 536 537
	ibool	log_file_has_been_opened,/* in: TRUE if a log file has been
					opened before: then it is an error
					to try to create another log file */
538 539 540 541 542 543 544 545 546
	ulint	k,			/* in: log group number */
	ulint	i)			/* in: log file number in group */
{
	ibool	ret;
	ulint	arch_space_id;
	ulint	size;
	ulint	size_high;
	char	name[10000];

547 548
	UT_NOT_USED(create_new_db);

549
	*log_file_created = FALSE;
unknown's avatar
unknown committed
550 551 552 553 554

	srv_normalize_path_for_win(srv_log_group_home_dirs[k]);
	srv_log_group_home_dirs[k] = srv_add_path_separator_if_needed(
						srv_log_group_home_dirs[k]);

555 556
	sprintf(name, "%s%s%lu", srv_log_group_home_dirs[k], "ib_logfile", i);

557 558
	files[i] = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL,
						OS_LOG_FILE, &ret);
559 560 561
	if (ret == FALSE) {
		if (os_file_get_last_error() != OS_FILE_ALREADY_EXISTS) {
			fprintf(stderr,
562
			"InnoDB: Error in creating or opening %s\n", name);
563 564 565 566
				
			return(DB_ERROR);
		}

unknown's avatar
Merge  
unknown committed
567
		files[i] = os_file_create(name, OS_FILE_OPEN, OS_FILE_AIO,
568
							OS_LOG_FILE, &ret);
569 570
		if (!ret) {
			fprintf(stderr,
571
			"InnoDB: Error in opening %s\n", name);
572 573 574 575 576 577 578
				
			return(DB_ERROR);
		}

		ret = os_file_get_size(files[i], &size, &size_high);
		ut_a(ret);
		
unknown's avatar
Merge  
unknown committed
579 580 581
		if (size != srv_calc_low32(srv_log_file_size)
		    || size_high != srv_calc_high32(srv_log_file_size)) {
		    	
582
			fprintf(stderr,
unknown's avatar
unknown committed
583 584 585 586 587
"InnoDB: Error: log file %s is of different size %lu %lu bytes\n"
"InnoDB: than specified in the .cnf file %lu %lu bytes!\n",
				name, size_high, size,
				srv_calc_high32(srv_log_file_size),
				srv_calc_low32(srv_log_file_size));
588 589 590 591 592
				
			return(DB_ERROR);
		}					
	} else {
		*log_file_created = TRUE;
unknown's avatar
unknown committed
593

unknown's avatar
unknown committed
594 595
	    	ut_print_timestamp(stderr);

596
		fprintf(stderr,
unknown's avatar
unknown committed
597
		"  InnoDB: Log file %s did not exist: new to be created\n",
598
									name);
unknown's avatar
unknown committed
599 600 601 602 603
		if (log_file_has_been_opened) {

			return(DB_ERROR);
		}

unknown's avatar
Merge  
unknown committed
604 605 606
		fprintf(stderr, "InnoDB: Setting log file %s size to %lu MB\n",
			             name, srv_log_file_size
			>> (20 - UNIV_PAGE_SIZE_SHIFT));
607

unknown's avatar
unknown committed
608 609 610
		fprintf(stderr,
	    "InnoDB: Database physically writes the file full: wait...\n");

611
		ret = os_file_set_size(name, files[i],
unknown's avatar
Merge  
unknown committed
612 613
					srv_calc_low32(srv_log_file_size),
					srv_calc_high32(srv_log_file_size));
614 615
		if (!ret) {
			fprintf(stderr,
616
		"InnoDB: Error in creating %s: probably out of disk space\n",
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
			name);

			return(DB_ERROR);
		}
	}

	ret = os_file_close(files[i]);
	ut_a(ret);

	if (i == 0) {
		/* Create in memory the file space object
		which is for this log group */
				
		fil_space_create(name,
		2 * k + SRV_LOG_SPACE_FIRST_ID, FIL_LOG);
	}

	ut_a(fil_validate());

	fil_node_create(name, srv_log_file_size,
					2 * k + SRV_LOG_SPACE_FIRST_ID);

	/* If this is the first log group, create the file space object
	for archived logs */

	if (k == 0 && i == 0) {
		arch_space_id = 2 * k + 1 + SRV_LOG_SPACE_FIRST_ID;

unknown's avatar
unknown committed
645
	    	fil_space_create((char*) "arch_log_space", arch_space_id, FIL_LOG);
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
	} else {
		arch_space_id = ULINT_UNDEFINED;
	}

	if (i == 0) {
		log_group_init(k, srv_n_log_files,
				srv_log_file_size * UNIV_PAGE_SIZE,
				2 * k + SRV_LOG_SPACE_FIRST_ID,
				arch_space_id);
	}

	return(DB_SUCCESS);
}

/*************************************************************************
unknown's avatar
unknown committed
661
Creates or opens database data files and closes them. */
662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
static
ulint
open_or_create_data_files(
/*======================*/
				/* out: DB_SUCCESS or error code */
	ibool*	create_new_db,	/* out: TRUE if new database should be
								created */
	dulint*	min_flushed_lsn,/* out: min of flushed lsn values in data
				files */
	ulint*	min_arch_log_no,/* out: min of archived log numbers in data
				files */
	dulint*	max_flushed_lsn,/* out: */
	ulint*	max_arch_log_no,/* out: */
	ulint*	sum_of_new_sizes)/* out: sum of sizes of the new files added */
{
	ibool	ret;
	ulint	i;
	ibool	one_opened	= FALSE;
	ibool	one_created	= FALSE;
	ulint	size;
	ulint	size_high;
unknown's avatar
unknown committed
683
	ulint	rounded_size_pages;
684 685
	char	name[10000];

686 687 688 689 690 691
	if (srv_n_data_files >= 1000) {
		fprintf(stderr, "InnoDB: can only have < 1000 data files\n"
				"InnoDB: you have defined %lu\n",
				srv_n_data_files);
		return(DB_ERROR);
	}
692 693 694 695 696

	*sum_of_new_sizes = 0;
	
	*create_new_db = FALSE;

unknown's avatar
unknown committed
697 698 699
	srv_normalize_path_for_win(srv_data_home);
	srv_data_home = srv_add_path_separator_if_needed(srv_data_home);

700
	for (i = 0; i < srv_n_data_files; i++) {
unknown's avatar
unknown committed
701
		srv_normalize_path_for_win(srv_data_file_names[i]);
702 703 704

		sprintf(name, "%s%s", srv_data_home, srv_data_file_names[i]);
	
705 706
		files[i] = os_file_create(name, OS_FILE_CREATE,
					OS_FILE_NORMAL, OS_DATA_FILE, &ret);
707

708 709 710
		if (srv_data_file_is_raw_partition[i] == SRV_NEW_RAW) {
			/* The partition is opened, not created; then it is
			written over */
711

712 713
			srv_created_new_raw = TRUE;

714 715 716 717
			files[i] = os_file_create(
				name, OS_FILE_OPEN, OS_FILE_NORMAL,
						OS_DATA_FILE, &ret);
			if (!ret) {
718 719 720 721
				fprintf(stderr,
				"InnoDB: Error in opening %s\n", name);

				return(DB_ERROR);
722 723 724
			}
		} else if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
			ret = FALSE;
725 726
		}

727
		if (ret == FALSE) {
728
			if (srv_data_file_is_raw_partition[i] != SRV_OLD_RAW
729
			    && os_file_get_last_error() !=
730 731
						OS_FILE_ALREADY_EXISTS) {
				fprintf(stderr,
732
				"InnoDB: Error in creating or opening %s\n",
733 734 735 736 737 738 739
				name);

				return(DB_ERROR);
			}

			if (one_created) {
				fprintf(stderr,
740
	"InnoDB: Error: data files can only be added at the end\n");
741
				fprintf(stderr,
742
	"InnoDB: of a tablespace, but data file %s existed beforehand.\n",
743 744 745 746 747
				name);
				return(DB_ERROR);
			}
				
			files[i] = os_file_create(
748 749
				name, OS_FILE_OPEN, OS_FILE_NORMAL,
						OS_DATA_FILE, &ret);
750 751
			if (!ret) {
				fprintf(stderr,
752
				"InnoDB: Error in opening %s\n", name);
753
				os_file_get_last_error();
754 755 756 757

				return(DB_ERROR);
			}

758 759 760 761 762
			if (srv_data_file_is_raw_partition[i] != SRV_OLD_RAW) {
			
				ret = os_file_get_size(files[i], &size,
								&size_high);
				ut_a(ret);
unknown's avatar
unknown committed
763
				/* Round size downward to megabytes */
764
		
unknown's avatar
unknown committed
765 766 767 768 769 770 771 772 773 774 775 776 777 778
				rounded_size_pages = (size / (1024 * 1024)
							+ 4096 * size_high)
					     << (20 - UNIV_PAGE_SIZE_SHIFT);

				if (i == srv_n_data_files - 1
				    && srv_auto_extend_last_data_file) {

				    	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,
unknown's avatar
unknown committed
779 780 781 782 783 784 785
"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);
unknown's avatar
unknown committed
786 787 788 789 790 791 792 793
					}
				    	     
				    	srv_data_file_sizes[i] =
				    			rounded_size_pages;
				}
				
				if (rounded_size_pages
						!= srv_data_file_sizes[i]) {
unknown's avatar
Merge  
unknown committed
794

795
					fprintf(stderr,
unknown's avatar
unknown committed
796 797 798 799 800
"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]);
801
				
802 803
					return(DB_ERROR);
				}
804 805 806 807 808 809 810 811 812 813 814
			}

			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 {
			one_created = TRUE;

			if (i > 0) {
unknown's avatar
unknown committed
815
	    			ut_print_timestamp(stderr);
816
				fprintf(stderr, 
unknown's avatar
unknown committed
817
		"  InnoDB: Data file %s did not exist: new to be created\n",
818
									name);
819 820
			} else {
				fprintf(stderr, 
821 822
 		"InnoDB: The first specified data file %s did not exist:\n"
		"InnoDB: a new database to be created!\n", name);
823 824 825
				*create_new_db = TRUE;
			}
			
unknown's avatar
unknown committed
826
	    		ut_print_timestamp(stderr);
unknown's avatar
Merge  
unknown committed
827
			fprintf(stderr, 
unknown's avatar
unknown committed
828
				"  InnoDB: Setting file %s size to %lu MB\n",
unknown's avatar
Merge  
unknown committed
829 830
			       name, (srv_data_file_sizes[i]
				      >> (20 - UNIV_PAGE_SIZE_SHIFT)));
831

832
			fprintf(stderr,
unknown's avatar
unknown committed
833
	"InnoDB: Database physically writes the file full: wait...\n");
834

835
			ret = os_file_set_size(name, files[i],
unknown's avatar
Merge  
unknown committed
836 837
				srv_calc_low32(srv_data_file_sizes[i]),
				srv_calc_high32(srv_data_file_sizes[i]));
838 839 840

			if (!ret) {
				fprintf(stderr, 
841
	"InnoDB: Error in creating %s: probably out of disk space\n", name);
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870

				return(DB_ERROR);
			}

			*sum_of_new_sizes = *sum_of_new_sizes
						+ srv_data_file_sizes[i];
		}

		ret = os_file_close(files[i]);
		ut_a(ret);

		if (i == 0) {
			fil_space_create(name, 0, FIL_TABLESPACE);
		}

		ut_a(fil_validate());

		fil_node_create(name, srv_data_file_sizes[i], 0);
	}

	ios = 0;

	mutex_create(&ios_mutex);
	mutex_set_level(&ios_mutex, SYNC_NO_ORDER_CHECK);

	return(DB_SUCCESS);
}

/********************************************************************
871
Starts InnoDB and creates a new database if database files
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
are not found and the user wants. Server parameters are
read from a file of name "srv_init" in the ib_home directory. */

int
innobase_start_or_create_for_mysql(void)
/*====================================*/
				/* out: DB_SUCCESS or error code */
{
	ibool	create_new_db;
	ibool	log_file_created;
	ibool	log_created	= FALSE;
	ibool	log_opened	= FALSE;
	dulint	min_flushed_lsn;
	dulint	max_flushed_lsn;
	ulint	min_arch_log_no;
	ulint	max_arch_log_no;
	ibool	start_archive;
	ulint   sum_of_new_sizes;
unknown's avatar
unknown committed
890 891
	ulint	sum_of_data_file_sizes;
	ulint	tablespace_size_in_header;
892 893 894
	ulint	err;
	ulint	i;
	ulint	k;
895 896
	mtr_t   mtr;

unknown's avatar
unknown committed
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916
#ifdef UNIV_DEBUG
	fprintf(stderr,
"InnoDB: !!!!!!!!!!!!!! UNIV_DEBUG switched on !!!!!!!!!!!!!!!\n"); 
#endif

#ifdef UNIV_SYNC_DEBUG
	fprintf(stderr,
"InnoDB: !!!!!!!!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!!!!!!!\n"); 
#endif

#ifdef UNIV_SEARCH_DEBUG
	fprintf(stderr,
"InnoDB: !!!!!!!!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!!!!!!!\n"); 
#endif

#ifdef UNIV_MEM_DEBUG
	fprintf(stderr,
"InnoDB: !!!!!!!!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!!!!!!!\n"); 
#endif

917 918 919 920 921 922 923 924 925
        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"
  "InnoDB: Check that pthread_mutex_t is defined in the same way in these\n"
  "InnoDB: compilation modules. Cannot continue.\n",
		  srv_sizeof_trx_t_in_ha_innodb_cc, (ulint)sizeof(trx_t));
		return(DB_ERROR);
	}

unknown's avatar
unknown committed
926 927 928 929 930 931 932 933 934 935 936 937 938 939
	/* Since InnoDB does not currently clean up all its internal data
	   structures in MySQL Embedded Server Library server_end(), we
	   print an error message if someone tries to start up InnoDB a
	   second time during the process lifetime. */

	if (srv_start_has_been_called) {
	        fprintf(stderr,
"InnoDB: Error:startup called second time during the process lifetime.\n"
"InnoDB: In the MySQL Embedded Server Library you cannot call server_init()\n"
"InnoDB: more than once during the process lifetime.\n");
	}

	srv_start_has_been_called = TRUE;

940 941 942
	log_do_write = TRUE;
/*	yydebug = TRUE; */

unknown's avatar
unknown committed
943
	srv_is_being_started = TRUE;
944
        srv_startup_is_before_trx_rollback_phase = TRUE;
unknown's avatar
unknown committed
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
	os_aio_use_native_aio = FALSE;

#ifdef __WIN__
	if (os_get_os_version() == OS_WIN95
	    || os_get_os_version() == OS_WIN31
	    || os_get_os_version() == OS_WINNT) {

	  	/* On Win 95, 98, ME, Win32 subsystem for Windows 3.1,
		and NT use simulated aio. In NT Windows provides async i/o,
		but when run in conjunction with InnoDB Hot Backup, it seemed
		to corrupt the data files. */

	  	os_aio_use_native_aio = FALSE;
	} else {
	  	/* On Win 2000 and XP use async i/o */
	  	os_aio_use_native_aio = TRUE;
	}
#endif	
        if (srv_file_flush_method_str == NULL) {
        	/* These are the default options */
unknown's avatar
unknown committed
965

unknown's avatar
unknown committed
966 967 968 969
		srv_unix_file_flush_method = SRV_UNIX_FDATASYNC;

		srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
#ifndef __WIN__        
unknown's avatar
unknown committed
970 971
	} else if (0 == ut_strcmp(srv_file_flush_method_str,
							(char*)"fdatasync")) {
972 973
	  	srv_unix_file_flush_method = SRV_UNIX_FDATASYNC;

unknown's avatar
unknown committed
974 975
	} else if (0 == ut_strcmp(srv_file_flush_method_str,
							(char*)"O_DSYNC")) {
976 977
	  	srv_unix_file_flush_method = SRV_UNIX_O_DSYNC;

978 979 980 981
	} else if (0 == ut_strcmp(srv_file_flush_method_str,
							(char*)"O_DIRECT")) {
	  	srv_unix_file_flush_method = SRV_UNIX_O_DIRECT;

unknown's avatar
unknown committed
982
	} else if (0 == ut_strcmp(srv_file_flush_method_str,
unknown's avatar
unknown committed
983
							(char*)"littlesync")) {
984 985
	  	srv_unix_file_flush_method = SRV_UNIX_LITTLESYNC;

unknown's avatar
unknown committed
986 987
	} else if (0 == ut_strcmp(srv_file_flush_method_str,
							(char*)"nosync")) {
988
	  	srv_unix_file_flush_method = SRV_UNIX_NOSYNC;
unknown's avatar
unknown committed
989
#else
unknown's avatar
unknown committed
990 991
	} else if (0 == ut_strcmp(srv_file_flush_method_str,
							(char*)"normal")) {
unknown's avatar
unknown committed
992 993 994 995 996 997 998 999 1000 1001 1002
	  	srv_win_file_flush_method = SRV_WIN_IO_NORMAL;
	  	os_aio_use_native_aio = FALSE;

	} else if (0 == ut_strcmp(srv_file_flush_method_str, "unbuffered")) {
	  	srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
	  	os_aio_use_native_aio = FALSE;

	} else if (0 == ut_strcmp(srv_file_flush_method_str,
							"async_unbuffered")) {
	  	srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;	
#endif
1003
	} else {
1004 1005
	  	fprintf(stderr, 
          	"InnoDB: Unrecognized value %s for innodb_flush_method\n",
unknown's avatar
unknown committed
1006
          				srv_file_flush_method_str);
1007
	  	return(DB_ERROR);
1008 1009
	}

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
        /* Set the maximum number of threads which can wait for a semaphore
        inside InnoDB */
#if defined(__WIN__) || defined(__NETWARE__)

/* Create less event semaphores because Win 98/ME had difficulty creating
40000 event semaphores.
Comment from Novell, Inc.: also, these just take a lot of memory on
NetWare. */
        srv_max_n_threads = 1000;
#else
        if (srv_pool_size >= 8 * 1024 * 1024) {
                                  /* Here we still have srv_pool_size counted
                                  in bytes, srv_boot converts the value to
                                  pages; if buffer pool is less than 8 MB,
                                  assume fewer threads. */
                srv_max_n_threads = 10000;
        } else {
		srv_max_n_threads = 1000;       /* saves several MB of memory,
                                                especially in 64-bit
                                                computers */
        }
#endif
1032 1033 1034 1035 1036 1037 1038
	err = srv_boot();

	if (err != DB_SUCCESS) {

		return((int) err);
	}

1039 1040
	/* Restrict the maximum number of file i/o threads */
	if (srv_n_file_io_threads > SRV_MAX_N_IO_THREADS) {
unknown's avatar
unknown committed
1041

1042 1043 1044
		srv_n_file_io_threads = SRV_MAX_N_IO_THREADS;
	}

unknown's avatar
unknown committed
1045 1046
	if (!os_aio_use_native_aio) {
 		/* In simulated aio we currently have use only for 4 threads */
1047

unknown's avatar
unknown committed
1048
		srv_n_file_io_threads = 4;
1049

unknown's avatar
unknown committed
1050
		os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
						* srv_n_file_io_threads,
					srv_n_file_io_threads,
					SRV_MAX_N_PENDING_SYNC_IOS);
	} else {
		os_aio_init(SRV_N_PENDING_IOS_PER_THREAD
						* srv_n_file_io_threads,
					srv_n_file_io_threads,
					SRV_MAX_N_PENDING_SYNC_IOS);
	}
	
	fil_init(SRV_MAX_N_OPEN_FILES);

	buf_pool_init(srv_pool_size, srv_pool_size);

	fsp_init();
	log_init();
	
	lock_sys_create(srv_lock_table_size);

	/* Create i/o-handler threads: */

	for (i = 0; i < srv_n_file_io_threads; i++) {
		n[i] = i;

		os_thread_create(io_handler_thread, n + i, thread_ids + i);
1076
    	}
1077

unknown's avatar
unknown committed
1078 1079 1080 1081 1082 1083 1084 1085
	if (0 != ut_strcmp(srv_log_group_home_dirs[0], srv_arch_dir)) {
		fprintf(stderr,
	"InnoDB: Error: you must set the log group home dir in my.cnf the\n"
	"InnoDB: same as log arch dir.\n");

		return(DB_ERROR);
	}

unknown's avatar
unknown committed
1086
	if (srv_n_log_files * srv_log_file_size >= 262144) {
unknown's avatar
Merge  
unknown committed
1087 1088

		fprintf(stderr,
unknown's avatar
unknown committed
1089
		"InnoDB: Error: combined size of log files must be < 4 GB\n");
1090

unknown's avatar
Merge  
unknown committed
1091 1092 1093 1094 1095
		return(DB_ERROR);
	}

	sum_of_new_sizes = 0;
	
1096
	for (i = 0; i < srv_n_data_files; i++) {
unknown's avatar
Merge  
unknown committed
1097 1098
#ifndef __WIN__
		if (sizeof(off_t) < 5 && srv_data_file_sizes[i] >= 262144) {
1099
		 	fprintf(stderr,
unknown's avatar
Merge  
unknown committed
1100 1101
	"InnoDB: Error: file size must be < 4 GB with this MySQL binary\n"
	"InnoDB: and operating system combination, in some OS's < 2 GB\n");
1102 1103 1104

		  	return(DB_ERROR);
		}
unknown's avatar
Merge  
unknown committed
1105
#endif
1106
		sum_of_new_sizes += srv_data_file_sizes[i];
1107 1108 1109
	}

	if (sum_of_new_sizes < 640) {
1110
		  fprintf(stderr,
1111 1112
		  "InnoDB: Error: tablespace size must be at least 10 MB\n");

1113
		  return(DB_ERROR);
1114 1115
	}

1116 1117 1118 1119 1120
	err = open_or_create_data_files(&create_new_db,
					&min_flushed_lsn, &min_arch_log_no,
					&max_flushed_lsn, &max_arch_log_no,
					&sum_of_new_sizes);
	if (err != DB_SUCCESS) {
unknown's avatar
unknown committed
1121 1122 1123 1124 1125 1126 1127 1128
	        fprintf(stderr,
"InnoDB: Could not open or create data files.\n"
"InnoDB: If you tried to add new data files, and it failed here,\n"
"InnoDB: you should now edit innodb_data_file_path in my.cnf back\n"
"InnoDB: to what it was, and remove the new ibdata files InnoDB created\n"
"InnoDB: in this failed attempt. InnoDB only wrote those files full of\n"
"InnoDB: zeros, but did not yet use them in any way. But be careful: do not\n"
"InnoDB: remove old data files which contain your precious data!\n");
1129

1130 1131 1132
		return((int) err);
	}

1133 1134 1135 1136 1137 1138
	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 */
		
unknown's avatar
unknown committed
1139 1140 1141 1142
		if (srv_force_recovery < SRV_FORCE_NO_LOG_REDO) {
		
			trx_sys_doublewrite_restore_corrupt_pages();
		}
1143 1144
	}

unknown's avatar
unknown committed
1145 1146 1147
	srv_normalize_path_for_win(srv_arch_dir);
	srv_arch_dir = srv_add_path_separator_if_needed(srv_arch_dir);

1148 1149 1150 1151 1152
	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,
unknown's avatar
unknown committed
1153 1154
						&log_file_created,
						log_opened, k, i);
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
			if (err != DB_SUCCESS) {

				return((int) err);
			}

			if (log_file_created) {
				log_created = TRUE;
			} else {
				log_opened = TRUE;
			}

			if ((log_opened && create_new_db)
			    		|| (log_opened && log_created)) {
				fprintf(stderr, 
1169
	"InnoDB: Error: all log files must be created at the same time.\n"
unknown's avatar
unknown committed
1170 1171 1172
	"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"
	"InnoDB: database and make sure there were no errors in shutdown.\n"
1173 1174
	"InnoDB: Then delete the existing log files. Edit the .cnf file\n"
	"InnoDB: and start the database again.\n");
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186

				return(DB_ERROR);
			}
			
		}
	}

	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, 
1187 1188
		"InnoDB: Cannot initialize created log files because\n"
		"InnoDB: data files were not in sync with each other\n"
unknown's avatar
unknown committed
1189
		"InnoDB: or the data files are corrupt.\n");
1190 1191 1192 1193 1194 1195 1196

			return(DB_ERROR);
		}

		if (ut_dulint_cmp(max_flushed_lsn, ut_dulint_create(0, 1000))
		    < 0) {
		    	fprintf(stderr,
1197 1198 1199 1200 1201
		"InnoDB: Cannot initialize created log files because\n"
		"InnoDB: data files are corrupt, or new data files were\n"
		"InnoDB: created when the database was started previous\n"
		"InnoDB: time but the database was not shut down\n"
		"InnoDB: normally after that.\n");
1202 1203 1204 1205 1206 1207

			return(DB_ERROR);
		}

		mutex_enter(&(log_sys->mutex));

unknown's avatar
unknown committed
1208
		recv_reset_logs(max_flushed_lsn, max_arch_log_no + 1, TRUE);
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
		
		mutex_exit(&(log_sys->mutex));
	}

	if (create_new_db) {
		mtr_start(&mtr);

		fsp_header_init(0, sum_of_new_sizes, &mtr);		

		mtr_commit(&mtr);

		trx_sys_create();
		dict_create();
1222
                srv_startup_is_before_trx_rollback_phase = FALSE;
1223 1224 1225

	} else if (srv_archive_recovery) {
		fprintf(stderr,
1226
	"InnoDB: Starting archive recovery from a backup...\n");
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
	
		err = recv_recovery_from_archive_start(
					min_flushed_lsn,
					srv_archive_recovery_limit_lsn,
					min_arch_log_no);
		if (err != DB_SUCCESS) {

			return(DB_ERROR);
		}

1237 1238 1239
		/* Since ibuf init is in dict_boot, and ibuf is needed
		in any disk i/o, first call dict_boot */

1240
		dict_boot();
1241 1242

		trx_sys_init_at_db_start();
1243
		
1244 1245
                srv_startup_is_before_trx_rollback_phase = FALSE;

unknown's avatar
unknown committed
1246 1247 1248 1249
		/* Initialize the fsp free limit global variable in the log
		system */
		fsp_header_get_free_limit(0);

1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
		recv_recovery_from_archive_finish();
	} else {
		/* We always try to do a recovery, even if the database had
		been shut down normally */
		
		err = recv_recovery_from_checkpoint_start(LOG_CHECKPOINT,
							ut_dulint_max,
							min_flushed_lsn,
							max_flushed_lsn);
		if (err != DB_SUCCESS) {

			return(DB_ERROR);
		}

1264 1265
		/* Since ibuf init is in dict_boot, and ibuf is needed
		in any disk i/o, first call dict_boot */
unknown's avatar
unknown committed
1266

1267
		dict_boot();
1268
		trx_sys_init_at_db_start();
1269 1270 1271

		/* The following needs trx lists which are initialized in
		trx_sys_init_at_db_start */
1272 1273

                srv_startup_is_before_trx_rollback_phase = FALSE;
unknown's avatar
unknown committed
1274 1275 1276 1277 1278

		/* Initialize the fsp free limit global variable in the log
		system */
		fsp_header_get_free_limit(0);

1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
		recv_recovery_from_checkpoint_finish();
	}
	
	if (!create_new_db && sum_of_new_sizes > 0) {
		/* New data file(s) were added */
		mtr_start(&mtr);

		fsp_header_inc_size(0, sum_of_new_sizes, &mtr);		

		mtr_commit(&mtr);
	}

unknown's avatar
unknown committed
1291 1292 1293 1294 1295 1296
	if (recv_needed_recovery) {
	    	ut_print_timestamp(stderr);
		fprintf(stderr,
	        "  InnoDB: Flushing modified pages from the buffer pool...\n");
	}

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
	log_make_checkpoint_at(ut_dulint_max, TRUE);

	if (!srv_log_archive_on) {
		ut_a(DB_SUCCESS == log_archive_noarchivelog());
	} else {
		mutex_enter(&(log_sys->mutex));

		start_archive = FALSE;

		if (log_sys->archiving_state == LOG_ARCH_OFF) {
			start_archive = TRUE;
		}

		mutex_exit(&(log_sys->mutex));

		if (start_archive) {
			ut_a(DB_SUCCESS == log_archive_archivelog());
		}
	}

	if (srv_measure_contention) {
1318
	  	/* os_thread_create(&test_measure_cont, NULL, thread_ids +
1319
                             	     SRV_MAX_N_IO_THREADS); */
1320 1321 1322 1323 1324
	}

	/* fprintf(stderr, "Max allowed record size %lu\n",
				page_get_free_space_of_empty() / 2); */

1325 1326 1327 1328
	/* Create the thread which watches the timeouts for lock waits
	and prints InnoDB monitor info */
	
	os_thread_create(&srv_lock_timeout_and_monitor_thread, NULL,
1329
					thread_ids + 2 + SRV_MAX_N_IO_THREADS);	
1330 1331 1332 1333

	/* 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);	
unknown's avatar
unknown committed
1334 1335 1336
	srv_was_started = TRUE;
	srv_is_being_started = FALSE;

1337 1338
	sync_order_checks_on = TRUE;

1339 1340 1341 1342
	if (srv_use_doublewrite_buf && trx_doublewrite == NULL) {
		trx_sys_create_doublewrite_buf();
	}

1343 1344 1345 1346 1347
	err = dict_create_or_check_foreign_constraint_tables();

	if (err != DB_SUCCESS) {
		return((int)DB_ERROR);
	}
unknown's avatar
unknown committed
1348
	
1349 1350 1351 1352 1353
	/* Create the master thread which monitors the database
	server, and does purge and other utility operations */

	os_thread_create(&srv_master_thread, NULL, thread_ids + 1 +
							SRV_MAX_N_IO_THREADS);
1354
	/* buf_debug_prints = TRUE; */
unknown's avatar
unknown committed
1355 1356

	sum_of_data_file_sizes = 0;
1357
	
unknown's avatar
unknown committed
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
	for (i = 0; i < srv_n_data_files; i++) {
		sum_of_data_file_sizes += srv_data_file_sizes[i];
	}

	tablespace_size_in_header = fsp_header_get_tablespace_size(0);

	if (!srv_auto_extend_last_data_file
		&& sum_of_data_file_sizes != tablespace_size_in_header) {

		fprintf(stderr,
"InnoDB: Error: tablespace size stored in header is %lu pages, but\n"
"InnoDB: the sum of data file sizes is %lu pages\n",
 			tablespace_size_in_header, sum_of_data_file_sizes);
	}

	if (srv_auto_extend_last_data_file
		&& sum_of_data_file_sizes < tablespace_size_in_header) {

		fprintf(stderr,
"InnoDB: Error: tablespace size stored in header is %lu pages, but\n"
"InnoDB: the sum of data file sizes is only %lu pages\n",
 			tablespace_size_in_header, sum_of_data_file_sizes);
	}

unknown's avatar
unknown committed
1382 1383 1384 1385 1386 1387
	/* Check that os_fast_mutexes work as exptected */
	os_fast_mutex_init(&srv_os_test_mutex);

	if (0 != os_fast_mutex_trylock(&srv_os_test_mutex)) {
	        fprintf(stderr,
"InnoDB: Error: pthread_mutex_trylock returns an unexpected value on\n"
unknown's avatar
unknown committed
1388
"InnoDB: success! Cannot continue.\n");
unknown's avatar
unknown committed
1389 1390 1391 1392 1393 1394 1395 1396 1397
	        exit(1);
	}

	os_fast_mutex_unlock(&srv_os_test_mutex);

        os_fast_mutex_lock(&srv_os_test_mutex);

	os_fast_mutex_unlock(&srv_os_test_mutex);

unknown's avatar
unknown committed
1398
	os_fast_mutex_free(&srv_os_test_mutex);
unknown's avatar
unknown committed
1399

1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
	/***********************************************************/
	/* Do NOT merge to the 4.1 code base! */
	if (trx_sys_downgrading_from_4_1_1) {
		fprintf(stderr,
"InnoDB: You are downgrading from 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(10000000);

			if (0 == strcmp(srv_main_thread_op_info,
					"waiting for server activity")) {
				break;
			}
		}
		fprintf(stderr,
"InnoDB: Full purge and insert buffer merge completed.\n");

	        trx_sys_mark_downgraded_from_4_1_1();

		fprintf(stderr,
"InnoDB: Downgraded from >= 4.1.1 to 4.0\n");
	}
	/***********************************************************/

unknown's avatar
unknown committed
1425 1426 1427
	if (srv_print_verbose_log) {
	  	ut_print_timestamp(stderr);
	  	fprintf(stderr, "  InnoDB: Started\n");
1428
	}
unknown's avatar
unknown committed
1429 1430 1431 1432 1433

	if (srv_force_recovery > 0) {
		fprintf(stderr,
		"InnoDB: !!! innodb_force_recovery is set to %lu !!!\n",
			srv_force_recovery);
unknown's avatar
unknown committed
1434 1435 1436
	}

	fflush(stderr);
unknown's avatar
unknown committed
1437

1438 1439 1440 1441
	return((int) DB_SUCCESS);
}

/********************************************************************
1442
Shuts down the InnoDB database. */
1443 1444 1445 1446 1447 1448

int
innobase_shutdown_for_mysql(void) 
/*=============================*/
				/* out: DB_SUCCESS or error code */
{
unknown's avatar
unknown committed
1449 1450
	ulint   i;

unknown's avatar
unknown committed
1451
        if (!srv_was_started) {
1452 1453 1454 1455 1456
	  	if (srv_is_being_started) {
	    		ut_print_timestamp(stderr);
            		fprintf(stderr, 
	"  InnoDB: Warning: shutting down a not properly started\n");
            		fprintf(stderr, 
unknown's avatar
unknown committed
1457
	"                 InnoDB: or created database!\n");
1458 1459 1460
	  	}

	  	return(DB_SUCCESS);
unknown's avatar
unknown committed
1461 1462
	}

unknown's avatar
unknown committed
1463
	/* 1. Flush buffer pool to disk, write the current lsn to
unknown's avatar
unknown committed
1464 1465 1466
	the tablespace header(s), and copy all log data to archive.
	The step 1 is the real InnoDB shutdown. The remaining steps
	just free data structures after the shutdown. */
1467 1468

	logs_empty_and_mark_files_at_shutdown();
unknown's avatar
Merge  
unknown committed
1469
	
unknown's avatar
unknown committed
1470 1471 1472 1473 1474 1475
	if (srv_conc_n_threads != 0) {
		fprintf(stderr,
		"InnoDB: Warning: query counter shows %ld queries still\n"
		"InnoDB: inside InnoDB at shutdown\n",
		srv_conc_n_threads);
	}
unknown's avatar
unknown committed
1476

unknown's avatar
unknown committed
1477
	/* 2. Make all threads created by InnoDB to exit */
unknown's avatar
unknown committed
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501

	srv_shutdown_state = SRV_SHUTDOWN_EXIT_THREADS;

	/* All threads end up waiting for certain events. Put those events
	to the signaled state. Then the threads will exit themselves in
	os_thread_event_wait(). */

	for (i = 0; i < 1000; i++) {
	        /* NOTE: IF YOU CREATE THREADS IN INNODB, YOU MUST EXIT THEM
	        HERE OR EARLIER */
		
		/* 1. Let the lock timeout thread exit */
		os_event_set(srv_lock_timeout_thread_event);		

		/* 2. srv error monitor thread exits automatically, no need
		to do anything here */

		/* 3. We wake the master thread so that it exits */
		srv_wake_master_thread();

		/* 4. Exit the i/o threads */

		os_aio_wake_all_threads_at_shutdown();

unknown's avatar
unknown committed
1502
		os_mutex_enter(os_sync_mutex);
unknown's avatar
unknown committed
1503 1504 1505 1506 1507 1508 1509 1510

		if (os_thread_count == 0) {
		        /* All the threads have exited or are just exiting;
			NOTE that the threads may not have completed their
			exit yet. Should we use pthread_join() to make sure
			they have exited? Now we just sleep 0.1 seconds and
			hope that is enough! */

unknown's avatar
unknown committed
1511
			os_mutex_exit(os_sync_mutex);
unknown's avatar
unknown committed
1512 1513 1514 1515 1516 1517

			os_thread_sleep(100000);

			break;
		}

unknown's avatar
unknown committed
1518
		os_mutex_exit(os_sync_mutex);
unknown's avatar
unknown committed
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528

		os_thread_sleep(100000);
	}

	if (i == 1000) {
	        fprintf(stderr,
"InnoDB: Warning: %lu threads created by InnoDB had not exited at shutdown!\n",
		      os_thread_count);
	}

1529 1530
	/* 3. Free all InnoDB's own mutexes and the os_fast_mutexes inside
	them */
unknown's avatar
unknown committed
1531 1532 1533

	sync_close();

1534
	/* 4. Free the os_conc_mutex and all os_events and os_mutexes */
unknown's avatar
unknown committed
1535 1536

	srv_free();
unknown's avatar
unknown committed
1537
	os_sync_free();
unknown's avatar
unknown committed
1538

1539
	/* 5. Free all allocated memory and the os_fast_mutex created in
unknown's avatar
unknown committed
1540
	ut0mem.c */
unknown's avatar
unknown committed
1541

unknown's avatar
unknown committed
1542
        ut_free_all_mem();
unknown's avatar
unknown committed
1543

1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554
	if (os_thread_count != 0
	    || os_event_count != 0
	    || os_mutex_count != 0
	    || os_fast_mutex_count != 0) {
	        fprintf(stderr,
"InnoDB: Warning: some resources were not cleaned up in shutdown:\n"
"InnoDB: threads %lu, events %lu, os_mutexes %lu, os_fast_mutexes %lu\n",
		      os_thread_count, os_event_count, os_mutex_count,
		      os_fast_mutex_count);
	}

unknown's avatar
unknown committed
1555 1556 1557 1558
	if (srv_print_verbose_log) {
	        ut_print_timestamp(stderr);
	        fprintf(stderr, "  InnoDB: Shutdown completed\n");
	}
unknown's avatar
unknown committed
1559

1560 1561
	return((int) DB_SUCCESS);
}