开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
srv0start.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：48k
源码类别：

MySQL数据库

开发平台：

Visual C++

srv0start.c：源码内容
  1. /************************************************************************
  2. Starts the InnoDB database server
  4. (c) 1996-2000 Innobase Oy
  6. Created 2/16/1996 Heikki Tuuri
  7. *************************************************************************/
  9. #include "os0proc.h"
  10. #include "sync0sync.h"
  11. #include "ut0mem.h"
  12. #include "mem0mem.h"
  13. #include "mem0pool.h"
  14. #include "data0data.h"
  15. #include "data0type.h"
  16. #include "dict0dict.h"
  17. #include "buf0buf.h"
  18. #include "buf0flu.h"
  19. #include "buf0rea.h"
  20. #include "os0file.h"
  21. #include "os0thread.h"
  22. #include "fil0fil.h"
  23. #include "fsp0fsp.h"
  24. #include "rem0rec.h"
  25. #include "rem0cmp.h"
  26. #include "mtr0mtr.h"
  27. #include "log0log.h"
  28. #include "log0recv.h"
  29. #include "page0page.h"
  30. #include "page0cur.h"
  31. #include "trx0trx.h"
  32. #include "dict0boot.h"
  33. #include "dict0load.h"
  34. #include "trx0sys.h"
  35. #include "dict0crea.h"
  36. #include "btr0btr.h"
  37. #include "btr0pcur.h"
  38. #include "btr0cur.h"
  39. #include "btr0sea.h"
  40. #include "rem0rec.h"
  41. #include "srv0srv.h"
  42. #include "que0que.h"
  43. #include "usr0sess.h"
  44. #include "lock0lock.h"
  45. #include "trx0roll.h"
  46. #include "trx0purge.h"
  47. #include "row0ins.h"
  48. #include "row0sel.h"
  49. #include "row0upd.h"
  50. #include "row0row.h"
  51. #include "row0mysql.h"
  52. #include "lock0lock.h"
  53. #include "ibuf0ibuf.h"
  54. #include "pars0pars.h"
  55. #include "btr0sea.h"
  56. #include "srv0start.h"
  57. #include "que0que.h"
  59. /* Log sequence number immediately after startup */
  60. dulint srv_start_lsn;
  61. /* Log sequence number at shutdown */
  62. dulint srv_shutdown_lsn;
  64. #ifdef HAVE_DARWIN_THREADS
  65. # include <sys/utsname.h>
  66. ibool srv_have_fullfsync = FALSE;
  67. #endif
  69. ibool srv_start_raw_disk_in_use  = FALSE;
  71. static ibool srv_start_has_been_called  = FALSE;
  73. ulint           srv_sizeof_trx_t_in_ha_innodb_cc;
  75. ibool           srv_startup_is_before_trx_rollback_phase = FALSE;
  76. ibool           srv_is_being_started = FALSE;
  77. static ibool srv_was_started      = FALSE;
  79. /* At a shutdown the value first climbs to SRV_SHUTDOWN_CLEANUP
  80. and then to SRV_SHUTDOWN_LAST_PHASE */
  81. ulint srv_shutdown_state = 0;
  83. ibool measure_cont = FALSE;
  85. static os_file_t files[1000];
  87. static mutex_t ios_mutex;
  88. static ulint ios;
  90. static ulint n[SRV_MAX_N_IO_THREADS + 5];
  91. static os_thread_id_t thread_ids[SRV_MAX_N_IO_THREADS + 5];
  93. /* We use this mutex to test the return value of pthread_mutex_trylock
  94.    on successful locking. HP-UX does NOT return 0, though Linux et al do. */
  95. static os_fast_mutex_t srv_os_test_mutex;
  97. /* Name of srv_monitor_file */
  98. static char* srv_monitor_file_name;
  100. #define SRV_N_PENDING_IOS_PER_THREAD  OS_AIO_N_PENDING_IOS_PER_THREAD
  101. #define SRV_MAX_N_PENDING_SYNC_IOS 100
  104. /* Avoid warnings when using purify */
  106. #ifdef HAVE_purify
  107. static int inno_bcmp(register const char *s1, register const char *s2,
  108.                      register uint len)
  109. {
  110.   while (len-- != 0 && *s1++ == *s2++) ;
  111.   return len+1;
  112. }
  113. #define memcmp(A,B,C) inno_bcmp((A),(B),(C))
  114. #endif
  116. /*************************************************************************
  117. Reads the data files and their sizes from a character string given in
  118. the .cnf file. */
  120. ibool
  121. srv_parse_data_file_paths_and_sizes(
  122. /*================================*/
  123. /* out: TRUE if ok, FALSE if parsing
  124. error */
  125. char* str, /* in: the data file path string */
  126. char*** data_file_names, /* out, own: array of data file
  127. names */
  128. ulint** data_file_sizes, /* out, own: array of data file sizes
  129. in megabytes */
  130. ulint** data_file_is_raw_partition,/* out, own: array of flags
  131. showing which data files are raw
  132. partitions */
  133. ulint* n_data_files, /* out: number of data files */
  134. ibool* is_auto_extending, /* out: TRUE if the last data file is
  135. auto-extending */
  136. ulint* max_auto_extend_size) /* out: max auto extend size for the
  137. last file if specified, 0 if not */
  138. {
  139. char* input_str;
  140. char* endp;
  141. char* path;
  142. ulint size;
  143. ulint i = 0;
  145. *is_auto_extending = FALSE;
  146. *max_auto_extend_size = 0;
  148. input_str = str;
  150. /* First calculate the number of data files and check syntax:
  151. path:size[M | G];path:size[M | G]... . Note that a Windows path may
  152. contain a drive name and a ':'. */
  154. while (*str != '') {
  155. path = str;
  157. while ((*str != ':' && *str != '')
  158.        || (*str == ':'
  159.    && (*(str + 1) == '\' || *(str + 1) == '/'
  160.      || *(str + 1) == ':'))) {
  161. str++;
  162. }
  164. if (*str == '') {
  165. return(FALSE);
  166. }
  168. str++;
  170. size = strtoul(str, &endp, 10);
  172. str = endp;
  174. if (*str != 'M' && *str != 'G') {
  175. size = size / (1024 * 1024);
  176. } else if (*str == 'G') {
  177.         size = size * 1024;
  178. str++;
  179. } else {
  180.         str++;
  181. }
  183.         if (0 == memcmp(str, ":autoextend", (sizeof ":autoextend") - 1)) {
  185. str += (sizeof ":autoextend") - 1;
  187.          if (0 == memcmp(str, ":max:", (sizeof ":max:") - 1)) {
  189. str += (sizeof ":max:") - 1;
  191. size = strtoul(str, &endp, 10);
  193. str = endp;
  195. if (*str != 'M' && *str != 'G') {
  196. size = size / (1024 * 1024);
  197. } else if (*str == 'G') {
  198.          size = size * 1024;
  199. str++;
  200. } else {
  201.          str++;
  202. }
  203. }
  205. if (*str != '') {
  207. return(FALSE);
  208. }
  209. }
  211.         if (strlen(str) >= 6
  212.    && *str == 'n'
  213.    && *(str + 1) == 'e' 
  214.            && *(str + 2) == 'w') {
  215.    str += 3;
  216. }
  218.         if (*str == 'r' && *(str + 1) == 'a' && *(str + 2) == 'w') {
  219.    str += 3;
  220. }
  222. if (size == 0) {
  223. return(FALSE);
  224. }
  226. i++;
  228. if (*str == ';') {
  229. str++;
  230. } else if (*str != '') {
  232. return(FALSE);
  233. }
  234. }
  236. *data_file_names = (char**)ut_malloc(i * sizeof(void*));
  237. *data_file_sizes = (ulint*)ut_malloc(i * sizeof(ulint));
  238. *data_file_is_raw_partition = (ulint*)ut_malloc(i * sizeof(ulint));
  240. *n_data_files = i;
  242. /* Then store the actual values to our arrays */
  244. str = input_str;
  245. i = 0;
  247. while (*str != '') {
  248. path = str;
  250. /* Note that we must step over the ':' in a Windows path;
  251. a Windows path normally looks like C:ibdataibdata1:1G, but
  252. a Windows raw partition may have a specification like
  253. \.C::1Gnewraw or \.PHYSICALDRIVE2:1Gnewraw */
  255. while ((*str != ':' && *str != '')
  256.        || (*str == ':'
  257.    && (*(str + 1) == '\' || *(str + 1) == '/'
  258.         || *(str + 1) == ':'))) {
  259. str++;
  260. }
  262. if (*str == ':') {
  263. /* Make path a null-terminated string */
  264. *str = '';
  265. str++;
  266. }
  268. size = strtoul(str, &endp, 10);
  270. str = endp;
  272. if ((*str != 'M') && (*str != 'G')) {
  273. size = size / (1024 * 1024);
  274. } else if (*str == 'G') {
  275.         size = size * 1024;
  276. str++;
  277. } else {
  278.         str++;
  279. }
  281. (*data_file_names)[i] = path;
  282. (*data_file_sizes)[i] = size;
  284.         if (0 == memcmp(str, ":autoextend", (sizeof ":autoextend") - 1)) {
  286. *is_auto_extending = TRUE;
  288. str += (sizeof ":autoextend") - 1;
  290.          if (0 == memcmp(str, ":max:", (sizeof ":max:") - 1)) {
  292. str += (sizeof ":max:") - 1;
  294. size = strtoul(str, &endp, 10);
  296. str = endp;
  298. if (*str != 'M' && *str != 'G') {
  299. size = size / (1024 * 1024);
  300. } else if (*str == 'G') {
  301.          size = size * 1024;
  302. str++;
  303. } else {
  304.          str++;
  305. }
  307. *max_auto_extend_size = size;
  308. }
  310. if (*str != '') {
  312. return(FALSE);
  313. }
  314. }
  316. (*data_file_is_raw_partition)[i] = 0;
  318.         if (strlen(str) >= 6
  319.    && *str == 'n'
  320.    && *(str + 1) == 'e' 
  321.            && *(str + 2) == 'w') {
  322.    str += 3;
  323.    (*data_file_is_raw_partition)[i] = SRV_NEW_RAW;
  324. }
  326. if (*str == 'r' && *(str + 1) == 'a' && *(str + 2) == 'w') {
  327.   str += 3;
  328.   
  329.    if ((*data_file_is_raw_partition)[i] == 0) {
  330.      (*data_file_is_raw_partition)[i] = SRV_OLD_RAW;
  331.    }   
  332. }
  334. i++;
  336. if (*str == ';') {
  337. str++;
  338. }
  339. }
  341. return(TRUE);
  342. }
  344. /*************************************************************************
  345. Reads log group home directories from a character string given in
  346. the .cnf file. */
  348. ibool
  349. srv_parse_log_group_home_dirs(
  350. /*==========================*/
  351. /* out: TRUE if ok, FALSE if parsing
  352. error */
  353. char* str, /* in: character string */
  354. char*** log_group_home_dirs) /* out, own: log group home dirs */
  355. {
  356. char* input_str;
  357. char* path;
  358. ulint i = 0;
  360. input_str = str;
  362. /* First calculate the number of directories and check syntax:
  363. path;path;... */
  365. while (*str != '') {
  366. path = str;
  368. while (*str != ';' && *str != '') {
  369. str++;
  370. }
  372. i++;
  374. if (*str == ';') {
  375. str++;
  376. } else if (*str != '') {
  378. return(FALSE);
  379. }
  380. }
  382. *log_group_home_dirs = (char**) ut_malloc(i * sizeof(void*));
  384. /* Then store the actual values to our array */
  386. str = input_str;
  387. i = 0;
  389. while (*str != '') {
  390. path = str;
  392. while (*str != ';' && *str != '') {
  393. str++;
  394. }
  396. if (*str == ';') {
  397. *str = '';
  398. str++;
  399. }
  401. (*log_group_home_dirs)[i] = path;
  403. i++;
  404. }
  406. return(TRUE);
  407. }
  409. /************************************************************************
  410. I/o-handler thread function. */
  411. static
  413. #ifndef __WIN__
  414. void*
  415. #else
  416. ulint
  417. #endif
  418. io_handler_thread(
  419. /*==============*/
  420. void* arg)
  421. {
  422. ulint segment;
  423. ulint i;
  425. segment = *((ulint*)arg);
  427. #ifdef UNIV_DEBUG_THREAD_CREATION
  428. fprintf(stderr, "Io handler thread %lu starts, id %lun", segment,
  429. os_thread_pf(os_thread_get_curr_id()));
  430. #endif
  431. for (i = 0;; i++) {
  432. fil_aio_wait(segment);
  434. mutex_enter(&ios_mutex);
  435. ios++;
  436. mutex_exit(&ios_mutex);
  437. }
  439. /* We count the number of threads in os_thread_exit(). A created
  440. thread should always use that to exit and not use return() to exit.
  441. The thread actually never comes here because it is exited in an
  442. os_event_wait(). */
  444. os_thread_exit(NULL);
  446. #ifndef __WIN__
  447. return(NULL); /* Not reached */
  448. #else
  449. return(0);
  450. #endif
  451. }
  453. #ifdef __WIN__
  454. #define SRV_PATH_SEPARATOR '\'
  455. #else
  456. #define SRV_PATH_SEPARATOR '/'
  457. #endif
  459. /*************************************************************************
  460. Normalizes a directory path for Windows: converts slashes to backslashes. */
  462. void
  463. srv_normalize_path_for_win(
  464. /*=======================*/
  465. char* str __attribute__((unused))) /* in/out: null-terminated
  466.    character string */
  467. {
  468. #ifdef __WIN__
  469. for (; *str; str++) {
  471. if (*str == '/') {
  472. *str = '\';
  473. }
  474. }
  475. #endif
  476. }
  478. /*************************************************************************
  479. Adds a slash or a backslash to the end of a string if it is missing
  480. and the string is not empty. */
  482. static
  483. char*
  484. srv_add_path_separator_if_needed(
  485. /*=============================*/
  486. /* out: string which has the separator if the
  487. string is not empty */
  488. char* str) /* in: null-terminated character string */
  489. {
  490. char* out_str;
  491. ulint len = ut_strlen(str);
  493. if (len == 0 || str[len - 1] == SRV_PATH_SEPARATOR) {
  495. return(str);
  496. }
  498. out_str = ut_malloc(len + 2);
  499. memcpy(out_str, str, len);
  500. out_str[len] = SRV_PATH_SEPARATOR;
  501. out_str[len + 1] = 0;
  503. return(out_str);
  504. }
  506. /*************************************************************************
  507. Calculates the low 32 bits when a file size which is given as a number
  508. database pages is converted to the number of bytes. */
  509. static
  510. ulint
  511. srv_calc_low32(
  512. /*===========*/
  513. /* out: low 32 bytes of file size when
  514. expressed in bytes */
  515. ulint file_size) /* in: file size in database pages */
  516. {
  517. return(0xFFFFFFFFUL & (file_size << UNIV_PAGE_SIZE_SHIFT));
  518. }
  520. /*************************************************************************
  521. Calculates the high 32 bits when a file size which is given as a number
  522. database pages is converted to the number of bytes. */
  523. static
  524. ulint
  525. srv_calc_high32(
  526. /*============*/
  527. /* out: high 32 bytes of file size when
  528. expressed in bytes */
  529. ulint file_size) /* in: file size in database pages */
  530. {
  531. return(file_size >> (32 - UNIV_PAGE_SIZE_SHIFT));
  532. }
  534. /*************************************************************************
  535. Creates or opens the log files and closes them. */
  536. static
  537. ulint
  538. open_or_create_log_file(
  539. /*====================*/
  540. /* out: DB_SUCCESS or error code */
  541.         ibool   create_new_db,          /* in: TRUE if we should create a
  542.                                         new database */
  543. ibool* log_file_created, /* out: TRUE if new log file
  544. created */
  545. ibool log_file_has_been_opened,/* in: TRUE if a log file has been
  546. opened before: then it is an error
  547. to try to create another log file */
  548. ulint k, /* in: log group number */
  549. ulint i) /* in: log file number in group */
  550. {
  551. ibool ret;
  552. ulint size;
  553. ulint size_high;
  554. char name[10000];
  556. UT_NOT_USED(create_new_db);
  558. *log_file_created = FALSE;
  560. srv_normalize_path_for_win(srv_log_group_home_dirs[k]);
  561. srv_log_group_home_dirs[k] = srv_add_path_separator_if_needed(
  562. srv_log_group_home_dirs[k]);
  564. ut_a(strlen(srv_log_group_home_dirs[k]) <
  565. (sizeof name) - 10 - sizeof "ib_logfile");
  566. sprintf(name, "%s%s%lu", srv_log_group_home_dirs[k], "ib_logfile", (ulong) i);
  568. files[i] = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL,
  569. OS_LOG_FILE, &ret);
  570. if (ret == FALSE) {
  571. if (os_file_get_last_error(FALSE) != OS_FILE_ALREADY_EXISTS
  572. #ifdef UNIV_AIX
  573.     /* AIX 5.1 after security patch ML7 may have errno set
  574. to 0 here, which causes our function to return 100;
  575. work around that AIX problem */
  576.    && os_file_get_last_error(FALSE) != 100
  577. #endif
  578. ) {
  579. fprintf(stderr,
  580. "InnoDB: Error in creating or opening %sn", name);
  582. return(DB_ERROR);
  583. }
  585. files[i] = os_file_create(name, OS_FILE_OPEN, OS_FILE_AIO,
  586. OS_LOG_FILE, &ret);
  587. if (!ret) {
  588. fprintf(stderr,
  589. "InnoDB: Error in opening %sn", name);
  591. return(DB_ERROR);
  592. }
  594. ret = os_file_get_size(files[i], &size, &size_high);
  595. ut_a(ret);
  597. if (size != srv_calc_low32(srv_log_file_size)
  598.     || size_high != srv_calc_high32(srv_log_file_size)) {
  599.     
  600. fprintf(stderr,
  601. "InnoDB: Error: log file %s is of different size %lu %lu bytesn"
  602. "InnoDB: than specified in the .cnf file %lu %lu bytes!n",
  603. name, (ulong) size_high, (ulong) size,
  604. (ulong) srv_calc_high32(srv_log_file_size),
  605. (ulong) srv_calc_low32(srv_log_file_size));
  607. return(DB_ERROR);
  608. }
  609. } else {
  610. *log_file_created = TRUE;
  612.      ut_print_timestamp(stderr);
  614. fprintf(stderr,
  615. "  InnoDB: Log file %s did not exist: new to be createdn",
  616. name);
  617. if (log_file_has_been_opened) {
  619. return(DB_ERROR);
  620. }
  622. fprintf(stderr, "InnoDB: Setting log file %s size to %lu MBn",
  623.              name, (ulong) srv_log_file_size
  624. >> (20 - UNIV_PAGE_SIZE_SHIFT));
  626. fprintf(stderr,
  627.     "InnoDB: Database physically writes the file full: wait...n");
  629. ret = os_file_set_size(name, files[i],
  630. srv_calc_low32(srv_log_file_size),
  631. srv_calc_high32(srv_log_file_size));
  632. if (!ret) {
  633. fprintf(stderr,
  634. "InnoDB: Error in creating %s: probably out of disk spacen",
  635. name);
  637. return(DB_ERROR);
  638. }
  639. }
  641. ret = os_file_close(files[i]);
  642. ut_a(ret);
  644. if (i == 0) {
  645. /* Create in memory the file space object
  646. which is for this log group */
  648. fil_space_create(name,
  649. 2 * k + SRV_LOG_SPACE_FIRST_ID, FIL_LOG);
  650. }
  652. ut_a(fil_validate());
  654. fil_node_create(name, srv_log_file_size,
  655. 2 * k + SRV_LOG_SPACE_FIRST_ID, FALSE);
  656. #ifdef UNIV_LOG_ARCHIVE
  657. /* If this is the first log group, create the file space object
  658. for archived logs.
  659. Under MySQL, no archiving ever done. */
  661. if (k == 0 && i == 0) {
  662. arch_space_id = 2 * k + 1 + SRV_LOG_SPACE_FIRST_ID;
  664.      fil_space_create("arch_log_space", arch_space_id, FIL_LOG);
  665. } else {
  666. arch_space_id = ULINT_UNDEFINED;
  667. }
  668. #endif /* UNIV_LOG_ARCHIVE */
  669. if (i == 0) {
  670. log_group_init(k, srv_n_log_files,
  671. srv_log_file_size * UNIV_PAGE_SIZE,
  672. 2 * k + SRV_LOG_SPACE_FIRST_ID,
  673. SRV_LOG_SPACE_FIRST_ID + 1); /* dummy arch
  674. space id */
  675. }
  677. return(DB_SUCCESS);
  678. }
  680. /*************************************************************************
  681. Creates or opens database data files and closes them. */
  682. static
  683. ulint
  684. open_or_create_data_files(
  685. /*======================*/
  686. /* out: DB_SUCCESS or error code */
  687. ibool* create_new_db, /* out: TRUE if new database should be
  688. created */
  689. #ifdef UNIV_LOG_ARCHIVE
  690. ulint* min_arch_log_no,/* out: min of archived log numbers in data
  691. files */
  692. ulint* max_arch_log_no,/* out: */
  693. #endif /* UNIV_LOG_ARCHIVE */
  694. dulint* min_flushed_lsn,/* out: min of flushed lsn values in data
  695. files */
  696. dulint* max_flushed_lsn,/* out: */
  697. ulint* sum_of_new_sizes)/* out: sum of sizes of the new files added */
  698. {
  699. ibool ret;
  700. ulint i;
  701. ibool one_opened = FALSE;
  702. ibool one_created = FALSE;
  703. ulint size;
  704. ulint size_high;
  705. ulint rounded_size_pages;
  706. char name[10000];
  708. if (srv_n_data_files >= 1000) {
  709. fprintf(stderr, "InnoDB: can only have < 1000 data filesn"
  710. "InnoDB: you have defined %lun",
  711. (ulong) srv_n_data_files);
  712. return(DB_ERROR);
  713. }
  715. *sum_of_new_sizes = 0;
  717. *create_new_db = FALSE;
  719. srv_normalize_path_for_win(srv_data_home);
  720. srv_data_home = srv_add_path_separator_if_needed(srv_data_home);
  722. for (i = 0; i < srv_n_data_files; i++) {
  723. srv_normalize_path_for_win(srv_data_file_names[i]);
  725. ut_a(strlen(srv_data_home) + strlen(srv_data_file_names[i])
  726. < (sizeof name) - 1);
  727. sprintf(name, "%s%s", srv_data_home, srv_data_file_names[i]);
  729. if (srv_data_file_is_raw_partition[i] == 0) {
  731. /* First we try to create the file: if it already
  732. exists, ret will get value FALSE */
  734. files[i] = os_file_create(name, OS_FILE_CREATE,
  735. OS_FILE_NORMAL, OS_DATA_FILE, &ret);
  737. if (ret == FALSE && os_file_get_last_error(FALSE) !=
  738. OS_FILE_ALREADY_EXISTS
  739. #ifdef UNIV_AIX
  740.     /* AIX 5.1 after security patch ML7 may have
  741. errno set to 0 here, which causes our function
  742. to return 100; work around that AIX problem */
  743.         && os_file_get_last_error(FALSE) != 100
  744. #endif
  745. ) {
  746. fprintf(stderr,
  747. "InnoDB: Error in creating or opening %sn",
  748. name);
  750. return(DB_ERROR);
  751. }
  752. } else if (srv_data_file_is_raw_partition[i] == SRV_NEW_RAW) {
  753. /* The partition is opened, not created; then it is
  754. written over */
  756. srv_start_raw_disk_in_use = TRUE;
  757. srv_created_new_raw = TRUE;
  759. files[i] = os_file_create(
  760. name, OS_FILE_OPEN_RAW, OS_FILE_NORMAL,
  761. OS_DATA_FILE, &ret);
  762. if (!ret) {
  763. fprintf(stderr,
  764. "InnoDB: Error in opening %sn", name);
  766. return(DB_ERROR);
  767. }
  768. } else if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
  769. srv_start_raw_disk_in_use = TRUE;
  771. ret = FALSE;
  772. } else {
  773. ut_a(0);
  774. }
  776. if (ret == FALSE) {
  777. /* We open the data file */
  779. if (one_created) {
  780. fprintf(stderr,
  781. "InnoDB: Error: data files can only be added at the endn");
  782. fprintf(stderr,
  783. "InnoDB: of a tablespace, but data file %s existed beforehand.n",
  784. name);
  785. return(DB_ERROR);
  786. }
  788. if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
  789. files[i] = os_file_create(
  790. name, OS_FILE_OPEN_RAW, OS_FILE_NORMAL,
  791.  OS_DATA_FILE, &ret);
  792. } else if (i == 0) {
  793. files[i] = os_file_create(
  794. name, OS_FILE_OPEN_RETRY,
  795. OS_FILE_NORMAL,
  796. OS_DATA_FILE, &ret);
  797. } else {
  798. files[i] = os_file_create(
  799. name, OS_FILE_OPEN, OS_FILE_NORMAL,
  800.  OS_DATA_FILE, &ret);
  801. }
  803. if (!ret) {
  804. fprintf(stderr,
  805. "InnoDB: Error in opening %sn", name);
  806. os_file_get_last_error(TRUE);
  808. return(DB_ERROR);
  809. }
  811. if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
  813. goto skip_size_check;
  814. }
  816. ret = os_file_get_size(files[i], &size, &size_high);
  817. ut_a(ret);
  818. /* Round size downward to megabytes */
  820. rounded_size_pages = (size / (1024 * 1024)
  821. + 4096 * size_high)
  822.      << (20 - UNIV_PAGE_SIZE_SHIFT);
  824. if (i == srv_n_data_files - 1
  825.     && srv_auto_extend_last_data_file) {
  827. if (srv_data_file_sizes[i] >
  828.      rounded_size_pages
  829.         || (srv_last_file_size_max > 0
  830.            && srv_last_file_size_max <
  831.             rounded_size_pages)) {
  832.             
  833. fprintf(stderr,
  834. "InnoDB: Error: auto-extending data file %s is of a different sizen"
  835. "InnoDB: %lu pages (rounded down to MB) than specified in the .cnf file:n"
  836. "InnoDB: initial %lu pages, max %lu (relevant if non-zero) pages!n",
  837.   name, (ulong) rounded_size_pages,
  838.   (ulong) srv_data_file_sizes[i],
  839.   (ulong) srv_last_file_size_max);
  841. return(DB_ERROR);
  842. }
  843.           
  844. srv_data_file_sizes[i] = rounded_size_pages;
  845. }
  847. if (rounded_size_pages != srv_data_file_sizes[i]) {
  849. fprintf(stderr,
  850. "InnoDB: Error: data file %s is of a different sizen"
  851. "InnoDB: %lu pages (rounded down to MB)n"
  852. "InnoDB: than specified in the .cnf file %lu pages!n", name,
  853.        (ulong) rounded_size_pages,
  854.        (ulong) srv_data_file_sizes[i]);
  856. return(DB_ERROR);
  857. }
  858. skip_size_check:
  859. fil_read_flushed_lsn_and_arch_log_no(files[i],
  860. one_opened,
  861. #ifdef UNIV_LOG_ARCHIVE
  862. min_arch_log_no, max_arch_log_no,
  863. #endif /* UNIV_LOG_ARCHIVE */
  864. min_flushed_lsn, max_flushed_lsn);
  865. one_opened = TRUE;
  866. } else {
  867.         /* We created the data file and now write it full of
  868. zeros */
  870. one_created = TRUE;
  872. if (i > 0) {
  873.      ut_print_timestamp(stderr);
  874. fprintf(stderr, 
  875. "  InnoDB: Data file %s did not exist: new to be createdn",
  876. name);
  877. } else {
  878. fprintf(stderr, 
  879.   "InnoDB: The first specified data file %s did not exist:n"
  880. "InnoDB: a new database to be created!n", name);
  881. *create_new_db = TRUE;
  882. }
  884.      ut_print_timestamp(stderr);
  885. fprintf(stderr, 
  886. "  InnoDB: Setting file %s size to %lu MBn",
  887.        name, (ulong) (srv_data_file_sizes[i]
  888.       >> (20 - UNIV_PAGE_SIZE_SHIFT)));
  890. fprintf(stderr,
  891. "InnoDB: Database physically writes the file full: wait...n");
  893. ret = os_file_set_size(name, files[i],
  894. srv_calc_low32(srv_data_file_sizes[i]),
  895. srv_calc_high32(srv_data_file_sizes[i]));
  897. if (!ret) {
  898. fprintf(stderr, 
  899. "InnoDB: Error in creating %s: probably out of disk spacen", name);
  901. return(DB_ERROR);
  902. }
  904. *sum_of_new_sizes = *sum_of_new_sizes
  905. + srv_data_file_sizes[i];
  906. }
  908. ret = os_file_close(files[i]);
  909. ut_a(ret);
  911. if (i == 0) {
  912. fil_space_create(name, 0, FIL_TABLESPACE);
  913. }
  915. ut_a(fil_validate());
  917. if (srv_data_file_is_raw_partition[i]) {
  919.         fil_node_create(name, srv_data_file_sizes[i], 0, TRUE);
  920. } else {
  921.         fil_node_create(name, srv_data_file_sizes[i], 0,
  922. FALSE);
  923. }
  924. }
  926. ios = 0;
  928. mutex_create(&ios_mutex);
  929. mutex_set_level(&ios_mutex, SYNC_NO_ORDER_CHECK);
  931. return(DB_SUCCESS);
  932. }
  934. /********************************************************************
  935. Starts InnoDB and creates a new database if database files
  936. are not found and the user wants. Server parameters are
  937. read from a file of name "srv_init" in the ib_home directory. */
  939. int
  940. innobase_start_or_create_for_mysql(void)
  941. /*====================================*/
  942. /* out: DB_SUCCESS or error code */
  943. {
  944. buf_pool_t* ret;
  945. ibool create_new_db;
  946. ibool log_file_created;
  947. ibool log_created = FALSE;
  948. ibool log_opened = FALSE;
  949. dulint min_flushed_lsn;
  950. dulint max_flushed_lsn;
  951. #ifdef UNIV_LOG_ARCHIVE
  952. ulint min_arch_log_no;
  953. ulint max_arch_log_no;
  954. #endif /* UNIV_LOG_ARCHIVE */
  955. ulint   sum_of_new_sizes;
  956. ulint sum_of_data_file_sizes;
  957. ulint tablespace_size_in_header;
  958. ulint err;
  959. ulint i;
  960. ibool srv_file_per_table_original_value  = srv_file_per_table;
  961. mtr_t   mtr;
  962. #ifdef HAVE_DARWIN_THREADS
  963. # ifdef F_FULLFSYNC
  964. /* This executable has been compiled on Mac OS X 10.3 or later.
  965. Assume that F_FULLFSYNC is available at run-time. */
  966. srv_have_fullfsync = TRUE;
  967. # else /* F_FULLFSYNC */
  968. /* This executable has been compiled on Mac OS X 10.2
  969. or earlier.  Determine if the executable is running
  970. on Mac OS X 10.3 or later. */
  971. struct utsname utsname;
  972. if (uname(&utsname)) {
  973. fputs("InnoDB: cannot determine Mac OS X version!n", stderr);
  974. } else {
  975. srv_have_fullfsync = strcmp(utsname.release, "7.") >= 0;
  976. }
  977. if (!srv_have_fullfsync) {
  978. fputs(
  979. "InnoDB: On Mac OS X, fsync() may be broken on internal drives,n"
  980. "InnoDB: making transactions unsafe!n", stderr);
  981. }
  982. # endif /* F_FULLFSYNC */
  983. #endif /* HAVE_DARWIN_THREADS */
  985. if (sizeof(ulint) != sizeof(void*)) {
  986. fprintf(stderr,
  987. "InnoDB: Error: size of InnoDB's ulint is %lu, but size of void* is %lu.n"
  988. "InnoDB: The sizes should be the same so that on a 64-bit platform you cann"
  989. "InnoDB: allocate more than 4 GB of memory.",
  990. (ulong)sizeof(ulint), (ulong)sizeof(void*));
  991. }
  993. srv_file_per_table = FALSE; /* system tables are created in tablespace
  994. 0 */
  995. #ifdef UNIV_DEBUG
  996. fprintf(stderr,
  997. "InnoDB: !!!!!!!!!!!!!! UNIV_DEBUG switched on !!!!!!!!!!!!!!!n"); 
  998. #endif
  1000. #ifdef UNIV_SYNC_DEBUG
  1001. fprintf(stderr,
  1002. "InnoDB: !!!!!!!!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!!!!!!!n"); 
  1003. #endif
  1005. #ifdef UNIV_SEARCH_DEBUG
  1006. fprintf(stderr,
  1007. "InnoDB: !!!!!!!!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!!!!!!!n"); 
  1008. #endif
  1010. #ifdef UNIV_MEM_DEBUG
  1011. fprintf(stderr,
  1012. "InnoDB: !!!!!!!!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!!!!!!!n"); 
  1013. #endif
  1015. #ifdef UNIV_SIMULATE_AWE
  1016. fprintf(stderr,
  1017. "InnoDB: !!!!!!!!!!!!!! UNIV_SIMULATE_AWE switched on !!!!!!!!!!!!!!!!!n");
  1018. #endif
  1019.         if (srv_sizeof_trx_t_in_ha_innodb_cc != (ulint)sizeof(trx_t)) {
  1020.         fprintf(stderr,
  1021.   "InnoDB: Error: trx_t size is %lu in ha_innodb.cc but %lu in srv0start.cn"
  1022.   "InnoDB: Check that pthread_mutex_t is defined in the same way in thesen"
  1023.   "InnoDB: compilation modules. Cannot continue.n",
  1024.  (ulong)  srv_sizeof_trx_t_in_ha_innodb_cc,
  1025.  (ulong) sizeof(trx_t));
  1026. return(DB_ERROR);
  1027. }
  1029. /* Since InnoDB does not currently clean up all its internal data
  1030.    structures in MySQL Embedded Server Library server_end(), we
  1031.    print an error message if someone tries to start up InnoDB a
  1032.    second time during the process lifetime. */
  1034. if (srv_start_has_been_called) {
  1035.         fprintf(stderr,
  1036. "InnoDB: Error:startup called second time during the process lifetime.n"
  1037. "InnoDB: In the MySQL Embedded Server Library you cannot call server_init()n"
  1038. "InnoDB: more than once during the process lifetime.n");
  1039. }
  1041. srv_start_has_been_called = TRUE;
  1043. log_do_write = TRUE;
  1044. /* yydebug = TRUE; */
  1046. srv_is_being_started = TRUE;
  1047.         srv_startup_is_before_trx_rollback_phase = TRUE;
  1048. os_aio_use_native_aio = FALSE;
  1050. #if !defined(__WIN2000__) && !defined(UNIV_SIMULATE_AWE)
  1051. if (srv_use_awe) {
  1053.         fprintf(stderr,
  1054. "InnoDB: Error: You have specified innodb_buffer_pool_awe_mem_mbn"
  1055. "InnoDB: in my.cnf, but AWE can only be used in Windows 2000 and later.n"
  1056. "InnoDB: To use AWE, InnoDB must be compiled with __WIN2000__ defined.n");
  1058.         return(DB_ERROR);
  1059. }
  1060. #endif
  1062. #ifdef __WIN__
  1063. if (os_get_os_version() == OS_WIN95
  1064.     || os_get_os_version() == OS_WIN31
  1065.     || os_get_os_version() == OS_WINNT) {
  1067.    /* On Win 95, 98, ME, Win32 subsystem for Windows 3.1,
  1068. and NT use simulated aio. In NT Windows provides async i/o,
  1069. but when run in conjunction with InnoDB Hot Backup, it seemed
  1070. to corrupt the data files. */
  1072.    os_aio_use_native_aio = FALSE;
  1073. } else {
  1074.    /* On Win 2000 and XP use async i/o */
  1075.    os_aio_use_native_aio = TRUE;
  1076. }
  1077. #endif
  1078.         if (srv_file_flush_method_str == NULL) {
  1079.          /* These are the default options */
  1081. srv_unix_file_flush_method = SRV_UNIX_FDATASYNC;
  1083. srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
  1084. #ifndef __WIN__        
  1085. } else if (0 == ut_strcmp(srv_file_flush_method_str, "fdatasync")) {
  1086.    srv_unix_file_flush_method = SRV_UNIX_FDATASYNC;
  1088. } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DSYNC")) {
  1089.    srv_unix_file_flush_method = SRV_UNIX_O_DSYNC;
  1091. } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DIRECT")) {
  1092.    srv_unix_file_flush_method = SRV_UNIX_O_DIRECT;
  1094. } else if (0 == ut_strcmp(srv_file_flush_method_str, "littlesync")) {
  1095.    srv_unix_file_flush_method = SRV_UNIX_LITTLESYNC;
  1097. } else if (0 == ut_strcmp(srv_file_flush_method_str, "nosync")) {
  1098.    srv_unix_file_flush_method = SRV_UNIX_NOSYNC;
  1099. #else
  1100. } else if (0 == ut_strcmp(srv_file_flush_method_str, "normal")) {
  1101.    srv_win_file_flush_method = SRV_WIN_IO_NORMAL;
  1102.    os_aio_use_native_aio = FALSE;
  1104. } else if (0 == ut_strcmp(srv_file_flush_method_str, "unbuffered")) {
  1105.    srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
  1106.    os_aio_use_native_aio = FALSE;
  1108. } else if (0 == ut_strcmp(srv_file_flush_method_str,
  1109. "async_unbuffered")) {
  1110.    srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
  1111. #endif
  1112. } else {
  1113.    fprintf(stderr, 
  1114.            "InnoDB: Unrecognized value %s for innodb_flush_methodn",
  1115.            srv_file_flush_method_str);
  1116.    return(DB_ERROR);
  1117. }
  1119. /* Note that the call srv_boot() also changes the values of
  1120. srv_pool_size etc. to the units used by InnoDB internally */
  1122.         /* Set the maximum number of threads which can wait for a semaphore
  1123.         inside InnoDB: this is the 'sync wait array' size, as well as the
  1124. maximum number of threads that can wait in the 'srv_conc array' for
  1125. their time to enter InnoDB. */
  1127. #if defined(__WIN__) || defined(__NETWARE__)
  1129. /* Create less event semaphores because Win 98/ME had difficulty creating
  1130. 40000 event semaphores.
  1131. Comment from Novell, Inc.: also, these just take a lot of memory on
  1132. NetWare. */
  1133.         srv_max_n_threads = 1000;
  1134. #else
  1135.         if (srv_pool_size >= 1000 * 1024) {
  1136.                                   /* Here we still have srv_pool_size counted
  1137.                                   in kilobytes (in 4.0 this was in bytes)
  1138.   srv_boot() converts the value to
  1139.                                   pages; if buffer pool is less than 1000 MB,
  1140.                                   assume fewer threads. */
  1141.                 srv_max_n_threads = 50000;
  1143.         } else if (srv_pool_size >= 8 * 1024) {
  1145.                 srv_max_n_threads = 10000;
  1146.         } else {
  1147. srv_max_n_threads = 1000;       /* saves several MB of memory,
  1148.                                                 especially in 64-bit
  1149.                                                 computers */
  1150.         }
  1151. #endif
  1152. err = srv_boot(); /* This changes srv_pool_size to units of a page */
  1154. if (err != DB_SUCCESS) {
  1156. return((int) err);
  1157. }
  1159. mutex_create(&srv_monitor_file_mutex);
  1160. mutex_set_level(&srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);
  1161. if (srv_innodb_status) {
  1162. srv_monitor_file_name = mem_alloc(
  1163. strlen(fil_path_to_mysql_datadir) +
  1164. 20 + sizeof "/innodb_status.");
  1165. sprintf(srv_monitor_file_name, "%s/innodb_status.%lu",
  1166. fil_path_to_mysql_datadir, os_proc_get_number());
  1167. srv_monitor_file = fopen(srv_monitor_file_name, "w+");
  1168. if (!srv_monitor_file) {
  1169. fprintf(stderr, "InnoDB: unable to create %s: %sn",
  1170. srv_monitor_file_name, strerror(errno));
  1171. return(DB_ERROR);
  1172. }
  1173. } else {
  1174. srv_monitor_file_name = NULL;
  1175. srv_monitor_file = os_file_create_tmpfile();
  1176. if (!srv_monitor_file) {
  1177. return(DB_ERROR);
  1178. }
  1179. }
  1181. /* Restrict the maximum number of file i/o threads */
  1182. if (srv_n_file_io_threads > SRV_MAX_N_IO_THREADS) {
  1184. srv_n_file_io_threads = SRV_MAX_N_IO_THREADS;
  1185. }
  1187. if (!os_aio_use_native_aio) {
  1188.   /* In simulated aio we currently have use only for 4 threads */
  1189. srv_n_file_io_threads = 4;
  1191. os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD
  1192. * srv_n_file_io_threads,
  1193. srv_n_file_io_threads,
  1194. SRV_MAX_N_PENDING_SYNC_IOS);
  1195. } else {
  1196. os_aio_init(SRV_N_PENDING_IOS_PER_THREAD
  1197. * srv_n_file_io_threads,
  1198. srv_n_file_io_threads,
  1199. SRV_MAX_N_PENDING_SYNC_IOS);
  1200. }
  1202. fil_init(srv_max_n_open_files);
  1204. if (srv_use_awe) {
  1205. fprintf(stderr,
  1206. "InnoDB: Using AWE: Memory window is %lu MB and AWE memory is %lu MBn",
  1207. (ulong) (srv_awe_window_size / ((1024 * 1024) / UNIV_PAGE_SIZE)),
  1208. (ulong) (srv_pool_size / ((1024 * 1024) / UNIV_PAGE_SIZE)));
  1210. /* We must disable adaptive hash indexes because they do not
  1211. tolerate remapping of pages in AWE */
  1213. srv_use_adaptive_hash_indexes = FALSE;
  1214. ret = buf_pool_init(srv_pool_size, srv_pool_size,
  1215. srv_awe_window_size);
  1216. } else {
  1217. ret = buf_pool_init(srv_pool_size, srv_pool_size,
  1218. srv_pool_size);
  1219. }
  1221. if (ret == NULL) {
  1222. fprintf(stderr,
  1223. "InnoDB: Fatal error: cannot allocate the memory for the buffer pooln");
  1225. return(DB_ERROR);
  1226. }
  1228. fsp_init();
  1229. log_init();
  1231. lock_sys_create(srv_lock_table_size);
  1233. /* Create i/o-handler threads: */
  1235. for (i = 0; i < srv_n_file_io_threads; i++) {
  1236. n[i] = i;
  1238. os_thread_create(io_handler_thread, n + i, thread_ids + i);
  1239.      }
  1241. #ifdef UNIV_LOG_ARCHIVE
  1242. if (0 != ut_strcmp(srv_log_group_home_dirs[0], srv_arch_dir)) {
  1243. fprintf(stderr,
  1244. "InnoDB: Error: you must set the log group home dir in my.cnf then"
  1245. "InnoDB: same as log arch dir.n");
  1247. return(DB_ERROR);
  1248. }
  1249. #endif /* UNIV_LOG_ARCHIVE */
  1251. if (srv_n_log_files * srv_log_file_size >= 262144) {
  1252. fprintf(stderr,
  1253. "InnoDB: Error: combined size of log files must be < 4 GBn");
  1255. return(DB_ERROR);
  1256. }
  1258. sum_of_new_sizes = 0;
  1260. for (i = 0; i < srv_n_data_files; i++) {
  1261. #ifndef __WIN__
  1262. if (sizeof(off_t) < 5 && srv_data_file_sizes[i] >= 262144) {
  1263.   fprintf(stderr,
  1264. "InnoDB: Error: file size must be < 4 GB with this MySQL binaryn"
  1265. "InnoDB: and operating system combination, in some OS's < 2 GBn");
  1267.    return(DB_ERROR);
  1268. }
  1269. #endif
  1270. sum_of_new_sizes += srv_data_file_sizes[i];
  1271. }
  1273. if (sum_of_new_sizes < 640) {
  1274.   fprintf(stderr,
  1275.   "InnoDB: Error: tablespace size must be at least 10 MBn");
  1277.   return(DB_ERROR);
  1278. }
  1280. err = open_or_create_data_files(&create_new_db,
  1281. #ifdef UNIV_LOG_ARCHIVE
  1282. &min_arch_log_no, &max_arch_log_no,
  1283. #endif /* UNIV_LOG_ARCHIVE */
  1284. &min_flushed_lsn, &max_flushed_lsn,
  1285. &sum_of_new_sizes);
  1286. if (err != DB_SUCCESS) {
  1287.         fprintf(stderr,
  1288. "InnoDB: Could not open or create data files.n"
  1289. "InnoDB: If you tried to add new data files, and it failed here,n"
  1290. "InnoDB: you should now edit innodb_data_file_path in my.cnf backn"
  1291. "InnoDB: to what it was, and remove the new ibdata files InnoDB createdn"
  1292. "InnoDB: in this failed attempt. InnoDB only wrote those files full ofn"
  1293. "InnoDB: zeros, but did not yet use them in any way. But be careful: do notn"
  1294. "InnoDB: remove old data files which contain your precious data!n");
  1296. return((int) err);
  1297. }
  1299. #ifdef UNIV_LOG_ARCHIVE
  1300. srv_normalize_path_for_win(srv_arch_dir);
  1301. srv_arch_dir = srv_add_path_separator_if_needed(srv_arch_dir);
  1302. #endif /* UNIV_LOG_ARCHIVE */
  1304. for (i = 0; i < srv_n_log_files; i++) {
  1305. err = open_or_create_log_file(create_new_db, &log_file_created,
  1306.      log_opened, 0, i);
  1307. if (err != DB_SUCCESS) {
  1309. return((int) err);
  1310. }
  1312. if (log_file_created) {
  1313. log_created = TRUE;
  1314. } else {
  1315. log_opened = TRUE;
  1316. }
  1317. if ((log_opened && create_new_db)
  1318.      || (log_opened && log_created)) {
  1319. fprintf(stderr, 
  1320. "InnoDB: Error: all log files must be created at the same time.n"
  1321. "InnoDB: All log files must be created also in database creation.n"
  1322. "InnoDB: If you want bigger or smaller log files, shut down then"
  1323. "InnoDB: database and make sure there were no errors in shutdown.n"
  1324. "InnoDB: Then delete the existing log files. Edit the .cnf filen"
  1325. "InnoDB: and start the database again.n");
  1327. return(DB_ERROR);
  1328. }
  1329. }
  1331. /* Open all log files and data files in the system tablespace: we
  1332. keep them open until database shutdown */
  1334. fil_open_log_and_system_tablespace_files();
  1336. if (log_created && !create_new_db
  1337. #ifdef UNIV_LOG_ARCHIVE
  1338. && !srv_archive_recovery
  1339. #endif /* UNIV_LOG_ARCHIVE */
  1340. ) {
  1341. if (ut_dulint_cmp(max_flushed_lsn, min_flushed_lsn) != 0
  1342. #ifdef UNIV_LOG_ARCHIVE
  1343. || max_arch_log_no != min_arch_log_no
  1344. #endif /* UNIV_LOG_ARCHIVE */
  1345. ) {
  1346. fprintf(stderr, 
  1347. "InnoDB: Cannot initialize created log files becausen"
  1348. "InnoDB: data files were not in sync with each othern"
  1349. "InnoDB: or the data files are corrupt.n");
  1351. return(DB_ERROR);
  1352. }
  1354. if (ut_dulint_cmp(max_flushed_lsn, ut_dulint_create(0, 1000))
  1355.     < 0) {
  1356.      fprintf(stderr,
  1357. "InnoDB: Cannot initialize created log files becausen"
  1358. "InnoDB: data files are corrupt, or new data files weren"
  1359. "InnoDB: created when the database was started previousn"
  1360. "InnoDB: time but the database was not shut downn"
  1361. "InnoDB: normally after that.n");
  1363. return(DB_ERROR);
  1364. }
  1366. mutex_enter(&(log_sys->mutex));
  1368. #ifdef UNIV_LOG_ARCHIVE
  1369. /* Do not + 1 arch_log_no because we do not use log
  1370. archiving */
  1371. recv_reset_logs(max_flushed_lsn, max_arch_log_no, TRUE);
  1372. #else
  1373. recv_reset_logs(max_flushed_lsn, TRUE);
  1374. #endif /* UNIV_LOG_ARCHIVE */
  1376. mutex_exit(&(log_sys->mutex));
  1377. }
  1379. if (create_new_db) {
  1380. mtr_start(&mtr);
  1382. fsp_header_init(0, sum_of_new_sizes, &mtr);
  1384. mtr_commit(&mtr);
  1386. trx_sys_create();
  1387. dict_create();
  1388.                 srv_startup_is_before_trx_rollback_phase = FALSE;
  1390. #ifdef UNIV_LOG_ARCHIVE
  1391. } else if (srv_archive_recovery) {
  1392. fprintf(stderr,
  1393. "InnoDB: Starting archive recovery from a backup...n");
  1394. err = recv_recovery_from_archive_start(
  1395. min_flushed_lsn,
  1396. srv_archive_recovery_limit_lsn,
  1397. min_arch_log_no);
  1398. if (err != DB_SUCCESS) {
  1400. return(DB_ERROR);
  1401. }
  1402. /* Since ibuf init is in dict_boot, and ibuf is needed
  1403. in any disk i/o, first call dict_boot */
  1405. dict_boot();
  1406. trx_sys_init_at_db_start();
  1407.                 srv_startup_is_before_trx_rollback_phase = FALSE;
  1409. /* Initialize the fsp free limit global variable in the log
  1410. system */
  1411. fsp_header_get_free_limit(0);
  1413. recv_recovery_from_archive_finish();
  1414. #endif /* UNIV_LOG_ARCHIVE */
  1415. } else {
  1416. /* We always try to do a recovery, even if the database had
  1417. been shut down normally: this is the normal startup path */
  1419. err = recv_recovery_from_checkpoint_start(LOG_CHECKPOINT,
  1420. ut_dulint_max,
  1421. min_flushed_lsn,
  1422. max_flushed_lsn);
  1423. if (err != DB_SUCCESS) {
  1425. return(DB_ERROR);
  1426. }
  1428. /* Since the insert buffer init is in dict_boot, and the
  1429. insert buffer is needed in any disk i/o, first we call
  1430. dict_boot(). Note that trx_sys_init_at_db_start() only needs
  1431. to access space 0, and the insert buffer at this stage already
  1432. works for space 0. */
  1434. dict_boot();
  1435. trx_sys_init_at_db_start();
  1437. if (srv_force_recovery < SRV_FORCE_NO_IBUF_MERGE) {
  1438. /* The following call is necessary for the insert
  1439. buffer to work with multiple tablespaces. We must
  1440. know the mapping between space id's and .ibd file
  1441. names.
  1443. In a crash recovery, we check that the info in data
  1444. dictionary is consistent with what we already know
  1445. about space id's from the call of
  1446. fil_load_single_table_tablespaces().
  1448. In a normal startup, we create the space objects for
  1449. every table in the InnoDB data dictionary that has
  1450. an .ibd file.
  1452. We also determine the maximum tablespace id used.
  1454. TODO: We may have incomplete transactions in the
  1455. data dictionary tables. Does that harm the scanning of
  1456. the data dictionary below? */
  1458. dict_check_tablespaces_and_store_max_id(
  1459. recv_needed_recovery);
  1460. }
  1462.                 srv_startup_is_before_trx_rollback_phase = FALSE;
  1464. /* Initialize the fsp free limit global variable in the log
  1465. system */
  1466. fsp_header_get_free_limit(0);
  1468. /* recv_recovery_from_checkpoint_finish needs trx lists which
  1469. are initialized in trx_sys_init_at_db_start(). */
  1471. recv_recovery_from_checkpoint_finish();
  1472. }
  1474. if (!create_new_db && sum_of_new_sizes > 0) {
  1475. /* New data file(s) were added */
  1476. mtr_start(&mtr);
  1478. fsp_header_inc_size(0, sum_of_new_sizes, &mtr);
  1480. mtr_commit(&mtr);
  1481. }
  1483. if (recv_needed_recovery) {
  1484.      ut_print_timestamp(stderr);
  1485. fprintf(stderr,
  1486.         "  InnoDB: Flushing modified pages from the buffer pool...n");
  1487. }
  1489. log_make_checkpoint_at(ut_dulint_max, TRUE);
  1491. #ifdef UNIV_LOG_ARCHIVE
  1492. /* Archiving is always off under MySQL */
  1493. if (!srv_log_archive_on) {
  1494. ut_a(DB_SUCCESS == log_archive_noarchivelog());
  1495. } else {
  1496. mutex_enter(&(log_sys->mutex));
  1498. start_archive = FALSE;
  1500. if (log_sys->archiving_state == LOG_ARCH_OFF) {
  1501. start_archive = TRUE;
  1502. }
  1504. mutex_exit(&(log_sys->mutex));
  1506. if (start_archive) {
  1507. ut_a(DB_SUCCESS == log_archive_archivelog());
  1508. }
  1509. }
  1510. #endif /* UNIV_LOG_ARCHIVE */
  1512. if (srv_measure_contention) {
  1513.    /* os_thread_create(&test_measure_cont, NULL, thread_ids +
  1514.                                    SRV_MAX_N_IO_THREADS); */
  1515. }
  1517. /* fprintf(stderr, "Max allowed record size %lun",
  1518. page_get_free_space_of_empty() / 2); */
  1520. /* Create the thread which watches the timeouts for lock waits
  1521. and prints InnoDB monitor info */
  1523. os_thread_create(&srv_lock_timeout_and_monitor_thread, NULL,
  1524. thread_ids + 2 + SRV_MAX_N_IO_THREADS);
  1526. /* Create the thread which warns of long semaphore waits */
  1527. os_thread_create(&srv_error_monitor_thread, NULL,
  1528. thread_ids + 3 + SRV_MAX_N_IO_THREADS);
  1529. srv_was_started = TRUE;
  1530. srv_is_being_started = FALSE;
  1532. #ifdef UNIV_DEBUG
  1533.         /* Wait a while so that the created threads have time to suspend
  1534. themselves before we switch sync debugging on; otherwise a thread may
  1535. execute mutex_enter() before the checks are on, and mutex_exit() after
  1536. the checks are on, which will cause an assertion failure in sync
  1537. debug. */
  1539.         os_thread_sleep(3000000);
  1540. #endif
  1541. sync_order_checks_on = TRUE;
  1543.         if (srv_use_doublewrite_buf && trx_doublewrite == NULL) {
  1544. /* Create the doublewrite buffer to a new tablespace */
  1546. trx_sys_create_doublewrite_buf();
  1547. }
  1549. err = dict_create_or_check_foreign_constraint_tables();
  1551. if (err != DB_SUCCESS) {
  1552. return((int)DB_ERROR);
  1553. }
  1555. /* Create the master thread which does purge and other utility
  1556. operations */
  1558. os_thread_create(&srv_master_thread, NULL, thread_ids + 1 +
  1559. SRV_MAX_N_IO_THREADS);
  1560. /* buf_debug_prints = TRUE; */
  1562. sum_of_data_file_sizes = 0;
  1564. for (i = 0; i < srv_n_data_files; i++) {
  1565. sum_of_data_file_sizes += srv_data_file_sizes[i];
  1566. }
  1568. tablespace_size_in_header = fsp_header_get_tablespace_size(0);
  1570. if (!srv_auto_extend_last_data_file
  1571. && sum_of_data_file_sizes != tablespace_size_in_header) {
  1573. fprintf(stderr,
  1574. "InnoDB: Error: tablespace size stored in header is %lu pages, butn"
  1575. "InnoDB: the sum of data file sizes is %lu pagesn",
  1576.   (ulong) tablespace_size_in_header,
  1577. (ulong) sum_of_data_file_sizes);
  1579. if (srv_force_recovery == 0
  1580.     && sum_of_data_file_sizes < tablespace_size_in_header) {
  1581. /* This is a fatal error, the tail of a tablespace is
  1582. missing */
  1584. fprintf(stderr,
  1585. "InnoDB: Cannot start InnoDB. The tail of the system tablespace isn"
  1586. "InnoDB: missing. Have you edited innodb_data_file_path in my.cnf in ann"
  1587. "InnoDB: inappropriate way, removing ibdata files from there?n"
  1588. "InnoDB: You can set innodb_force_recovery=1 in my.cnf to forcen"
  1589. "InnoDB: a startup if you are trying to recover a badly corrupt database.n");
  1591. return(DB_ERROR);
  1592. }
  1593. }
  1595. if (srv_auto_extend_last_data_file
  1596. && sum_of_data_file_sizes < tablespace_size_in_header) {
  1598. fprintf(stderr,
  1599. "InnoDB: Error: tablespace size stored in header is %lu pages, butn"
  1600. "InnoDB: the sum of data file sizes is only %lu pagesn",
  1601.   (ulong) tablespace_size_in_header,
  1602. (ulong) sum_of_data_file_sizes);
  1604. if (srv_force_recovery == 0) {
  1606. fprintf(stderr,
  1607. "InnoDB: Cannot start InnoDB. The tail of the system tablespace isn"
  1608. "InnoDB: missing. Have you edited innodb_data_file_path in my.cnf in ann"
  1609. "InnoDB: inappropriate way, removing ibdata files from there?n"
  1610. "InnoDB: You can set innodb_force_recovery=1 in my.cnf to forcen"
  1611. "InnoDB: a startup if you are trying to recover a badly corrupt database.n");
  1613. return(DB_ERROR);
  1614. }
  1615. }
  1617. /* Check that os_fast_mutexes work as expected */
  1618. os_fast_mutex_init(&srv_os_test_mutex);
  1620. if (0 != os_fast_mutex_trylock(&srv_os_test_mutex)) {
  1621.         fprintf(stderr,
  1622. "InnoDB: Error: pthread_mutex_trylock returns an unexpected value onn"
  1623. "InnoDB: success! Cannot continue.n");
  1624.         exit(1);
  1625. }
  1627. os_fast_mutex_unlock(&srv_os_test_mutex);
  1629.         os_fast_mutex_lock(&srv_os_test_mutex);
  1631. os_fast_mutex_unlock(&srv_os_test_mutex);
  1633. os_fast_mutex_free(&srv_os_test_mutex);
  1635. if (srv_print_verbose_log) {
  1636.    ut_print_timestamp(stderr);
  1637.    fprintf(stderr,
  1638. "  InnoDB: Started; log sequence number %lu %lun",
  1639. (ulong) ut_dulint_get_high(srv_start_lsn),
  1640. (ulong) ut_dulint_get_low(srv_start_lsn));
  1641. }
  1643. if (srv_force_recovery > 0) {
  1644. fprintf(stderr,
  1645. "InnoDB: !!! innodb_force_recovery is set to %lu !!!n",
  1646. (ulong) srv_force_recovery);
  1647. }
  1649. fflush(stderr);
  1651. if (trx_doublewrite_must_reset_space_ids) {
  1652. /* Actually, we did not change the undo log format between
  1653. 4.0 and 4.1.1, and we would not need to run purge to
  1654. completion. Note also that the purge algorithm in 4.1.1
  1655. can process the the history list again even after a full
  1656. purge, because our algorithm does not cut the end of the
  1657. history list in all cases so that it would become empty
  1658. after a full purge. That mean that we may purge 4.0 type
  1659. undo log even after this phase.
  1661. The insert buffer record format changed between 4.0 and
  1662. 4.1.1. It is essential that the insert buffer is emptied
  1663. here! */
  1665. fprintf(stderr,
  1666. "InnoDB: You are upgrading to an InnoDB version which allows multiplen"
  1667. "InnoDB: tablespaces. Wait that purge and insert buffer merge run ton"
  1668. "InnoDB: completion...n");
  1669. for (;;) {
  1670. os_thread_sleep(1000000);
  1672. if (0 == strcmp(srv_main_thread_op_info,
  1673. "waiting for server activity")) {
  1675. ut_a(ibuf_is_empty());
  1677. break;
  1678. }
  1679. }
  1680. fprintf(stderr,
  1681. "InnoDB: Full purge and insert buffer merge completed.n");
  1683.         trx_sys_mark_upgraded_to_multiple_tablespaces();
  1685. fprintf(stderr,
  1686. "InnoDB: You have now successfully upgraded to the multiple tablespacesn"
  1687. "InnoDB: format. You should NOT DOWNGRADE to an earlier version ofn"
  1688. "InnoDB: InnoDB! But if you absolutely need to downgrade, seen"
  1689. "InnoDB: http://dev.mysql.com/doc/mysql/en/Multiple_tablespaces.htmln"
  1690. "InnoDB: for instructions.n");
  1691. }
  1693. if (srv_force_recovery == 0) {
  1694. /* In the insert buffer we may have even bigger tablespace
  1695. id's, because we may have dropped those tablespaces, but
  1696. insert buffer merge has not had time to clean the records from
  1697. the ibuf tree. */
  1699. ibuf_update_max_tablespace_id();
  1700. }
  1702. srv_file_per_table = srv_file_per_table_original_value;
  1704. return((int) DB_SUCCESS);
  1705. }
  1707. /********************************************************************
  1708. Shuts down the InnoDB database. */
  1710. int
  1711. innobase_shutdown_for_mysql(void) 
  1712. /*=============================*/
  1713. /* out: DB_SUCCESS or error code */
  1714. {
  1715. ulint   i;
  1716. #ifdef __NETWARE__
  1717. extern ibool panic_shutdown;
  1718. #endif
  1719.         if (!srv_was_started) {
  1720.    if (srv_is_being_started) {
  1721.      ut_print_timestamp(stderr);
  1722.              fprintf(stderr, 
  1723. "  InnoDB: Warning: shutting down a not properly startedn"
  1724. "                 InnoDB: or created database!n");
  1725.    }
  1727.    return(DB_SUCCESS);
  1728. }
  1730. /* 1. Flush the buffer pool to disk, write the current lsn to
  1731. the tablespace header(s), and copy all log data to archive.
  1732. The step 1 is the real InnoDB shutdown. The remaining steps 2 - ...
  1733. just free data structures after the shutdown. */
  1735. #ifdef __NETWARE__
  1736. if(!panic_shutdown)
  1737. #endif 
  1738. logs_empty_and_mark_files_at_shutdown();
  1740. if (srv_conc_n_threads != 0) {
  1741. fprintf(stderr,
  1742. "InnoDB: Warning: query counter shows %ld queries stilln"
  1743. "InnoDB: inside InnoDB at shutdownn",
  1744. srv_conc_n_threads);
  1745. }
  1747. /* 2. Make all threads created by InnoDB to exit */
  1749. srv_shutdown_state = SRV_SHUTDOWN_EXIT_THREADS;
  1751. /* All threads end up waiting for certain events. Put those events
  1752. to the signaled state. Then the threads will exit themselves in
  1753. os_thread_event_wait(). */
  1755. for (i = 0; i < 1000; i++) {
  1756.         /* NOTE: IF YOU CREATE THREADS IN INNODB, YOU MUST EXIT THEM
  1757.         HERE OR EARLIER */
  1759. /* a. Let the lock timeout thread exit */
  1760. os_event_set(srv_lock_timeout_thread_event);
  1762. /* b. srv error monitor thread exits automatically, no need
  1763. to do anything here */
  1765. /* c. We wake the master thread so that it exits */
  1766. srv_wake_master_thread();
  1768. /* d. Exit the i/o threads */
  1770. os_aio_wake_all_threads_at_shutdown();
  1772. os_mutex_enter(os_sync_mutex);
  1774. if (os_thread_count == 0) {
  1775.         /* All the threads have exited or are just exiting;
  1776. NOTE that the threads may not have completed their
  1777. exit yet. Should we use pthread_join() to make sure
  1778. they have exited? Now we just sleep 0.1 seconds and
  1779. hope that is enough! */
  1781. os_mutex_exit(os_sync_mutex);
  1783. os_thread_sleep(100000);
  1785. break;
  1786. }
  1788. os_mutex_exit(os_sync_mutex);
  1790. os_thread_sleep(100000);
  1791. }
  1793. if (i == 1000) {
  1794.         fprintf(stderr,
  1795. "InnoDB: Warning: %lu threads created by InnoDB had not exited at shutdown!n",
  1796.       (ulong) os_thread_count);
  1797. }
  1799. if (srv_monitor_file) {
  1800. fclose(srv_monitor_file);
  1801. srv_monitor_file = 0;
  1802. if (srv_monitor_file_name) {
  1803. unlink(srv_monitor_file_name);
  1804. mem_free(srv_monitor_file_name);
  1805. }
  1806. }
  1808. mutex_free(&srv_monitor_file_mutex);
  1810. /* 3. Free all InnoDB's own mutexes and the os_fast_mutexes inside
  1811. them */
  1812. sync_close();
  1814. /* 4. Free the os_conc_mutex and all os_events and os_mutexes */
  1816. srv_free();
  1817. os_sync_free();
  1819. /* 5. Free all allocated memory and the os_fast_mutex created in
  1820. ut0mem.c */
  1822. ut_free_all_mem();
  1824. if (os_thread_count != 0
  1825.     || os_event_count != 0
  1826.     || os_mutex_count != 0
  1827.     || os_fast_mutex_count != 0) {
  1828.         fprintf(stderr,
  1829. "InnoDB: Warning: some resources were not cleaned up in shutdown:n"
  1830. "InnoDB: threads %lu, events %lu, os_mutexes %lu, os_fast_mutexes %lun",
  1831. (ulong) os_thread_count, (ulong) os_event_count,
  1832. (ulong) os_mutex_count, (ulong) os_fast_mutex_count);
  1833. }
  1835. if (dict_foreign_err_file) {
  1836. fclose(dict_foreign_err_file);
  1837. }
  1838. if (lock_latest_err_file) {
  1839. fclose(lock_latest_err_file);
  1840. }
  1842. if (srv_print_verbose_log) {
  1843.         ut_print_timestamp(stderr);
  1844.         fprintf(stderr,
  1845. "  InnoDB: Shutdown completed; log sequence number %lu %lun",
  1846.        (ulong) ut_dulint_get_high(srv_shutdown_lsn),
  1847.        (ulong) ut_dulint_get_low(srv_shutdown_lsn));
  1848. }
  1850. return((int) DB_SUCCESS);
  1851. }
  1853. #ifdef __NETWARE__
  1854. void set_panic_flag_for_netware()
  1855. {
  1856. extern ibool panic_shutdown;
  1857. panic_shutdown = TRUE;
  1858. }
  1859. #endif