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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
srv0start.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：16k
源码类别：

MySQL数据库

开发平台：

Visual C++

srv0start.c：源码内容
  1. /************************************************************************
  2. Starts the Innobase 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 "trx0sys.h"
  34. #include "dict0crea.h"
  35. #include "btr0btr.h"
  36. #include "btr0pcur.h"
  37. #include "btr0cur.h"
  38. #include "btr0sea.h"
  39. #include "rem0rec.h"
  40. #include "srv0srv.h"
  41. #include "que0que.h"
  42. #include "com0com.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. ibool           srv_is_being_started = FALSE;
  60. ibool           srv_was_started      = FALSE;
  62. ibool measure_cont = FALSE;
  64. os_file_t files[1000];
  66. mutex_t ios_mutex;
  67. ulint ios;
  69. #define SRV_MAX_N_IO_THREADS 1000
  71. ulint n[SRV_MAX_N_IO_THREADS + 5];
  72. os_thread_id_t thread_ids[SRV_MAX_N_IO_THREADS + 5];
  74. #define SRV_N_PENDING_IOS_PER_THREAD  OS_AIO_N_PENDING_IOS_PER_THREAD
  75. #define SRV_MAX_N_PENDING_SYNC_IOS 100
  77. #define SRV_MAX_N_OPEN_FILES 25
  79. #define SRV_LOG_SPACE_FIRST_ID 1000000000
  81. /************************************************************************
  82. I/o-handler thread function. */
  83. static
  85. #ifndef __WIN__
  86. void*
  87. #else
  88. ulint
  89. #endif
  90. io_handler_thread(
  91. /*==============*/
  92. void* arg)
  93. {
  94. ulint segment;
  95. ulint i;
  97. segment = *((ulint*)arg);
  99. /* printf("Io handler thread %lu startsn", segment); */
  101. for (i = 0;; i++) {
  102. fil_aio_wait(segment);
  104. mutex_enter(&ios_mutex);
  105. ios++;
  106. mutex_exit(&ios_mutex);
  107. }
  109. #ifndef __WIN__
  110. return(NULL);
  111. #else
  112. return(0);
  113. #endif
  114. }
  116. /*************************************************************************
  117. Creates or opens the log files. */
  118. static
  119. ulint
  120. open_or_create_log_file(
  121. /*====================*/
  122. /* out: DB_SUCCESS or error code */
  123. ibool create_new_db, /* in: TRUE if we should create a
  124. new database */
  125. ibool* log_file_created, /* out: TRUE if new log file
  126. created */
  127. ulint k, /* in: log group number */
  128. ulint i) /* in: log file number in group */
  129. {
  130. ibool ret;
  131. ulint arch_space_id;
  132. ulint size;
  133. ulint size_high;
  134. char name[10000];
  136. UT_NOT_USED(create_new_db);
  138. *log_file_created = FALSE;
  140. sprintf(name, "%s%s%lu", srv_log_group_home_dirs[k], "ib_logfile", i);
  142. files[i] = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL, &ret);
  144. if (ret == FALSE) {
  145. if (os_file_get_last_error() != OS_FILE_ALREADY_EXISTS) {
  146. fprintf(stderr,
  147. "Innobase: Error in creating or opening %sn", name);
  149. return(DB_ERROR);
  150. }
  152. files[i] = os_file_create(
  153. name, OS_FILE_OPEN, OS_FILE_AIO, &ret);
  154. if (!ret) {
  155. fprintf(stderr,
  156. "Innobase: Error in opening %sn", name);
  158. return(DB_ERROR);
  159. }
  161. ret = os_file_get_size(files[i], &size, &size_high);
  162. ut_a(ret);
  164. if (size != UNIV_PAGE_SIZE * srv_log_file_size
  165. || size_high != 0) {
  166. fprintf(stderr,
  167. "Innobase: Error: log file %s is of different sizen"
  168. "Innobase: than specified in the .cnf file!n", name);
  170. return(DB_ERROR);
  171. }
  172. } else {
  173. *log_file_created = TRUE;
  175. fprintf(stderr,
  176. "Innobase: Log file %s did not exist: new to be createdn",
  177. name);
  178. printf("Innobase: Setting log file %s size to %lun",
  179.              name, UNIV_PAGE_SIZE * srv_log_file_size);
  181. ret = os_file_set_size(name, files[i],
  182. UNIV_PAGE_SIZE * srv_log_file_size, 0);
  183. if (!ret) {
  184. fprintf(stderr,
  185. "Innobase: Error in creating %s: probably out of disk spacen",
  186. name);
  188. return(DB_ERROR);
  189. }
  190. }
  192. ret = os_file_close(files[i]);
  193. ut_a(ret);
  195. if (i == 0) {
  196. /* Create in memory the file space object
  197. which is for this log group */
  199. fil_space_create(name,
  200. 2 * k + SRV_LOG_SPACE_FIRST_ID, FIL_LOG);
  201. }
  203. ut_a(fil_validate());
  205. fil_node_create(name, srv_log_file_size,
  206. 2 * k + SRV_LOG_SPACE_FIRST_ID);
  208. /* If this is the first log group, create the file space object
  209. for archived logs */
  211. if (k == 0 && i == 0) {
  212. arch_space_id = 2 * k + 1 + SRV_LOG_SPACE_FIRST_ID;
  214.      fil_space_create("arch_log_space", arch_space_id,
  215. FIL_LOG);
  216. } else {
  217. arch_space_id = ULINT_UNDEFINED;
  218. }
  220. if (i == 0) {
  221. log_group_init(k, srv_n_log_files,
  222. srv_log_file_size * UNIV_PAGE_SIZE,
  223. 2 * k + SRV_LOG_SPACE_FIRST_ID,
  224. arch_space_id);
  225. }
  227. return(DB_SUCCESS);
  228. }
  230. /*************************************************************************
  231. Creates or opens database data files. */
  232. static
  233. ulint
  234. open_or_create_data_files(
  235. /*======================*/
  236. /* out: DB_SUCCESS or error code */
  237. ibool* create_new_db, /* out: TRUE if new database should be
  238. created */
  239. dulint* min_flushed_lsn,/* out: min of flushed lsn values in data
  240. files */
  241. ulint* min_arch_log_no,/* out: min of archived log numbers in data
  242. files */
  243. dulint* max_flushed_lsn,/* out: */
  244. ulint* max_arch_log_no,/* out: */
  245. ulint* sum_of_new_sizes)/* out: sum of sizes of the new files added */
  246. {
  247. ibool ret;
  248. ulint i;
  249. ibool one_opened = FALSE;
  250. ibool one_created = FALSE;
  251. ulint size;
  252. ulint size_high;
  253. char name[10000];
  255. ut_a(srv_n_data_files < 1000);
  257. *sum_of_new_sizes = 0;
  259. *create_new_db = FALSE;
  261. for (i = 0; i < srv_n_data_files; i++) {
  263. sprintf(name, "%s%s", srv_data_home, srv_data_file_names[i]);
  265. files[i] = os_file_create(name, OS_FILE_CREATE,
  266. OS_FILE_NORMAL, &ret);
  267. if (ret == FALSE) {
  268. if (os_file_get_last_error() !=
  269. OS_FILE_ALREADY_EXISTS) {
  270. fprintf(stderr,
  271. "Innobase: Error in creating or opening %sn",
  272. name);
  274. return(DB_ERROR);
  275. }
  277. if (one_created) {
  278. fprintf(stderr,
  279. "Innobase: Error: data files can only be added at the endn");
  280. fprintf(stderr,
  281. "Innobase: of a tablespace, but data file %s existed beforehand.n",
  282. name);
  283. return(DB_ERROR);
  284. }
  286. files[i] = os_file_create(
  287. name, OS_FILE_OPEN, OS_FILE_NORMAL, &ret);
  289. if (!ret) {
  290. fprintf(stderr,
  291. "Innobase: Error in opening %sn", name);
  293. return(DB_ERROR);
  294. }
  296. ret = os_file_get_size(files[i], &size, &size_high);
  297. ut_a(ret);
  299. if (size != UNIV_PAGE_SIZE * srv_data_file_sizes[i]
  300.      || size_high != 0) {
  301. fprintf(stderr,
  302. "Innobase: Error: data file %s is of different sizen"
  303. "Innobase: than specified in the .cnf file!n", name);
  305. return(DB_ERROR);
  306. }
  308. fil_read_flushed_lsn_and_arch_log_no(files[i],
  309. one_opened,
  310. min_flushed_lsn, min_arch_log_no,
  311. max_flushed_lsn, max_arch_log_no);
  312. one_opened = TRUE;
  313. } else {
  314. one_created = TRUE;
  316. if (i > 0) {
  317. fprintf(stderr, 
  318. "Innobase: Data file %s did not exist: new to be createdn", name);
  319. } else {
  320. fprintf(stderr, 
  321.   "Innobase: The first specified data file %s did not exist:n"
  322. "Innobase: a new database to be created!n", name);
  323. *create_new_db = TRUE;
  324. }
  326. printf("Innobase: Setting file %s size to %lun",
  327.        name, UNIV_PAGE_SIZE * srv_data_file_sizes[i]);
  329. printf(
  330.     "Innobase: Database physically writes the file full: wait...n");
  332. ret = os_file_set_size(name, files[i],
  333. UNIV_PAGE_SIZE * srv_data_file_sizes[i], 0);
  335. if (!ret) {
  336. fprintf(stderr, 
  337. "Innobase: Error in creating %s: probably out of disk spacen", name);
  339. return(DB_ERROR);
  340. }
  342. *sum_of_new_sizes = *sum_of_new_sizes
  343. + srv_data_file_sizes[i];
  344. }
  346. ret = os_file_close(files[i]);
  347. ut_a(ret);
  349. if (i == 0) {
  350. fil_space_create(name, 0, FIL_TABLESPACE);
  351. }
  353. ut_a(fil_validate());
  355. fil_node_create(name, srv_data_file_sizes[i], 0);
  356. }
  358. ios = 0;
  360. mutex_create(&ios_mutex);
  361. mutex_set_level(&ios_mutex, SYNC_NO_ORDER_CHECK);
  363. return(DB_SUCCESS);
  364. }
  366. /*********************************************************************
  367. This thread is used to measure contention of latches. */
  368. static
  369. ulint
  370. test_measure_cont(
  371. /*==============*/
  372. void* arg)
  373. {
  374. ulint i, j;
  375. ulint pcount, kcount, s_scount, s_xcount, s_mcount, lcount;
  377. UT_NOT_USED(arg);
  379. fprintf(stderr, "Starting contention measurementn");
  381. for (i = 0; i < 1000; i++) {
  383. pcount = 0;
  384. kcount = 0;
  385. s_scount = 0;
  386. s_xcount = 0;
  387. s_mcount = 0;
  388. lcount = 0;
  390. for (j = 0; j < 100; j++) {
  392.     if (srv_measure_by_spin) {
  393.      ut_delay(ut_rnd_interval(0, 20000));
  394.     } else {
  395.      os_thread_sleep(20000);
  396.     }
  398.     if (kernel_mutex.lock_word) {
  399. kcount++;
  400.     }
  402.     if (buf_pool->mutex.lock_word) {
  403.      pcount++;
  404.     }
  406.     if (log_sys->mutex.lock_word) {
  407.      lcount++;
  408.     }
  410.     if (btr_search_latch.reader_count) {
  411.      s_scount++;
  412.     }
  414.     if (btr_search_latch.writer != RW_LOCK_NOT_LOCKED) {
  415.      s_xcount++;
  416.     }
  418.     if (btr_search_latch.mutex.lock_word) {
  419.      s_mcount++;
  420.     }
  421. }
  423. fprintf(stderr, 
  424. "Mutex res. l %lu, p %lu, k %lu s x %lu s s %lu s mut %lu of %lun",
  425. lcount, pcount, kcount, s_xcount, s_scount, s_mcount, j);
  427. sync_print_wait_info();
  429. fprintf(stderr, 
  430.     "log i/o %lu n non sea %lu n succ %lu n h fail %lun",
  431. log_sys->n_log_ios, btr_cur_n_non_sea,
  432. btr_search_n_succ, btr_search_n_hash_fail);
  433. }
  435. return(0);
  436. }
  438. /********************************************************************
  439. Starts Innobase and creates a new database if database files
  440. are not found and the user wants. Server parameters are
  441. read from a file of name "srv_init" in the ib_home directory. */
  443. int
  444. innobase_start_or_create_for_mysql(void)
  445. /*====================================*/
  446. /* out: DB_SUCCESS or error code */
  447. {
  448. ulint i;
  449. ulint k;
  450. ulint err;
  451. ibool create_new_db;
  452. ibool log_file_created;
  453. ibool log_created = FALSE;
  454. ibool log_opened = FALSE;
  455. dulint min_flushed_lsn;
  456. dulint max_flushed_lsn;
  457. ulint min_arch_log_no;
  458. ulint max_arch_log_no;
  459. ibool start_archive;
  460. ulint   sum_of_new_sizes;
  461. mtr_t   mtr;
  463. log_do_write = TRUE;
  464. /* yydebug = TRUE; */
  466. srv_is_being_started = TRUE;
  468. os_aio_use_native_aio = srv_use_native_aio;
  470. err = srv_boot();
  472. if (err != DB_SUCCESS) {
  474. return((int) err);
  475. }
  477. #if !(defined(WIN_ASYNC_IO) || defined(POSIX_ASYNC_IO))
  478. /* In simulated aio we currently have use only for 4 threads */
  480. os_aio_use_native_aio = FALSE;
  482. srv_n_file_io_threads = 4;
  483. #endif
  485. #ifdef WIN_ASYNC_IO
  486. /* On NT always use aio */
  487. os_aio_use_native_aio = TRUE;
  488. #endif
  490. if (!os_aio_use_native_aio) {
  491. os_aio_init(4 * SRV_N_PENDING_IOS_PER_THREAD
  492. * srv_n_file_io_threads,
  493. srv_n_file_io_threads,
  494. SRV_MAX_N_PENDING_SYNC_IOS);
  495. } else {
  496. os_aio_init(SRV_N_PENDING_IOS_PER_THREAD
  497. * srv_n_file_io_threads,
  498. srv_n_file_io_threads,
  499. SRV_MAX_N_PENDING_SYNC_IOS);
  500. }
  502. fil_init(SRV_MAX_N_OPEN_FILES);
  504. buf_pool_init(srv_pool_size, srv_pool_size);
  506. fsp_init();
  507. log_init();
  509. lock_sys_create(srv_lock_table_size);
  511. #ifdef POSIX_ASYNC_IO
  512. if (os_aio_use_native_aio) {
  513. /* There is only one thread per async io array:
  514. one for ibuf i/o, one for log i/o, one for ordinary reads,
  515. one for ordinary writes; we need only 4 i/o threads */
  517. srv_n_file_io_threads = 4;
  518. }
  519. #endif
  520. /* Create i/o-handler threads: */
  522. for (i = 0; i < srv_n_file_io_threads; i++) {
  523. n[i] = i;
  525. os_thread_create(io_handler_thread, n + i, thread_ids + i);
  526.      }
  528. err = open_or_create_data_files(&create_new_db,
  529. &min_flushed_lsn, &min_arch_log_no,
  530. &max_flushed_lsn, &max_arch_log_no,
  531. &sum_of_new_sizes);
  532. if (err != DB_SUCCESS) {
  534.         fprintf(stderr, "Innobase: Could not open data filesn");
  536. return((int) err);
  537. }
  539. for (k = 0; k < srv_n_log_groups; k++) {
  541. for (i = 0; i < srv_n_log_files; i++) {
  543. err = open_or_create_log_file(create_new_db,
  544. &log_file_created, k, i);
  545. if (err != DB_SUCCESS) {
  547. return((int) err);
  548. }
  550. if (log_file_created) {
  551. log_created = TRUE;
  552. } else {
  553. log_opened = TRUE;
  554. }
  556. if ((log_opened && create_new_db)
  557.      || (log_opened && log_created)) {
  558. fprintf(stderr, 
  559. "Innobase: Error: all log files must be created at the same time.n"
  560. "Innobase: If you want bigger or smaller log files,n"
  561. "Innobase: shut down the database and make sure theren"
  562. "Innobase: were no errors in shutdown.n"
  563. "Innobase: Then delete the existing log files. Edit the .cnf filen"
  564. "Innobase: and start the database again.n");
  566. return(DB_ERROR);
  567. }
  569. }
  570. }
  572. if (log_created && !create_new_db && !srv_archive_recovery) {
  574. if (ut_dulint_cmp(max_flushed_lsn, min_flushed_lsn) != 0
  575. || max_arch_log_no != min_arch_log_no) {
  576. fprintf(stderr, 
  577. "Innobase: Cannot initialize created log files becausen"
  578. "Innobase: data files were not in sync with each othern"
  579. "Innobase: or the data files are corrupt./n");
  581. return(DB_ERROR);
  582. }
  584. if (ut_dulint_cmp(max_flushed_lsn, ut_dulint_create(0, 1000))
  585.     < 0) {
  586.      fprintf(stderr,
  587. "Innobase: Cannot initialize created log files becausen"
  588. "Innobase: data files are corrupt, or new data files weren"
  589. "Innobase: created when the database was started previousn"
  590. "Innobase: time but the database was not shut downn"
  591. "Innobase: normally after that.n");
  593. return(DB_ERROR);
  594. }
  596. mutex_enter(&(log_sys->mutex));
  598. recv_reset_logs(ut_dulint_align_down(max_flushed_lsn,
  599. OS_FILE_LOG_BLOCK_SIZE),
  600. max_arch_log_no + 1, TRUE);
  602. mutex_exit(&(log_sys->mutex));
  603. }
  605. sess_sys_init_at_db_start();
  607. if (create_new_db) {
  608. mtr_start(&mtr);
  610. fsp_header_init(0, sum_of_new_sizes, &mtr);
  612. mtr_commit(&mtr);
  614. trx_sys_create();
  615. dict_create();
  617. } else if (srv_archive_recovery) {
  618. fprintf(stderr,
  619. "Innobase: Starting archive recovery from a backup...n");
  621. err = recv_recovery_from_archive_start(
  622. min_flushed_lsn,
  623. srv_archive_recovery_limit_lsn,
  624. min_arch_log_no);
  625. if (err != DB_SUCCESS) {
  627. return(DB_ERROR);
  628. }
  630. trx_sys_init_at_db_start();
  631. dict_boot();
  633. recv_recovery_from_archive_finish();
  634. } else {
  635. /* We always try to do a recovery, even if the database had
  636. been shut down normally */
  638. err = recv_recovery_from_checkpoint_start(LOG_CHECKPOINT,
  639. ut_dulint_max,
  640. min_flushed_lsn,
  641. max_flushed_lsn);
  642. if (err != DB_SUCCESS) {
  644. return(DB_ERROR);
  645. }
  647. trx_sys_init_at_db_start();
  648. dict_boot();
  650. /* The following needs trx lists which are initialized in
  651. trx_sys_init_at_db_start */
  653. recv_recovery_from_checkpoint_finish();
  654. }
  656. if (!create_new_db && sum_of_new_sizes > 0) {
  657. /* New data file(s) were added */
  658. mtr_start(&mtr);
  660. fsp_header_inc_size(0, sum_of_new_sizes, &mtr);
  662. mtr_commit(&mtr);
  663. }
  665. log_make_checkpoint_at(ut_dulint_max, TRUE);
  667. if (!srv_log_archive_on) {
  668. ut_a(DB_SUCCESS == log_archive_noarchivelog());
  669. } else {
  670. mutex_enter(&(log_sys->mutex));
  672. start_archive = FALSE;
  674. if (log_sys->archiving_state == LOG_ARCH_OFF) {
  675. start_archive = TRUE;
  676. }
  678. mutex_exit(&(log_sys->mutex));
  680. if (start_archive) {
  681. ut_a(DB_SUCCESS == log_archive_archivelog());
  682. }
  683. }
  685. if (srv_measure_contention) {
  686.   /* os_thread_create(&test_measure_cont, NULL, thread_ids +
  687.                                    SRV_MAX_N_IO_THREADS); */
  688. }
  690. /* Create the master thread which monitors the database
  691. server, and does purge and other utility operations */
  693. os_thread_create(&srv_master_thread, NULL, thread_ids + 1 +
  694. SRV_MAX_N_IO_THREADS);
  695. /* fprintf(stderr, "Max allowed record size %lun",
  696. page_get_free_space_of_empty() / 2); */
  698. /* Create the thread which watches the timeouts for lock waits */
  699. os_thread_create(&srv_lock_timeout_monitor_thread, NULL,
  700. thread_ids + 2 + SRV_MAX_N_IO_THREADS);
  701. fprintf(stderr, "Innobase: Startedn");
  703. srv_was_started = TRUE;
  704. srv_is_being_started = FALSE;
  706. sync_order_checks_on = TRUE;
  708. /* buf_debug_prints = TRUE; */
  710. return((int) DB_SUCCESS);
  711. }
  713. /********************************************************************
  714. Shuts down the Innobase database. */
  716. int
  717. innobase_shutdown_for_mysql(void) 
  718. /*=============================*/
  719. /* out: DB_SUCCESS or error code */
  720. {
  721.         if (!srv_was_started) {
  722.   if (srv_is_being_started) {
  723.             fprintf(stderr, 
  724. "Innobase: Warning: shutting down not properly started databasen");
  725.   }
  726.   return(DB_SUCCESS);
  727. }
  729. /* Flush buffer pool to disk, write the current lsn to
  730. the tablespace header(s), and copy all log data to archive */
  732. logs_empty_and_mark_files_at_shutdown();
  734. return((int) DB_SUCCESS);
  735. }