• os_aio_array_t
  • os_aio_slot_t
  2.  os_aio_slot_t {
  4.   ibool   is_read;  /*!< TRUE if a read operation */
  6.   ulint   pos;    // os_aio_array_t数组中所在的位置 
  8.   ibool   reserved; // TRUE表示该Slot已经被别的IO请求占用了
  10.   time_t    reservation_time; // 占用的时间
  12.   ulint   len;    // io请求的长度
  14.   byte*   buf;    // 数据读取或者需要写入的buffer，通常指向buffer pool的一个页面，压缩页面有特殊处理
  16.   ulint   type;   /* 请求类型，即读还是写IO请求 */ 
  18.   os_offset_t offset;   /*!< file offset in bytes */
  20.   os_file_t file;   /*!< file where to read or write */
  22.   const char* name;   /*!< 需要读取的文件及路径信息 */
  24.   ibool   io_already_done; /* TRUE表示IO已经完成了
  26.   fil_node_t* message1; /* 该aio操作的innodb文件描述符（f_node_t）*/
  28.   void*   message2; /* 用来记录完成IO请求所对应的具体buffer pool bpage页 */
  30.  \#ifdef WIN_ASYNC_IO
  32.   HANDLE    handle;   /*!< handle object we need in the
  33.           OVERLAPPED struct */
  35.   OVERLAPPED  control;  /*!< Windows control block for the
  36.           aio request */
  38.   \#elif defined(LINUX_NATIVE_AIO)
  40.   struct iocb control;  /* 该slot使用的aio请求控制块iocb */
  42.   int   n_bytes;  /* 读写bytes */
  44.   int   ret;    /* AIO return code */
  46.   \#endif /* WIN_ASYNC_IO */
  48. }
  • 物理数据页操作入口函数os_aio_func
  1. static
  2. ibool
  4. /*==================*/
  5.   os_aio_array_t* array,  /* IO请求函数 */
  6.   os_aio_slot_t*  slot, /* 申请好的slot */
  7.         ibool           should_buffer)  // 是否需要缓存aio 请求，该变量主要对预读起作用
  8. {
  9.     ...
  11.   /* Find out what we are going to work with.
  12.   The iocb struct is directly in the slot.
  13.   The io_context is one per segment. */
  15.   // 每个segment包含的slot个数，Linux下每个segment包含256个slot
  16.   slots_per_segment = array->n_slots / array->n_segments;
  17.   iocb = &slot->control;
  18.   io_ctx_index = slot->pos / slots_per_segment;
  19.   if (should_buffer) {
  20.       /* 这里也可以看到aio请求缓存只对读请求起作用 */
  21.       ut_ad(array == os_aio_read_array);
  23.     ulint n;
  24.     ulint count;
  25.     os_mutex_enter(array->mutex);
  26.     /* There are array->n_slots elements in array->pending, which is divided into
  27.      * array->n_segments area of equal size.  The iocb of each segment are 
  28.      * buffered in its corresponding area in the pending array consecutively as
  29.      * they come.  array->count[i] records the number of buffered aio requests in
  30.      * the ith segment.*/
  31.        n = io_ctx_index * slots_per_segment
  32.       + array->count[io_ctx_index];
  33.       array->pending[n] = iocb;
  34.       array->count[io_ctx_index] ++; 
  35.       count = array->count[io_ctx_index];
  36.       os_mutex_exit(array->mutex);
  37.       // 如果当前segment的slot都已经被占用了，就需要提交一次异步aio请求
  38.       if (count == slots_per_segment) {
  39.             os_aio_linux_dispatch_read_array_submit(); //no cover line
  40.       }   
  41.       // 否则就直接返回
  42.         return (TRUE);                  
  43.    } 
  44.     // 直接提交IO请求到内核
  45.   ret = io_submit(array->aio_ctx[io_ctx_index], 1, &iocb);
  46.   ...
  47. }
  • IO线程负责监控aio请求的主函数fil_aio_wait
  • IO线程负责处理native IO请求的函数os_aio_linux_handle
  1. ibool
  2. os_aio_linux_handle(ulint    global_seg, // 属于哪个segment
  3.                     fil_node_t**message1, /* 该aio操作的innodb文件描述符（f_node_t）*/
  4.                     void**    message2, /* 用来记录完成IO请求所对应的具体buffer pool bpage页 */
  6.     segment = os_aio_get_array_and_local_segment(&array, global_seg); 
  7.     n = array->n_slots / array->n_segments; //获得一个线程可监控的io event数
  8.     /* Loop until we have found a completed request. */
  9.     for (;;) {
  10.         ibool    any_reserved = FALSE;
  11.         os_mutex_enter(array->mutex);
  12.         for (i = 0; i < n; ++i) {  // 遍历该线程所发起的所有aio请求
  13.             slot = os_aio_array_get_nth_slot(
  14.                 array, i + segment * n); 
  15.             if (!slot->reserved) {  // 该slot是否被占用
  16.                 continue;
  17.             } else if (slot->io_already_done) {  // IO请求已经完成，可以通知主线程返回数据了
  18.                 /* Something for us to work on. */
  19.                 goto found;
  20.             } else {
  21.                 any_reserved = TRUE;
  22.             }
  23.         }
  24.         os_mutex_exit(array->mutex);
  25.        // 到这里说明没有找到一个完成的io，则再去collect
  26.         os_aio_linux_collect(array, segment, n); 
  27. found:   // 找到一个完成的io，将内容返回
  28.     *message1 = slot->message1;  
  29.     *message2 = slot->message2; // 返回完成IO所对应的bpage页
  30.     *type = slot->type;
  31.     if (slot->ret == 0 && slot->n_bytes == (long) slot->len) {
  32.         if (slot->page_encrypt
  33.         && slot->type == OS_FILE_READ) {
  34.           os_decrypt_page(slot->buf, slot->len, slot->page_size, FALSE);
  35.     }    
  37.     ret = TRUE;
  38.   } else {
  39.     errno = -slot->ret;
  40.     /* os_file_handle_error does tell us if we should retry
  41.     this IO. As it stands now, we don't do this retry when
  42.     reaping requests from a different context than
  43.     the dispatcher. This non-retry logic is the same for
  44.     windows and linux native AIO.
  45.     We should probably look into this to transparently
  46.     re-submit the IO. */
  47.     os_file_handle_error(slot->name, "Linux aio");
  49.     ret = FALSE;
  50.   }
  52.   os_mutex_exit(array->mutex);
  54.   os_aio_array_free_slot(array, slot);
  56. }
  • 等待native IO请求完成os_aio_linux_collect