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

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

MySQL数据库

开发平台：

Visual C++

os0file.c：源码内容
  1. /******************************************************
  2. The interface to the operating system file i/o primitives
  4. (c) 1995 Innobase Oy
  6. Created 10/21/1995 Heikki Tuuri
  7. *******************************************************/
  9. #include "os0file.h"
  10. #include "os0sync.h"
  11. #include "ut0mem.h"
  14. #ifdef POSIX_ASYNC_IO
  15. /* We assume in this case that the OS has standard Posix aio (at least SunOS
  16. 2.6, HP-UX 11i and AIX 4.3 have) */
  18. #undef __USE_FILE_OFFSET64
  20. #include <aio.h>
  21. #endif
  23. /* We use these mutexes to protect lseek + file i/o operation, if the
  24. OS does not provide an atomic pread or pwrite, or similar */
  25. #define OS_FILE_N_SEEK_MUTEXES 16
  26. os_mutex_t os_file_seek_mutexes[OS_FILE_N_SEEK_MUTEXES];
  28. /* In simulated aio, merge at most this many consecutive i/os */
  29. #define OS_AIO_MERGE_N_CONSECUTIVE 32
  31. /* If this flag is TRUE, then we will use the native aio of the
  32. OS (provided we compiled Innobase with it in), otherwise we will
  33. use simulated aio we build below with threads */
  35. ibool os_aio_use_native_aio = FALSE;
  37. /* The aio array slot structure */
  38. typedef struct os_aio_slot_struct os_aio_slot_t;
  40. struct os_aio_slot_struct{
  41. ibool is_read; /* TRUE if a read operation */
  42. ulint pos; /* index of the slot in the aio
  43. array */
  44. ibool reserved; /* TRUE if this slot is reserved */
  45. ulint len; /* length of the block to read or
  46. write */
  47. byte* buf; /* buffer used in i/o */
  48. ulint type; /* OS_FILE_READ or OS_FILE_WRITE */
  49. ulint offset; /* 32 low bits of file offset in
  50. bytes */
  51. ulint offset_high; /* 32 high bits of file offset */
  52. os_file_t file; /* file where to read or write */
  53. char* name; /* file name or path */
  54. ibool io_already_done;/* used only in simulated aio:
  55. TRUE if the physical i/o already
  56. made and only the slot message
  57. needs to be passed to the caller
  58. of os_aio_simulated_handle */
  59. void* message1; /* message which is given by the */
  60. void* message2; /* the requester of an aio operation
  61. and which can be used to identify
  62. which pending aio operation was
  63. completed */
  64. #ifdef WIN_ASYNC_IO
  65. OVERLAPPED control; /* Windows control block for the
  66. aio request */
  67. #elif defined(POSIX_ASYNC_IO)
  68. struct aiocb control; /* Posix control block for aio
  69. request */
  70. #endif
  71. };
  73. /* The aio array structure */
  74. typedef struct os_aio_array_struct os_aio_array_t;
  76. struct os_aio_array_struct{
  77. os_mutex_t mutex;   /* the mutex protecting the aio array */
  78. os_event_t not_full; /* The event which is set to signaled
  79.   state when there is space in the aio
  80.   outside the ibuf segment */
  81. ulint n_slots;  /* Total number of slots in the aio array.
  82.   This must be divisible by n_threads. */
  83. ulint n_segments;/* Number of segments in the aio array of
  84.   pending aio requests. A thread can wait
  85.   separately for any one of the segments. */
  86. ulint n_reserved;/* Number of reserved slots in the
  87.   aio array outside the ibuf segment */
  88. os_aio_slot_t*  slots;   /* Pointer to the slots in the array */
  89. os_event_t* events;   /* Pointer to an array of event handles
  90.   where we copied the handles from slots,
  91.   in the same order. This can be used in
  92.   WaitForMultipleObjects; used only in
  93.   Windows */
  94. };
  96. /* Array of events used in simulated aio */
  97. os_event_t* os_aio_segment_wait_events = NULL;
  99. /* The aio arrays for non-ibuf i/o and ibuf i/o, as well as sync aio. These
  100. are NULL when the module has not yet been initialized. */
  101. os_aio_array_t* os_aio_read_array = NULL;
  102. os_aio_array_t* os_aio_write_array = NULL;
  103. os_aio_array_t* os_aio_ibuf_array = NULL;
  104. os_aio_array_t* os_aio_log_array = NULL;
  105. os_aio_array_t* os_aio_sync_array = NULL;
  107. ulint os_aio_n_segments = ULINT_UNDEFINED;
  109. /***************************************************************************
  110. Retrieves the last error number if an error occurs in a file io function.
  111. The number should be retrieved before any other OS calls (because they may
  112. overwrite the error number). If the number is not known to this program,
  113. the OS error number + 100 is returned. */
  115. ulint
  116. os_file_get_last_error(void)
  117. /*========================*/
  118. /* out: error number, or OS error number + 100 */
  119. {
  120. ulint err;
  122. #ifdef __WIN__
  124. err = (ulint) GetLastError();
  126. if (err == ERROR_FILE_NOT_FOUND) {
  127. return(OS_FILE_NOT_FOUND);
  128. } else if (err == ERROR_DISK_FULL) {
  129. return(OS_FILE_DISK_FULL);
  130. } else if (err == ERROR_FILE_EXISTS) {
  131. return(OS_FILE_ALREADY_EXISTS);
  132. } else {
  133. return(100 + err);
  134. }
  135. #else
  136. err = (ulint) errno;
  138. if (err == ENOSPC ) {
  139. return(OS_FILE_DISK_FULL);
  140. #ifdef POSIX_ASYNC_IO
  141. } else if (err == EAGAIN) {
  142. return(OS_FILE_AIO_RESOURCES_RESERVED);
  143. #endif
  144. } else if (err == ENOENT) {
  145. return(OS_FILE_NOT_FOUND);
  146. } else if (err == EEXIST) {
  147. return(OS_FILE_ALREADY_EXISTS);
  148. } else {
  149. return(100 + err);
  150. }
  151. #endif
  152. }
  154. /********************************************************************
  155. Does error handling when a file operation fails. If we have run out
  156. of disk space, then the user can clean the disk. If we do not find
  157. a specified file, then the user can copy it to disk. */
  158. static
  159. ibool
  160. os_file_handle_error(
  161. /*=================*/
  162. /* out: TRUE if we should retry the operation */
  163. os_file_t file, /* in: file pointer */
  164. char* name) /* in: name of a file or NULL */
  165. {
  166. int input_char;
  167. ulint err;
  169. UT_NOT_USED(file);
  171. err = os_file_get_last_error();
  173. if (err == OS_FILE_DISK_FULL) {
  174. ask_again:
  175. printf("n");
  176. if (name) {
  177. printf(
  178. "Innobase encountered a problem with file %s.n",
  179. name);
  180. }
  181. printf("Disk is full. Try to clean the disk to free spacen");
  182. printf("before answering the following: How to continue?n");
  183. printf("(Y == freed some space: try again)n");
  184. printf("(N == crash the database: will restart it)?n");
  185. ask_with_no_question:
  186. input_char = getchar();
  188. if (input_char == (int) 'N') {
  189. ut_error;
  191. return(FALSE);
  192. } else if (input_char == (int) 'Y') {
  194. return(TRUE);
  195. } else if (input_char == (int) 'n') {
  197. goto ask_with_no_question;
  198. } else {
  199. goto ask_again;
  200. }
  201. } else if (err == OS_FILE_AIO_RESOURCES_RESERVED) {
  203. return(TRUE);
  204. } else {
  205. ut_error;
  206. }
  208. return(FALSE);
  209. }
  211. /********************************************************************
  212. Opens an existing file or creates a new. */
  214. os_file_t
  215. os_file_create(
  216. /*===========*/
  217. /* out, own: handle to the file, not defined if error,
  218. error number can be retrieved with os_get_last_error */
  219. char* name, /* in: name of the file or path as a null-terminated
  220. string */
  221. ulint create_mode, /* in: OS_FILE_OPEN if an existing file is opened
  222. (if does not exist, error), or OS_FILE_CREATE if a new
  223. file is created (if exists, error), OS_FILE_OVERWRITE
  224. if a new is created or an old overwritten */
  225. ulint purpose,/* in: OS_FILE_AIO, if asynchronous, non-buffered i/o
  226. is desired, OS_FILE_NORMAL, if any normal file */
  227. ibool* success)/* out: TRUE if succeed, FALSE if error */
  228. {
  229. #ifdef __WIN__
  230. os_file_t file;
  231. DWORD create_flag;
  232. DWORD attributes;
  233. ibool retry;
  235. try_again:
  236. ut_a(name);
  238. if (create_mode == OS_FILE_OPEN) {
  239. create_flag = OPEN_EXISTING;
  240. } else if (create_mode == OS_FILE_CREATE) {
  241. create_flag = CREATE_NEW;
  242. } else if (create_mode == OS_FILE_OVERWRITE) {
  243. create_flag = CREATE_ALWAYS;
  244. } else {
  245. create_flag = 0;
  246. ut_error;
  247. }
  249. if (purpose == OS_FILE_AIO) {
  250. /* use asynchronous (overlapped) io and no buffering
  251. of writes in the OS */
  252. attributes = 0;
  253. #ifdef WIN_ASYNC_IO
  254. if (os_aio_use_native_aio) {
  255. attributes = attributes | FILE_FLAG_OVERLAPPED;
  256. }
  257. #endif
  258. #ifdef UNIV_NON_BUFFERED_IO
  259. attributes = attributes | FILE_FLAG_NO_BUFFERING;
  260. #endif
  261. } else if (purpose == OS_FILE_NORMAL) {
  262. attributes = 0
  263. #ifdef UNIV_NON_BUFFERED_IO
  264.  | FILE_FLAG_NO_BUFFERING
  265. #endif
  266. ;
  267. } else {
  268. attributes = 0;
  269. ut_error;
  270. }
  272. file = CreateFile(name,
  273. GENERIC_READ | GENERIC_WRITE, /* read and write
  274. access */
  275. FILE_SHARE_READ,/* file can be read by other
  276. processes */
  277. NULL, /* default security attributes */
  278. create_flag,
  279. attributes,
  280. NULL); /* no template file */
  282. if (file == INVALID_HANDLE_VALUE) {
  283. *success = FALSE;
  285. if (create_mode != OS_FILE_OPEN
  286.     && os_file_get_last_error() == OS_FILE_DISK_FULL) {
  288. retry = os_file_handle_error(file, name);
  290. if (retry) {
  291. goto try_again;
  292. }
  293. }
  294. } else {
  295. *success = TRUE;
  296. }
  298. return(file);
  299. #else
  300. os_file_t file;
  301. int create_flag;
  302. ibool retry;
  304. try_again:
  305. ut_a(name);
  307. if (create_mode == OS_FILE_OPEN) {
  308. create_flag = O_RDWR;
  309. } else if (create_mode == OS_FILE_CREATE) {
  310. create_flag = O_RDWR | O_CREAT | O_EXCL;
  311. } else if (create_mode == OS_FILE_OVERWRITE) {
  312. create_flag = O_RDWR | O_CREAT | O_TRUNC;
  313. } else {
  314. create_flag = 0;
  315. ut_error;
  316. }
  318. UT_NOT_USED(purpose);
  320. if (create_mode == OS_FILE_CREATE) {
  321. #ifndef S_IRWXU
  322.                 file = open(name, create_flag);
  323. #else
  324.         file = open(name, create_flag, S_IRWXU | S_IRWXG | S_IRWXO);
  325. #endif
  326.         } else {
  327.                 file = open(name, create_flag);
  328.         }
  330. if (file == -1) {
  331. *success = FALSE;
  333. if (create_mode != OS_FILE_OPEN
  334.     && errno == ENOSPC) {
  336. retry = os_file_handle_error(file, name);
  338. if (retry) {
  339. goto try_again;
  340. }
  341. }
  342. } else {
  343. *success = TRUE;
  344. }
  346. return(file);
  347. #endif
  348. }
  350. /***************************************************************************
  351. Closes a file handle. In case of error, error number can be retrieved with
  352. os_file_get_last_error. */
  354. ibool
  355. os_file_close(
  356. /*==========*/
  357. /* out: TRUE if success */
  358. os_file_t file) /* in, own: handle to a file */
  359. {
  360. #ifdef __WIN__
  361. BOOL ret;
  363. ut_a(file);
  365. ret = CloseHandle(file);
  367. if (ret) {
  368. return(TRUE);
  369. }
  371. return(FALSE);
  372. #else
  373. int ret;
  375. ret = close(file);
  377. if (ret == -1) {
  378. return(FALSE);
  379. }
  381. return(TRUE);
  382. #endif
  383. }
  385. /***************************************************************************
  386. Gets a file size. */
  388. ibool
  389. os_file_get_size(
  390. /*=============*/
  391. /* out: TRUE if success */
  392. os_file_t file, /* in: handle to a file */
  393. ulint* size, /* out: least significant 32 bits of file
  394. size */
  395. ulint* size_high)/* out: most significant 32 bits of size */
  396. {
  397. #ifdef __WIN__
  398. DWORD high;
  399. DWORD low;
  401. low = GetFileSize(file, &high);
  403. if ((low == 0xFFFFFFFF) && (GetLastError() != NO_ERROR)) {
  404. return(FALSE);
  405. }
  407. *size = low;
  408. *size_high = high;
  410. return(TRUE);
  411. #else
  412. *size = (ulint) lseek(file, 0, SEEK_END);
  413. *size_high = 0;
  415. return(TRUE);
  416. #endif
  417. }
  419. /***************************************************************************
  420. Sets a file size. This function can be used to extend or truncate a file. */
  422. ibool
  423. os_file_set_size(
  424. /*=============*/
  425. /* out: TRUE if success */
  426. char* name, /* in: name of the file or path as a
  427. null-terminated string */
  428. os_file_t file, /* in: handle to a file */
  429. ulint size, /* in: least significant 32 bits of file
  430. size */
  431. ulint size_high)/* in: most significant 32 bits of size */
  432. {
  433. ulint   offset;
  434. ulint   n_bytes;
  435. ulint low;
  436. ibool ret;
  437. ibool retry;
  438. ulint   i;
  439. byte*   buf;
  441. try_again:
  442. buf = ut_malloc(UNIV_PAGE_SIZE * 64);
  444. /* Write buffer full of zeros */
  445. for (i = 0; i < UNIV_PAGE_SIZE * 64; i++) {
  446.         buf[i] = '';
  447. }
  449. offset = 0;
  450. low = size;
  451. #if (UNIV_WORD_SIZE == 8)
  452. low = low + (size_high << 32);
  453. #else
  454. UT_NOT_USED(size_high);
  455. #endif
  456. while (offset < low) {
  457.         if (low - offset < UNIV_PAGE_SIZE * 64) {
  458.                  n_bytes = low - offset;
  459.         } else {
  460.                  n_bytes = UNIV_PAGE_SIZE * 64;
  461.         }
  462.   
  463.         ret = os_file_write(name, file, buf, offset, 0, n_bytes);
  465.         if (!ret) {
  466. ut_free(buf);
  467.           goto error_handling;
  468.         }
  469.         offset += n_bytes;
  470. }
  472. ut_free(buf);
  474. ret = os_file_flush(file);
  476. if (ret) {
  477.         return(TRUE);
  478. }
  480. error_handling:
  481. retry = os_file_handle_error(file, name); 
  483. if (retry) {
  484. goto try_again;
  485. }
  487. ut_error;
  489. return(FALSE);
  490. }
  492. /***************************************************************************
  493. Flushes the write buffers of a given file to the disk. */
  495. ibool
  496. os_file_flush(
  497. /*==========*/
  498. /* out: TRUE if success */
  499. os_file_t file) /* in, own: handle to a file */
  500. {
  501. #ifdef __WIN__
  502. BOOL ret;
  504. ut_a(file);
  506. ret = FlushFileBuffers(file);
  508. if (ret) {
  509. return(TRUE);
  510. }
  512. return(FALSE);
  513. #else
  514. int ret;
  516. ret = fsync(file);
  518. if (ret == 0) {
  519. return(TRUE);
  520. }
  522. return(FALSE);
  523. #endif
  524. }
  527. #ifndef __WIN__
  528. /***********************************************************************
  529. Does a synchronous read operation in Posix. */
  530. static
  531. ssize_t
  532. os_file_pread(
  533. /*==========*/
  534. /* out: number of bytes read, -1 if error */
  535. os_file_t file, /* in: handle to a file */
  536. void* buf, /* in: buffer where to read */
  537. ulint n, /* in: number of bytes to read */
  538. ulint offset) /* in: offset from where to read */
  539. {
  540. #ifdef HAVE_PREAD
  541. return(pread(file, buf, n, (off_t) offset));
  542. #else
  543. ssize_t ret;
  544. ulint i;
  546. /* Protect the seek / read operation with a mutex */
  547. i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
  549. os_mutex_enter(os_file_seek_mutexes[i]);
  551. ret = lseek(file, (off_t) offset, 0);
  553. if (ret < 0) {
  554. os_mutex_exit(os_file_seek_mutexes[i]);
  556. return(ret);
  557. }
  559. ret = read(file, buf, n);
  561. os_mutex_exit(os_file_seek_mutexes[i]);
  563. return(ret);
  564. #endif
  565. }
  567. /***********************************************************************
  568. Does a synchronous write operation in Posix. */
  569. static
  570. ssize_t
  571. os_file_pwrite(
  572. /*===========*/
  573. /* out: number of bytes written, -1 if error */
  574. os_file_t file, /* in: handle to a file */
  575. void* buf, /* in: buffer from where to write */
  576. ulint n, /* in: number of bytes to write */
  577. ulint offset) /* in: offset where to write */
  578. {
  579. #ifdef HAVE_PWRITE
  580. return(pwrite(file, buf, n, (off_t) offset));
  581. #else
  582. ssize_t ret;
  583. ulint i;
  585. /* Protect the seek / write operation with a mutex */
  586. i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
  588. os_mutex_enter(os_file_seek_mutexes[i]);
  590. ret = lseek(file, (off_t) offset, 0);
  592. if (ret < 0) {
  593. os_mutex_exit(os_file_seek_mutexes[i]);
  595. return(ret);
  596. }
  598. ret = write(file, buf, n);
  600. os_mutex_exit(os_file_seek_mutexes[i]);
  602. return(ret);
  603. #endif
  604. }
  605. #endif
  607. /***********************************************************************
  608. Requests a synchronous positioned read operation. */
  610. ibool
  611. os_file_read(
  612. /*=========*/
  613. /* out: TRUE if request was
  614. successful, FALSE if fail */
  615. os_file_t file, /* in: handle to a file */
  616. void* buf, /* in: buffer where to read */
  617. ulint offset, /* in: least significant 32 bits of file
  618. offset where to read */
  619. ulint offset_high, /* in: most significant 32 bits of
  620. offset */
  621. ulint n) /* in: number of bytes to read */
  622. {
  623. #ifdef __WIN__
  624. BOOL ret;
  625. DWORD len;
  626. DWORD ret2;
  627. DWORD err;
  628. DWORD low;
  629. DWORD high;
  630. ibool retry;
  631. ulint i;
  633. try_again:
  634. ut_ad(file);
  635. ut_ad(buf);
  636. ut_ad(n > 0);
  638. low = offset;
  639. high = offset_high;
  641. /* Protect the seek / read operation with a mutex */
  642. i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
  644. os_mutex_enter(os_file_seek_mutexes[i]);
  646. ret2 = SetFilePointer(file, low, &high, FILE_BEGIN);
  648. if (ret2 == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
  649. err = GetLastError();
  651. os_mutex_exit(os_file_seek_mutexes[i]);
  653. goto error_handling;
  654. } 
  656. ret = ReadFile(file, buf, n, &len, NULL);
  658. os_mutex_exit(os_file_seek_mutexes[i]);
  660. if (ret && len == n) {
  661. return(TRUE);
  662. }
  664. err = GetLastError();
  665. #else
  666. ibool retry;
  667. ssize_t ret;
  668. ulint   i;
  670. #if (UNIV_WORD_SIZE == 8)
  671. offset = offset + (offset_high << 32);
  672. #else
  673. UT_NOT_USED(offset_high);
  674. #endif
  675. try_again:
  676. /* Protect the seek / read operation with a mutex */
  677. i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
  679. os_mutex_enter(os_file_seek_mutexes[i]);
  681. ret = os_file_pread(file, buf, n, (off_t) offset);
  683. if ((ulint)ret == n) {
  684. os_mutex_exit(os_file_seek_mutexes[i]);
  686. return(TRUE);
  687. }
  688. #endif
  689. error_handling:
  690. retry = os_file_handle_error(file, NULL); 
  692. if (retry) {
  693. goto try_again;
  694. }
  696. ut_error;
  698. return(FALSE);
  699. }
  701. /***********************************************************************
  702. Requests a synchronous write operation. */
  704. ibool
  705. os_file_write(
  706. /*==========*/
  707. /* out: TRUE if request was
  708. successful, FALSE if fail */
  709. char* name, /* in: name of the file or path as a
  710. null-terminated string */
  711. os_file_t file, /* in: handle to a file */
  712. void* buf, /* in: buffer from which to write */
  713. ulint offset, /* in: least significant 32 bits of file
  714. offset where to write */
  715. ulint offset_high, /* in: most significant 32 bits of
  716. offset */
  717. ulint n) /* in: number of bytes to write */
  718. {
  719. #ifdef __WIN__
  720. BOOL ret;
  721. DWORD len;
  722. DWORD ret2;
  723. DWORD err;
  724. DWORD low;
  725. DWORD high;
  726. ibool retry;
  727. ulint i;
  729. try_again:
  730. ut_ad(file);
  731. ut_ad(buf);
  732. ut_ad(n > 0);
  734. low = offset;
  735. high = offset_high;
  737. /* Protect the seek / write operation with a mutex */
  738. i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
  740. os_mutex_enter(os_file_seek_mutexes[i]);
  742. ret2 = SetFilePointer(file, low, &high, FILE_BEGIN);
  744. if (ret2 == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
  745. err = GetLastError();
  747. os_mutex_exit(os_file_seek_mutexes[i]);
  749. goto error_handling;
  750. } 
  752. ret = WriteFile(file, buf, n, &len, NULL);
  754. os_mutex_exit(os_file_seek_mutexes[i]);
  756. if (ret && len == n) {
  757. return(TRUE);
  758. }
  759. #else
  760. ibool retry;
  761. ssize_t ret;
  763. #if (UNIV_WORD_SIZE == 8)
  764. offset = offset + (offset_high << 32);
  765. #else
  766. UT_NOT_USED(offset_high);
  767. #endif
  768. try_again:
  769. ret = pwrite(file, buf, n, (off_t) offset);
  771. if ((ulint)ret == n) {
  772. return(TRUE);
  773. }
  774. #endif
  775. error_handling:
  776. retry = os_file_handle_error(file, name); 
  778. if (retry) {
  779. goto try_again;
  780. }
  782. ut_error;
  784. return(FALSE);
  785. }
  787. /********************************************************************
  788. Returns a pointer to the nth slot in the aio array. */
  789. static
  790. os_aio_slot_t*
  791. os_aio_array_get_nth_slot(
  792. /*======================*/
  793. /* out: pointer to slot */
  794. os_aio_array_t* array, /* in: aio array */
  795. ulint index) /* in: index of the slot */
  796. {
  797. ut_a(index < array->n_slots);
  799. return((array->slots) + index);
  800. }
  802. /****************************************************************************
  803. Creates an aio wait array. */
  804. static
  805. os_aio_array_t*
  806. os_aio_array_create(
  807. /*================*/
  808. /* out, own: aio array */
  809. ulint n, /* in: maximum number of pending aio operations
  810. allowed; n must be divisible by n_segments */
  811. ulint n_segments)  /* in: number of segments in the aio array */
  812. {
  813. os_aio_array_t* array;
  814. ulint i;
  815. os_aio_slot_t* slot;
  816. #ifdef WIN_ASYNC_IO
  817. OVERLAPPED* over;
  818. #endif
  819. ut_a(n > 0);
  820. ut_a(n_segments > 0);
  821. ut_a(n % n_segments == 0);
  823. array = ut_malloc(sizeof(os_aio_array_t));
  825. array->mutex  = os_mutex_create(NULL);
  826. array->not_full = os_event_create(NULL);
  827. array->n_slots   = n;
  828. array->n_segments = n_segments;
  829. array->n_reserved = 0;
  830. array->slots = ut_malloc(n * sizeof(os_aio_slot_t));
  831. array->events = ut_malloc(n * sizeof(os_event_t));
  833. for (i = 0; i < n; i++) {
  834. slot = os_aio_array_get_nth_slot(array, i);
  836. slot->pos = i;
  837. slot->reserved = FALSE;
  838. #ifdef WIN_ASYNC_IO
  839. over = &(slot->control);
  841. over->hEvent = os_event_create(NULL);
  843. *((array->events) + i) = over->hEvent;
  844. #endif
  845. }
  847. return(array);
  848. }
  850. /****************************************************************************
  851. Initializes the asynchronous io system. Creates separate aio array for
  852. non-ibuf read and write, a third aio array for the ibuf i/o, with just one
  853. segment, two aio arrays for log reads and writes with one segment, and a
  854. synchronous aio array of the specified size. The combined number of segments
  855. in the three first aio arrays is the parameter n_segments given to the
  856. function. The caller must create an i/o handler thread for each segment in
  857. the four first arrays, but not for the sync aio array. */
  859. void
  860. os_aio_init(
  861. /*========*/
  862. ulint n, /* in: maximum number of pending aio operations
  863. allowed; n must be divisible by n_segments */
  864. ulint n_segments, /* in: combined number of segments in the four
  865. first aio arrays; must be >= 4 */
  866. ulint n_slots_sync) /* in: number of slots in the sync aio array */
  867. {
  868. ulint n_read_segs;
  869. ulint n_write_segs;
  870. ulint n_per_seg;
  871. ulint i;
  872. #ifdef POSIX_ASYNC_IO
  873. sigset_t   sigset;
  874. #endif
  875. ut_ad(n % n_segments == 0);
  876. ut_ad(n_segments >= 4);
  878. n_per_seg = n / n_segments;
  879. n_write_segs = (n_segments - 2) / 2;
  880. n_read_segs = n_segments - 2 - n_write_segs;
  882. /* printf("Array n per seg %lun", n_per_seg); */
  884. os_aio_read_array = os_aio_array_create(n_read_segs * n_per_seg,
  885. n_read_segs);
  886. os_aio_write_array = os_aio_array_create(n_write_segs * n_per_seg,
  887. n_write_segs);
  888. os_aio_ibuf_array = os_aio_array_create(n_per_seg, 1);
  890. os_aio_log_array = os_aio_array_create(n_per_seg, 1);
  892. os_aio_sync_array = os_aio_array_create(n_slots_sync, 1);
  894. os_aio_n_segments = n_segments;
  896. os_aio_validate();
  898. for (i = 0; i < OS_FILE_N_SEEK_MUTEXES; i++) {
  899. os_file_seek_mutexes[i] = os_mutex_create(NULL);
  900. }
  902. os_aio_segment_wait_events = ut_malloc(n_segments * sizeof(void*));
  904. for (i = 0; i < n_segments; i++) {
  905. os_aio_segment_wait_events[i] = os_event_create(NULL);
  906. }
  908. #ifdef POSIX_ASYNC_IO
  909. /* Block aio signals from the current thread and its children:
  910. for this to work, the current thread must be the first created
  911. in the database, so that all its children will inherit its
  912. signal mask */
  914.         sigemptyset(&sigset);
  915. sigaddset(&sigset, SIGRTMIN + 1 + 0);
  916. sigaddset(&sigset, SIGRTMIN + 1 + 1);
  917. sigaddset(&sigset, SIGRTMIN + 1 + 2);
  918. sigaddset(&sigset, SIGRTMIN + 1 + 3);
  920. pthread_sigmask(SIG_BLOCK, &sigset, NULL);
  921. #endif
  922. }
  924. /**************************************************************************
  925. Calculates segment number for a slot. */
  926. static
  927. ulint
  928. os_aio_get_segment_no_from_slot(
  929. /*============================*/
  930. /* out: segment number (which is the number
  931. used by, for example, i/o-handler threads) */
  932. os_aio_array_t* array, /* in: aio wait array */
  933. os_aio_slot_t* slot) /* in: slot in this array */
  934. {
  935. ulint segment;
  936. ulint seg_len;
  938. if (array == os_aio_ibuf_array) {
  939. segment = 0;
  941. } else if (array == os_aio_log_array) {
  942. segment = 1;
  944. } else if (array == os_aio_read_array) {
  945. seg_len = os_aio_read_array->n_slots /
  946. os_aio_read_array->n_segments;
  948. segment = 2 + slot->pos / seg_len;
  949. } else {
  950. ut_a(array == os_aio_write_array);
  951. seg_len = os_aio_write_array->n_slots /
  952. os_aio_write_array->n_segments;
  954. segment = os_aio_read_array->n_segments + 2
  955. + slot->pos / seg_len;
  956. }
  958. return(segment);
  959. }
  961. /**************************************************************************
  962. Calculates local segment number and aio array from global segment number. */
  963. static
  964. ulint
  965. os_aio_get_array_and_local_segment(
  966. /*===============================*/
  967. /* out: local segment number within
  968. the aio array */
  969. os_aio_array_t** array, /* out: aio wait array */
  970. ulint  global_segment)/* in: global segment number */
  971. {
  972. ulint segment;
  974. ut_a(global_segment < os_aio_n_segments);
  976. if (global_segment == 0) {
  977. *array = os_aio_ibuf_array;
  978. segment = 0;
  980. } else if (global_segment == 1) {
  981. *array = os_aio_log_array;
  982. segment = 0;
  984. } else if (global_segment < os_aio_read_array->n_segments + 2) {
  985. *array = os_aio_read_array;
  987. segment = global_segment - 2;
  988. } else {
  989. *array = os_aio_write_array;
  991. segment = global_segment - (os_aio_read_array->n_segments + 2);
  992. }
  994. return(segment);
  995. }
  997. /***********************************************************************
  998. Gets an integer value designating a specified aio array. This is used
  999. to give numbers to signals in Posix aio. */
  1000. static
  1001. ulint
  1002. os_aio_get_array_no(
  1003. /*================*/
  1004. os_aio_array_t* array) /* in: aio array */
  1005. {
  1006. if (array == os_aio_ibuf_array) {
  1008. return(0);
  1010. } else if (array == os_aio_log_array) {
  1012. return(1);
  1014. } else if (array == os_aio_read_array) {
  1016. return(2);
  1017. } else if (array == os_aio_write_array) {
  1019. return(3);
  1020. } else {
  1021. ut_a(0);
  1023. return(0);
  1024. }
  1025. }
  1027. /***********************************************************************
  1028. Gets the aio array for its number. */
  1029. static
  1030. os_aio_array_t*
  1031. os_aio_get_array_from_no(
  1032. /*=====================*/
  1033. /* out: aio array */
  1034. ulint n) /* in: array number */
  1035. {
  1036. if (n == 0) {
  1037. return(os_aio_ibuf_array);
  1038. } else if (n == 1) {
  1040. return(os_aio_log_array);
  1041. } else if (n == 2) {
  1043. return(os_aio_read_array);
  1044. } else if (n == 3) {
  1046. return(os_aio_write_array);
  1047. } else {
  1048. ut_a(0);
  1050. return(NULL);
  1051. }
  1052. }
  1054. /***********************************************************************
  1055. Requests for a slot in the aio array. If no slot is available, waits until
  1056. not_full-event becomes signaled. */
  1057. static
  1058. os_aio_slot_t*
  1059. os_aio_array_reserve_slot(
  1060. /*======================*/
  1061. /* out: pointer to slot */
  1062. ulint type, /* in: OS_FILE_READ or OS_FILE_WRITE */
  1063. os_aio_array_t* array, /* in: aio array */
  1064. void* message1,/* in: message to be passed along with
  1065. the aio operation */
  1066. void* message2,/* in: message to be passed along with
  1067. the aio operation */
  1068. os_file_t file, /* in: file handle */
  1069. char* name, /* in: name of the file or path as a
  1070. null-terminated string */
  1071. void* buf, /* in: buffer where to read or from which
  1072. to write */
  1073. ulint offset, /* in: least significant 32 bits of file
  1074. offset */
  1075. ulint offset_high, /* in: most significant 32 bits of
  1076. offset */
  1077. ulint len) /* in: length of the block to read or write */
  1078. {
  1079. os_aio_slot_t* slot;
  1080. #ifdef WIN_ASYNC_IO
  1081. OVERLAPPED* control;
  1083. #elif defined(POSIX_ASYNC_IO)
  1085. struct aiocb* control;
  1086. #endif
  1087. ulint i;
  1088. loop:
  1089. os_mutex_enter(array->mutex);
  1091. if (array->n_reserved == array->n_slots) {
  1092. os_mutex_exit(array->mutex);
  1094. if (!os_aio_use_native_aio) {
  1095. /* If the handler threads are suspended, wake them
  1096. so that we get more slots */
  1098. os_aio_simulated_wake_handler_threads();
  1099. }
  1101. os_event_wait(array->not_full);
  1103. goto loop;
  1104. }
  1106. for (i = 0;; i++) {
  1107. slot = os_aio_array_get_nth_slot(array, i);
  1109. if (slot->reserved == FALSE) {
  1110. break;
  1111. }
  1112. }
  1114. array->n_reserved++;
  1116. if (array->n_reserved == array->n_slots) {
  1117. os_event_reset(array->not_full);
  1118. }
  1120. slot->reserved = TRUE;
  1121. slot->message1 = message1;
  1122. slot->message2 = message2;
  1123. slot->file     = file;
  1124. slot->name     = name;
  1125. slot->len      = len;
  1126. slot->type     = type;
  1127. slot->buf      = buf;
  1128. slot->offset   = offset;
  1129. slot->offset_high = offset_high;
  1130. slot->io_already_done = FALSE;
  1132. #ifdef WIN_ASYNC_IO
  1133. control = &(slot->control);
  1134. control->Offset = (DWORD)offset;
  1135. control->OffsetHigh = (DWORD)offset_high;
  1136. os_event_reset(control->hEvent);
  1138. #elif defined(POSIX_ASYNC_IO)
  1140. #if (UNIV_WORD_SIZE == 8)
  1141. offset = offset + (offset_high << 32);
  1142. #else
  1143. ut_a(offset_high == 0);
  1144. #endif 
  1145. control = &(slot->control);
  1146. control->aio_fildes = file;
  1147. control->aio_buf = buf;
  1148. control->aio_nbytes = len;
  1149. control->aio_offset = offset;
  1150. control->aio_reqprio = 0;
  1151. control->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
  1152. control->aio_sigevent.sigev_signo =
  1153. SIGRTMIN + 1 + os_aio_get_array_no(array);
  1154. /* TODO: How to choose the signal numbers? */
  1155. /*
  1156. printf("AIO signal number %lun", (ulint) control->aio_sigevent.sigev_signo);
  1157. */
  1158. control->aio_sigevent.sigev_value.sival_ptr = slot;
  1159. #endif
  1160. os_mutex_exit(array->mutex);
  1162. return(slot);
  1163. }
  1165. /***********************************************************************
  1166. Frees a slot in the aio array. */
  1167. static
  1168. void
  1169. os_aio_array_free_slot(
  1170. /*===================*/
  1171. os_aio_array_t* array, /* in: aio array */
  1172. os_aio_slot_t* slot) /* in: pointer to slot */
  1173. {
  1174. ut_ad(array);
  1175. ut_ad(slot);
  1177. os_mutex_enter(array->mutex);
  1179. ut_ad(slot->reserved);
  1181. slot->reserved = FALSE;
  1183. array->n_reserved--;
  1185. if (array->n_reserved == array->n_slots - 1) {
  1186. os_event_set(array->not_full);
  1187. }
  1189. #ifdef WIN_ASYNC_IO
  1190. os_event_reset(slot->control.hEvent);
  1191. #endif
  1192. os_mutex_exit(array->mutex);
  1193. }
  1195. /**************************************************************************
  1196. Wakes up a simulated aio i/o-handler thread if it has something to do. */
  1197. static
  1198. void
  1199. os_aio_simulated_wake_handler_thread(
  1200. /*=================================*/
  1201. ulint global_segment) /* in: the number of the segment in the aio
  1202. arrays */
  1203. {
  1204. os_aio_array_t* array;
  1205. ulint segment;
  1206. os_aio_slot_t* slot;
  1207. ulint n;
  1208. ulint i;
  1210. ut_ad(!os_aio_use_native_aio);
  1212. segment = os_aio_get_array_and_local_segment(&array, global_segment);
  1214. n = array->n_slots / array->n_segments;
  1216. /* Look through n slots after the segment * n'th slot */
  1218. os_mutex_enter(array->mutex);
  1220. for (i = 0; i < n; i++) {
  1221. slot = os_aio_array_get_nth_slot(array, i + segment * n);
  1223. if (slot->reserved) {
  1224. /* Found an i/o request */
  1226. break;
  1227. }
  1228. }
  1230. os_mutex_exit(array->mutex);
  1232. if (i < n) {
  1233. os_event_set(os_aio_segment_wait_events[global_segment]);
  1234. }
  1235. }
  1237. /**************************************************************************
  1238. Wakes up simulated aio i/o-handler threads if they have something to do. */
  1240. void
  1241. os_aio_simulated_wake_handler_threads(void)
  1242. /*=======================================*/
  1243. {
  1244. ulint i;
  1246. if (os_aio_use_native_aio) {
  1247. /* We do not use simulated aio: do nothing */
  1249. return;
  1250. }
  1252. for (i = 0; i < os_aio_n_segments; i++) {
  1253. os_aio_simulated_wake_handler_thread(i);
  1254. }
  1255. }
  1257. /***********************************************************************
  1258. Requests an asynchronous i/o operation. */
  1260. ibool
  1261. os_aio(
  1262. /*===*/
  1263. /* out: TRUE if request was queued
  1264. successfully, FALSE if fail */
  1265. ulint type, /* in: OS_FILE_READ or OS_FILE_WRITE */
  1266. ulint mode, /* in: OS_AIO_NORMAL, ..., possibly ORed
  1267. to OS_AIO_SIMULATED_WAKE_LATER: the
  1268. last flag advises this function not to wake
  1269. i/o-handler threads, but the caller will
  1270. do the waking explicitly later, in this
  1271. way the caller can post several requests in
  1272. a batch; NOTE that the batch must not be
  1273. so big that it exhausts the slots in aio
  1274. arrays! NOTE that a simulated batch
  1275. may introduce hidden chances of deadlocks,
  1276. because i/os are not actually handled until
  1277. all have been posted: use with great
  1278. caution! */
  1279. char* name, /* in: name of the file or path as a
  1280. null-terminated string */
  1281. os_file_t file, /* in: handle to a file */
  1282. void* buf, /* in: buffer where to read or from which
  1283. to write */
  1284. ulint offset, /* in: least significant 32 bits of file
  1285. offset where to read or write */
  1286. ulint offset_high, /* in: most significant 32 bits of
  1287. offset */
  1288. ulint n, /* in: number of bytes to read or write */
  1289. void* message1,/* in: messages for the aio handler (these
  1290. can be used to identify a completed aio
  1291. operation); if mode is OS_AIO_SYNC, these
  1292. are ignored */
  1293. void* message2)
  1294. {
  1295. os_aio_array_t* array;
  1296. os_aio_slot_t* slot;
  1297. #ifdef WIN_ASYNC_IO
  1298. BOOL ret = TRUE;
  1299. DWORD len = n;
  1300. void* dummy_mess1;
  1301. void* dummy_mess2;
  1302. #endif
  1303. ulint err = 0;
  1304. ibool retry;
  1305. ulint wake_later;
  1307. ut_ad(file);
  1308. ut_ad(buf);
  1309. ut_ad(n > 0);
  1310. ut_ad(n % OS_FILE_LOG_BLOCK_SIZE == 0);
  1311. ut_ad((ulint)buf % OS_FILE_LOG_BLOCK_SIZE == 0)
  1312. ut_ad(offset % OS_FILE_LOG_BLOCK_SIZE == 0);
  1313. ut_ad(os_aio_validate());
  1315. wake_later = mode & OS_AIO_SIMULATED_WAKE_LATER;
  1316. mode = mode & (~OS_AIO_SIMULATED_WAKE_LATER);
  1318. if (mode == OS_AIO_SYNC
  1319. #ifdef WIN_ASYNC_IO
  1320. && !os_aio_use_native_aio
  1321. #endif
  1322. ) {
  1323. /* This is actually an ordinary synchronous read or write:
  1324. no need to use an i/o-handler thread. NOTE that if we use
  1325. Windows async i/o, Windows does not allow us to use
  1326. ordinary synchronous os_file_read etc. on the same file,
  1327. therefore we have built a special mechanism for synchronous
  1328. wait in the Windows case. */
  1330. if (type == OS_FILE_READ) {
  1331. return(os_file_read(file, buf, offset, offset_high, n));
  1332. }
  1334. ut_a(type == OS_FILE_WRITE);
  1336. return(os_file_write(name, file, buf, offset, offset_high, n));
  1337. }
  1339. try_again:
  1340. if (mode == OS_AIO_NORMAL) {
  1341. if (type == OS_FILE_READ) {
  1342. array = os_aio_read_array;
  1343. } else {
  1344. array = os_aio_write_array;
  1345. }
  1346. } else if (mode == OS_AIO_IBUF) {
  1347. ut_ad(type == OS_FILE_READ);
  1349. array = os_aio_ibuf_array;
  1350. } else if (mode == OS_AIO_LOG) {
  1352. array = os_aio_log_array;
  1353. } else if (mode == OS_AIO_SYNC) {
  1354. array = os_aio_sync_array;
  1355. } else {
  1356. ut_error;
  1357. }
  1359. slot = os_aio_array_reserve_slot(type, array, message1, message2, file,
  1360. name, buf, offset, offset_high, n);
  1361. if (type == OS_FILE_READ) {
  1362. if (os_aio_use_native_aio) {
  1363. #ifdef WIN_ASYNC_IO
  1364. ret = ReadFile(file, buf, (DWORD)n, &len,
  1365. &(slot->control));
  1366. #elif defined(POSIX_ASYNC_IO)
  1367. slot->control.aio_lio_opcode = LIO_READ;
  1368. err = (ulint) aio_read(&(slot->control));
  1369. printf("Starting Posix aio read %lun", err);
  1370. #endif
  1371. } else {
  1372. if (!wake_later) {
  1373. os_aio_simulated_wake_handler_thread(
  1374.  os_aio_get_segment_no_from_slot(array, slot));
  1375. }
  1376. }
  1377. } else if (type == OS_FILE_WRITE) {
  1378. if (os_aio_use_native_aio) {
  1379. #ifdef WIN_ASYNC_IO
  1380. ret = WriteFile(file, buf, (DWORD)n, &len,
  1381. &(slot->control));
  1382. #elif defined(POSIX_ASYNC_IO)
  1383. slot->control.aio_lio_opcode = LIO_WRITE;
  1384. err = (ulint) aio_write(&(slot->control));
  1385. printf("Starting Posix aio write %lun", err);
  1386. #endif
  1387. } else {
  1388. if (!wake_later) {
  1389. os_aio_simulated_wake_handler_thread(
  1390.  os_aio_get_segment_no_from_slot(array, slot));
  1391. }
  1392. }
  1393. } else {
  1394. ut_error;
  1395. }
  1397. #ifdef WIN_ASYNC_IO
  1398. if (os_aio_use_native_aio) {
  1399. if ((ret && len == n)
  1400. || (!ret && GetLastError() == ERROR_IO_PENDING)) {
  1402. /* aio was queued successfully! */
  1404.      if (mode == OS_AIO_SYNC) {
  1405.          /* We want a synchronous i/o operation on a file
  1406.          where we also use async i/o: in Windows we must
  1407.          use the same wait mechanism as for async i/o */
  1408.     
  1409.          return(os_aio_windows_handle(ULINT_UNDEFINED,
  1410. slot->pos,
  1411.      &dummy_mess1, &dummy_mess2));
  1412.      }
  1414. return(TRUE);
  1415. }
  1417. goto error_handling;
  1418. }
  1419. #endif
  1420. if (err == 0) {
  1421. /* aio was queued successfully! */
  1423. return(TRUE);
  1424. }
  1426. os_aio_array_free_slot(array, slot);
  1428. retry = os_file_handle_error(file, name);
  1430. if (retry) {
  1432. goto try_again;
  1433. }
  1435. ut_error;
  1437. return(FALSE);
  1438. }
  1440. #ifdef WIN_ASYNC_IO
  1441. /**************************************************************************
  1442. This function is only used in Windows asynchronous i/o.
  1443. Waits for an aio operation to complete. This function is used to wait the
  1444. for completed requests. The aio array of pending requests is divided
  1445. into segments. The thread specifies which segment or slot it wants to wait
  1446. for. NOTE: this function will also take care of freeing the aio slot,
  1447. therefore no other thread is allowed to do the freeing! */
  1449. ibool
  1450. os_aio_windows_handle(
  1451. /*==================*/
  1452. /* out: TRUE if the aio operation succeeded */
  1453. ulint segment, /* in: the number of the segment in the aio
  1454. arrays to wait for; segment 0 is the ibuf
  1455. i/o thread, segment 1 the log i/o thread,
  1456. then follow the non-ibuf read threads, and as
  1457. the last are the non-ibuf write threads; if
  1458. this is ULINT_UNDEFINED, then it means that
  1459. sync aio is used, and this parameter is
  1460. ignored */
  1461. ulint pos, /* this parameter is used only in sync aio:
  1462. wait for the aio slot at this position */  
  1463. void** message1, /* out: the messages passed with the aio
  1464. request; note that also in the case where
  1465. the aio operation failed, these output
  1466. parameters are valid and can be used to
  1467. restart the operation, for example */
  1468. void** message2)
  1469. {
  1470. os_aio_array_t* array;
  1471. os_aio_slot_t* slot;
  1472. ulint n;
  1473. ulint i;
  1474. ibool ret_val;
  1475. ulint err;
  1476. BOOL ret;
  1477. DWORD len;
  1479. if (segment == ULINT_UNDEFINED) {
  1480. array = os_aio_sync_array;
  1481. segment = 0;
  1482. } else {
  1483. segment = os_aio_get_array_and_local_segment(&array, segment);
  1484. }
  1486. /* NOTE! We only access constant fields in os_aio_array. Therefore
  1487. we do not have to acquire the protecting mutex yet */
  1489. ut_ad(os_aio_validate());
  1490. ut_ad(segment < array->n_segments);
  1492. n = array->n_slots / array->n_segments;
  1494. if (array == os_aio_sync_array) {
  1495. ut_ad(pos < array->n_slots); 
  1496. os_event_wait(array->events[pos]);
  1497. i = pos;
  1498. } else {
  1499. i = os_event_wait_multiple(n, (array->events) + segment * n);
  1500. }
  1502. os_mutex_enter(array->mutex);
  1504. slot = os_aio_array_get_nth_slot(array, i + segment * n);
  1506. ut_a(slot->reserved);
  1508. ret = GetOverlappedResult(slot->file, &(slot->control), &len, TRUE);
  1510. *message1 = slot->message1;
  1511. *message2 = slot->message2;
  1513. if (ret && len == slot->len) {
  1514. ret_val = TRUE;
  1515. } else {
  1516. err = GetLastError();
  1517. ut_error;
  1519. ret_val = FALSE;
  1520. }   
  1522. os_mutex_exit(array->mutex);
  1524. os_aio_array_free_slot(array, slot);
  1526. return(ret_val);
  1527. }
  1528. #endif
  1530. #ifdef POSIX_ASYNC_IO
  1532. /**************************************************************************
  1533. This function is only used in Posix asynchronous i/o. Waits for an aio
  1534. operation to complete. */
  1536. ibool
  1537. os_aio_posix_handle(
  1538. /*================*/
  1539. /* out: TRUE if the aio operation succeeded */
  1540. ulint array_no, /* in: array number 0 - 3 */
  1541. void** message1, /* out: the messages passed with the aio
  1542. request; note that also in the case where
  1543. the aio operation failed, these output
  1544. parameters are valid and can be used to
  1545. restart the operation, for example */
  1546. void** message2)
  1547. {
  1548. os_aio_array_t* array;
  1549. os_aio_slot_t* slot;
  1550. siginfo_t info;
  1551. sigset_t sigset;
  1552. sigset_t        proc_sigset;
  1553. sigset_t        thr_sigset;
  1554. int ret;
  1555. int             i;
  1556. int             sig;
  1558.         sigemptyset(&sigset);
  1559. sigaddset(&sigset, SIGRTMIN + 1 + array_no);
  1561. pthread_sigmask(SIG_UNBLOCK, &sigset, NULL);
  1563. /*
  1564. sigprocmask(0, NULL, &proc_sigset);
  1565. pthread_sigmask(0, NULL, &thr_sigset);
  1567. for (i = 32 ; i < 40; i++) {
  1568.   printf("%lu : %lu %lun", (ulint)i,
  1569.  (ulint)sigismember(&proc_sigset, i),
  1570.  (ulint)sigismember(&thr_sigset, i));
  1571. }
  1572. */
  1574. ret = sigwaitinfo(&sigset, &info);
  1576. if (sig != SIGRTMIN + 1 + array_no) {
  1578. ut_a(0);
  1580. return(FALSE);
  1581. }
  1583. printf("Handling Posix aion");
  1585. array = os_aio_get_array_from_no(array_no);
  1587. os_mutex_enter(array->mutex);
  1589. slot = info.si_value.sival_ptr;
  1591. ut_a(slot->reserved);
  1593. *message1 = slot->message1;
  1594. *message2 = slot->message2;
  1596. os_mutex_exit(array->mutex);
  1598. os_aio_array_free_slot(array, slot);
  1600. return(TRUE);
  1601. }
  1602. #endif
  1604. /**************************************************************************
  1605. Does simulated aio. This function should be called by an i/o-handler
  1606. thread. */
  1608. ibool
  1609. os_aio_simulated_handle(
  1610. /*====================*/
  1611. /* out: TRUE if the aio operation succeeded */
  1612. ulint global_segment, /* in: the number of the segment in the aio
  1613. arrays to wait for; segment 0 is the ibuf
  1614. i/o thread, segment 1 the log i/o thread,
  1615. then follow the non-ibuf read threads, and as
  1616. the last are the non-ibuf write threads */
  1617. void** message1, /* out: the messages passed with the aio
  1618. request; note that also in the case where
  1619. the aio operation failed, these output
  1620. parameters are valid and can be used to
  1621. restart the operation, for example */
  1622. void** message2)
  1623. {
  1624. os_aio_array_t* array;
  1625. ulint segment;
  1626. os_aio_slot_t* slot;
  1627. os_aio_slot_t* slot2;
  1628. os_aio_slot_t* consecutive_ios[OS_AIO_MERGE_N_CONSECUTIVE];
  1629. ulint n_consecutive;
  1630. ulint total_len;
  1631. ulint offs;
  1632. ulint lowest_offset;
  1633. byte* combined_buf;
  1634. ibool ret;
  1635. ulint n;
  1636. ulint i;
  1638. segment = os_aio_get_array_and_local_segment(&array, global_segment);
  1640. restart:
  1641. /* Give other threads chance to add several i/os to the array
  1642. at once */
  1644. os_thread_yield();
  1646. /* NOTE! We only access constant fields in os_aio_array. Therefore
  1647. we do not have to acquire the protecting mutex yet */
  1649. ut_ad(os_aio_validate());
  1650. ut_ad(segment < array->n_segments);
  1652. n = array->n_slots / array->n_segments;
  1654. /* Look through n slots after the segment * n'th slot */
  1656. os_mutex_enter(array->mutex);
  1658. /* Check if there is a slot for which the i/o has already been
  1659. done */
  1661. for (i = 0; i < n; i++) {
  1662. slot = os_aio_array_get_nth_slot(array, i + segment * n);
  1664. if (slot->reserved && slot->io_already_done) {
  1666. ret = TRUE;
  1668. goto slot_io_done;
  1669. }
  1670. }
  1672. n_consecutive = 0;
  1674. /* Look for an i/o request at the lowest offset in the array */
  1676. lowest_offset = ULINT_MAX;
  1678. for (i = 0; i < n; i++) {
  1679. slot = os_aio_array_get_nth_slot(array, i + segment * n);
  1681. if (slot->reserved && slot->offset < lowest_offset) {
  1683. /* Found an i/o request */
  1684. consecutive_ios[0] = slot;
  1686. n_consecutive = 1;
  1688. lowest_offset = slot->offset;
  1689. }
  1690. }
  1692. if (n_consecutive == 0) {
  1694. /* No i/o requested at the moment */
  1696. goto wait_for_io;
  1697. }
  1699. slot = consecutive_ios[0];
  1701. /* Check if there are several consecutive blocks to read or write */
  1703. consecutive_loop:
  1704. for (i = 0; i < n; i++) {
  1705. slot2 = os_aio_array_get_nth_slot(array, i + segment * n);
  1707. if (slot2->reserved && slot2 != slot
  1708.     && slot2->offset == slot->offset + slot->len
  1709.     && slot->offset + slot->len > slot->offset /* check that
  1710. sum does not wrap over */
  1711.     && slot2->offset_high == slot->offset_high
  1712.     && slot2->type == slot->type
  1713.     && slot2->file == slot->file) {
  1715. /* Found a consecutive i/o request */
  1717. consecutive_ios[n_consecutive] = slot2;
  1718. n_consecutive++;
  1720. slot = slot2;
  1722. if (n_consecutive < OS_AIO_MERGE_N_CONSECUTIVE) {
  1724. goto consecutive_loop;
  1725. } else {
  1726. break;
  1727. }
  1728. }
  1729. }
  1731. /* We have now collected n_consecutive i/o requests in the array;
  1732. allocate a single buffer which can hold all data, and perform the
  1733. i/o */
  1735. total_len = 0;
  1736. slot = consecutive_ios[0];
  1738. for (i = 0; i < n_consecutive; i++) {
  1739. total_len += consecutive_ios[i]->len;
  1740. }
  1742. if (n_consecutive == 1) {
  1743. /* We can use the buffer of the i/o request */
  1744. combined_buf = slot->buf;
  1745. } else {
  1746. combined_buf = ut_malloc(total_len);
  1748. ut_a(combined_buf);
  1749. }
  1751. /* We release the array mutex for the time of the i/o: NOTE that
  1752. this assumes that there is just one i/o-handler thread serving
  1753. a single segment of slots! */
  1755. os_mutex_exit(array->mutex);
  1757. if (slot->type == OS_FILE_WRITE && n_consecutive > 1) {
  1758. /* Copy the buffers to the combined buffer */
  1759. offs = 0;
  1761. for (i = 0; i < n_consecutive; i++) {
  1763. ut_memcpy(combined_buf + offs, consecutive_ios[i]->buf,
  1764. consecutive_ios[i]->len);
  1765. offs += consecutive_ios[i]->len;
  1766. }
  1767. }
  1769. /* Do the i/o with ordinary, synchronous i/o functions: */
  1770. if (slot->type == OS_FILE_WRITE) {
  1771. ret = os_file_write(slot->name, slot->file, combined_buf,
  1772. slot->offset, slot->offset_high, total_len);
  1773. } else {
  1774. ret = os_file_read(slot->file, combined_buf,
  1775. slot->offset, slot->offset_high, total_len);
  1776. }
  1778. ut_a(ret);
  1780. /* printf("aio: %lu consecutive %lu:th segment, first offs %lu blocksn",
  1781. n_consecutive, global_segment, slot->offset
  1782. / UNIV_PAGE_SIZE); */
  1784. if (slot->type == OS_FILE_READ && n_consecutive > 1) {
  1785. /* Copy the combined buffer to individual buffers */
  1786. offs = 0;
  1788. for (i = 0; i < n_consecutive; i++) {
  1790. ut_memcpy(consecutive_ios[i]->buf, combined_buf + offs, 
  1791. consecutive_ios[i]->len);
  1792. offs += consecutive_ios[i]->len;
  1793. }
  1794. }
  1796. if (n_consecutive > 1) {
  1797. ut_free(combined_buf);
  1798. }
  1800. os_mutex_enter(array->mutex);
  1802. /* Mark the i/os done in slots */
  1804. for (i = 0; i < n_consecutive; i++) {
  1805. consecutive_ios[i]->io_already_done = TRUE;
  1806. }
  1808. /* We return the messages for the first slot now, and if there were
  1809. several slots, the messages will be returned with subsequent calls
  1810. of this function */
  1812. slot_io_done:
  1814. ut_a(slot->reserved);
  1816. *message1 = slot->message1;
  1817. *message2 = slot->message2;
  1819. os_mutex_exit(array->mutex);
  1821. os_aio_array_free_slot(array, slot);
  1823. return(ret);
  1825. wait_for_io:
  1826. /* We wait here until there again can be i/os in the segment
  1827. of this thread */
  1829. os_event_reset(os_aio_segment_wait_events[global_segment]);
  1831. os_mutex_exit(array->mutex);
  1833. os_event_wait(os_aio_segment_wait_events[global_segment]);
  1835. goto restart;
  1836. }
  1838. /**************************************************************************
  1839. Validates the consistency of an aio array. */
  1840. static
  1841. ibool
  1842. os_aio_array_validate(
  1843. /*==================*/
  1844. /* out: TRUE if ok */
  1845. os_aio_array_t* array) /* in: aio wait array */
  1846. {
  1847. os_aio_slot_t* slot;
  1848. ulint n_reserved = 0;
  1849. ulint i;
  1851. ut_a(array);
  1853. os_mutex_enter(array->mutex);
  1855. ut_a(array->n_slots > 0);
  1856. ut_a(array->n_segments > 0);
  1858. for (i = 0; i < array->n_slots; i++) {
  1859. slot = os_aio_array_get_nth_slot(array, i);
  1861. if (slot->reserved) {
  1862. n_reserved++;
  1863. ut_a(slot->len > 0);
  1864. }
  1865. }
  1867. ut_a(array->n_reserved == n_reserved);
  1869. os_mutex_exit(array->mutex);
  1871. return(TRUE);
  1872. }
  1874. /**************************************************************************
  1875. Validates the consistency the aio system. */
  1877. ibool
  1878. os_aio_validate(void)
  1879. /*=================*/
  1880. /* out: TRUE if ok */
  1881. {
  1882. os_aio_array_validate(os_aio_read_array);
  1883. os_aio_array_validate(os_aio_write_array);
  1884. os_aio_array_validate(os_aio_ibuf_array);
  1885. os_aio_array_validate(os_aio_log_array);
  1886. os_aio_array_validate(os_aio_sync_array);
  1888. return(TRUE);
  1889. }
  1891. /**************************************************************************
  1892. Prints info of the aio arrays. */
  1894. void
  1895. os_aio_print(void)
  1896. /*==============*/
  1897. {
  1898. os_aio_array_t* array;
  1899. os_aio_slot_t* slot;
  1900. ulint n_reserved;
  1901. ulint i;
  1903. array = os_aio_read_array;
  1904. loop:
  1905. ut_a(array);
  1907. printf("INFO OF AN AIO ARRAYn");
  1909. os_mutex_enter(array->mutex);
  1911. ut_a(array->n_slots > 0);
  1912. ut_a(array->n_segments > 0);
  1914. n_reserved = 0;
  1916. for (i = 0; i < array->n_slots; i++) {
  1917. slot = os_aio_array_get_nth_slot(array, i);
  1919. if (slot->reserved) {
  1920. n_reserved++;
  1921. printf("Reserved slot, messages %lx %lxn",
  1922. (ulint)slot->message1,
  1923. (ulint)slot->message2);
  1924. ut_a(slot->len > 0);
  1925. }
  1926. }
  1928. ut_a(array->n_reserved == n_reserved);
  1930. printf("Total of %lu reserved aio slotsn", n_reserved);
  1932. os_mutex_exit(array->mutex);
  1934. if (array == os_aio_read_array) {
  1935. array = os_aio_write_array;
  1937. goto loop;
  1938. }
  1940. if (array == os_aio_write_array) {
  1941. array = os_aio_ibuf_array;
  1943. goto loop;
  1944. }
  1946. if (array == os_aio_ibuf_array) {
  1947. array = os_aio_log_array;
  1949. goto loop;
  1950. }
  1952. if (array == os_aio_log_array) {
  1953. array = os_aio_sync_array;
  1955. goto loop;
  1956. }
  1957. }
  1959. /**************************************************************************
  1960. Checks that all slots in the system have been freed, that is, there are
  1961. no pending io operations. */
  1963. ibool
  1964. os_aio_all_slots_free(void)
  1965. /*=======================*/
  1966. /* out: TRUE if all free */
  1967. {
  1968. os_aio_array_t* array;
  1969. ulint n_res = 0;
  1971. array = os_aio_read_array;
  1973. os_mutex_enter(array->mutex);
  1975. n_res += array->n_reserved; 
  1977. os_mutex_exit(array->mutex);
  1979. array = os_aio_write_array;
  1981. os_mutex_enter(array->mutex);
  1983. n_res += array->n_reserved; 
  1985. os_mutex_exit(array->mutex);
  1987. array = os_aio_ibuf_array;
  1989. os_mutex_enter(array->mutex);
  1991. n_res += array->n_reserved; 
  1993. os_mutex_exit(array->mutex);
  1995. array = os_aio_log_array;
  1997. os_mutex_enter(array->mutex);
  1999. n_res += array->n_reserved; 
  2001. os_mutex_exit(array->mutex);
  2003. array = os_aio_sync_array;
  2005. os_mutex_enter(array->mutex);
  2007. n_res += array->n_reserved; 
  2009. os_mutex_exit(array->mutex);
  2011. if (n_res == 0) {
  2013. return(TRUE);
  2014. }
  2016. return(FALSE);
  2017. }