一步一步学linux操作系统: 32 输入与输出系统_ 块设备二_直接 I/O，缓存 I/O 与 块设备数据写入请求

最新推荐文章于 2024-07-13 17:28:19 发布
最新推荐文章于 2024-07-13 17:28:19 发布
阅读量1k 收藏 4
点赞数 1
分类专栏： 趣谈Linux操作系统 学习 文章标签： linux 块设备 块设备写入请求
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leacock1991/article/details/108655861
版权

直接 I/O 与 缓存 I/O

可以参见 https://blog.csdn.net/leacock1991/article/details/108035136

对于 ext4 文件系统，最后调用的是 ext4_file_write_iter，它将 I/O 的调用分成两种情况：

  • 第一是直接 I/O
    最终调用的是 generic_file_direct_write，这里调用的是 mapping->a_ops->direct_IO，实际调用的是 ext4_direct_IO，往设备层写入数据。

  • 第二种是缓存 I/O
    最终会将数据从应用拷贝到内存缓存中，但是这个时候，并不执行真正的 I/O 操作。
    只将整个页或其中部分标记为脏。写操作由一个 timer 触发，那个时候，才调用 wb_workfn 往硬盘写入页面。

    • wb_workfn 后的调用链
      wb_workfn->wb_do_writeback->wb_writeback->writeback_sb_inodes->__writeback_single_inode->do_writepages。在 do_writepages 中，我们要调用 mapping->a_ops->writepages，但实际调用的是 ext4_writepages，往设备层写入数据。

直接 I/O 如何访问块设备？

直接 I/O 调用到 ext4_direct_IO

ext4_direct_IO 函数 与 ext4_direct_IO_write 函数

\linux-4.13.16\fs\ext4\inode.c


static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
{
  struct file *file = iocb->ki_filp;
  struct inode *inode = file->f_mapping->host;
  size_t count = iov_iter_count(iter);
  loff_t offset = iocb->ki_pos;
  ssize_t ret;
......
  ret = ext4_direct_IO_write(iocb, iter);
......
}


static ssize_t ext4_direct_IO_write(struct kiocb *iocb, struct iov_iter *iter)
{
  struct file *file = iocb->ki_filp;
  struct inode *inode = file->f_mapping->host;
  struct ext4_inode_info *ei = EXT4_I(inode);
  ssize_t ret;
  loff_t offset = iocb->ki_pos;
  size_t count = iov_iter_count(iter);
......
  ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
           get_block_func, ext4_end_io_dio, NULL,
           dio_flags);


……
}

在这里插入图片描述
在这里插入图片描述

在 ext4_direct_IO_write 调用 __blockdev_direct_IO，有个参数inode->i_sb->s_bdev，通过当前文件的 inode，可以得到 super_block。这个 super_block 中的 s_bdev，就是https://blog.csdn.net/leacock1991/article/details/108308446中填进去的那个 block_device

__blockdev_direct_IO 会调用 do_blockdev_direct_IO

do_blockdev_direct_IO 函数

\linux-4.13.16\fs\direct-io.c


static inline ssize_t
do_blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
          struct block_device *bdev, struct iov_iter *iter,
          get_block_t get_block, dio_iodone_t end_io,
          dio_submit_t submit_io, int flags)
{
  unsigned i_blkbits = ACCESS_ONCE(inode->i_blkbits);
  unsigned blkbits = i_blkbits;
  unsigned blocksize_mask = (1 << blkbits) - 1;
  ssize_t retval = -EINVAL;
  size_t count = iov_iter_count(iter);
  loff_t offset = iocb->ki_pos;
  loff_t end = offset + count;
  struct dio *dio;
  struct dio_submit sdio = { 0, };
  struct buffer_head map_bh = { 0, };
......
  dio = kmem_cache_alloc(dio_cache, GFP_KERNEL);
  dio->flags = flags;
  dio->i_size = i_size_read(inode);
  dio->inode = inode;
  if (iov_iter_rw(iter) == WRITE) {
    dio->op = REQ_OP_WRITE;
    dio->op_flags = REQ_SYNC | REQ_IDLE;
    if (iocb->ki_flags & IOCB_NOWAIT)
      dio->op_flags |= REQ_NOWAIT;
  } else {
    dio->op = REQ_OP_READ;
  }
  sdio.blkbits = blkbits;
  sdio.blkfactor = i_blkbits - blkbits;
  sdio.block_in_file = offset >> blkbits;


  sdio.get_block = get_block;
  dio->end_io = end_io;
  sdio.submit_io = submit_io;
  sdio.final_block_in_bio = -1;
  sdio.next_block_for_io = -1;


  dio->iocb = iocb;
  dio->refcount = 1;


  sdio.iter = iter;
  sdio.final_block_in_request =
    (offset + iov_iter_count(iter)) >> blkbits;
......
  sdio.pages_in_io += iov_iter_npages(iter, INT_MAX);


  retval = do_direct_IO(dio, &sdio, &map_bh);
.....
}

在这里插入图片描述

在这里面函数里有 struct dio 结构和 struct dio_submit 结构，用来描述将要发生的写入请求。

struct dio 结构

\linux-4.13.16\fs\direct-io.c

/* dio_state communicated between submission path and end_io */
struct dio {
	int flags;			/* doesn't change */
	int op;
	int op_flags;
	blk_qc_t bio_cookie;
	struct block_device *bio_bdev;
	struct inode *inode;
	loff_t i_size;			/* i_size when submitted */
	dio_iodone_t *end_io;		/* IO completion function */

	void *private;			/* copy from map_bh.b_private */

	/* BIO completion state */
	spinlock_t bio_lock;		/* protects BIO fields below */
	int page_errors;		/* errno from get_user_pages() */
	int is_async;			/* is IO async ? */
	bool defer_completion;		/* defer AIO completion to workqueue? */
	bool should_dirty;		/* if pages should be dirtied */
	int io_error;			/* IO error in completion path */
	unsigned long refcount;		/* direct_io_worker() and bios */
	struct bio *bio_list;		/* singly linked via bi_private */
	struct task_struct *waiter;	/* waiting task (NULL if none) */

	/* AIO related stuff */
	struct kiocb *iocb;		/* kiocb */
	ssize_t result;                 /* IO result */

	/*
	 * pages[] (and any fields placed after it) are not zeroed out at
	 * allocation time.  Don't add new fields after pages[] unless you
	 * wish that they not be zeroed.
	 */
	union {
		struct page *pages[DIO_PAGES];	/* page buffer */
		struct work_struct complete_work;/* deferred AIO completion */
	};
} ____cacheline_aligned_in_smp;

在这里插入图片描述

struct bio 是将数据传给块设备的通用传输对象

struct dio_submit 结构

\linux-4.13.16\fs\direct-io.c

struct dio_submit {
	struct bio *bio;		/* bio under assembly */
	unsigned blkbits;		/* doesn't change */
	unsigned blkfactor;		/* When we're using an alignment which
					   is finer than the filesystem's soft
					   blocksize, this specifies how much
					   finer.  blkfactor=2 means 1/4-block
					   alignment.  Does not change */
	unsigned start_zero_done;	/* flag: sub-blocksize zeroing has
					   been performed at the start of a
					   write */
	int pages_in_io;		/* approximate total IO pages */
	sector_t block_in_file;		/* Current offset into the underlying
					   file in dio_block units. */
	unsigned blocks_available;	/* At block_in_file.  changes */
	int reap_counter;		/* rate limit reaping */
	sector_t final_block_in_request;/* doesn't change */
	int boundary;			/* prev block is at a boundary */
	get_block_t *get_block;		/* block mapping function */
	dio_submit_t *submit_io;	/* IO submition function */

	loff_t logical_offset_in_bio;	/* current first logical block in bio */
	sector_t final_block_in_bio;	/* current final block in bio + 1 */
	sector_t next_block_for_io;	/* next block to be put under IO,
					   in dio_blocks units */

	/*
	 * Deferred addition of a page to the dio.  These variables are
	 * private to dio_send_cur_page(), submit_page_section() and
	 * dio_bio_add_page().
	 */
	struct page *cur_page;		/* The page */
	unsigned cur_page_offset;	/* Offset into it, in bytes */
	unsigned cur_page_len;		/* Nr of bytes at cur_page_offset */
	sector_t cur_page_block;	/* Where it starts */
	loff_t cur_page_fs_offset;	/* Offset in file */

	struct iov_iter *iter;
	/*
	 * Page queue.  These variables belong to dio_refill_pages() and
	 * dio_get_page().
	 */
	unsigned head;			/* next page to process */
	unsigned tail;			/* last valid page + 1 */
	size_t from, to;
};

在这里插入图片描述
do_blockdev_direct_IO 函数 会调用 do_direct_IO

do_direct_IO 函数

\linux-4.13.16\fs\direct-io.c


static int do_direct_IO(struct dio *dio, struct dio_submit *sdio,
      struct buffer_head *map_bh)
{
  const unsigned blkbits = sdio->blkbits;
  const unsigned i_blkbits = blkbits + sdio->blkfactor;
  int ret = 0;


  while (sdio->block_in_file < sdio->final_block_in_request) {
    struct page *page;
    size_t from, to;


    page = dio_get_page(dio, sdio);
        from = sdio->head ? 0 : sdio->from;
    to = (sdio->head == sdio->tail - 1) ? sdio->to : PAGE_SIZE;
    sdio->head++;


    while (from < to) {
      unsigned this_chunk_bytes;  /* # of bytes mapped */
      unsigned this_chunk_blocks;  /* # of blocks */
......
            ret = submit_page_section(dio, sdio, page,
              from,
              this_chunk_bytes,
              sdio->next_block_for_io,
              map_bh);
......
      sdio->next_block_for_io += this_chunk_blocks;
      sdio->block_in_file += this_chunk_blocks;
      from += this_chunk_bytes;
      dio->result += this_chunk_bytes;
      sdio->blocks_available -= this_chunk_blocks;
      if (sdio->block_in_file == sdio->final_block_in_request)
        break;
......
        }
    }
}

在这里插入图片描述
do_direct_IO 里面有两层循环:

  • 第一层循环是依次处理这次要写入的所有块
    对于每一块，取出对应的内存中的页 page，在这一块中，有写入的起始地址 from 和终止地址 to
  • 第二层循环就是依次处理 from 到 to 的数据
    调用 submit_page_section，提交到块设备层进行写入。
    submit_page_section 会调用 dio_bio_submit，进而调用 submit_bio 向块设备层提交数据。

缓存 I/O 如何访问块设备？

缓存 I/O 调用到 ext4_writepages

ext4_writepages 函数

\linux-4.13.16\fs\ext4\inode.c


static int ext4_writepages(struct address_space *mapping,
         struct writeback_control *wbc)
{
......
  struct mpage_da_data mpd;
  struct inode *inode = mapping->host;
  struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
......
  mpd.do_map = 0;
  mpd.io_submit.io_end = ext4_init_io_end(inode, GFP_KERNEL);
  ret = mpage_prepare_extent_to_map(&mpd);
  /* Submit prepared bio */
  ext4_io_submit(&mpd.io_submit);
......
}

在这里插入图片描述
比较重要的一个数据结构 struct mpage_da_data

struct mpage_da_data

\linux-4.13.16\fs\ext4\inode.c


struct mpage_da_data {
  struct inode *inode;
......
  pgoff_t first_page;  /* The first page to write */
  pgoff_t next_page;  /* Current page to examine */
  pgoff_t last_page;  /* Last page to examine */
  struct ext4_map_blocks map;
  struct ext4_io_submit io_submit;  /* IO submission data */
  unsigned int do_map:1;
};


struct ext4_io_submit {
......
  struct bio    *io_bio;
  ext4_io_end_t    *io_end;
  sector_t    io_next_block;
};

在这里插入图片描述

里面有文件的 inode、要写入的页的偏移量，还有一个重要的 struct ext4_io_submit，里面有通用传输对象 bio 相关结构见下

在 ext4_writepages 中，mpage_prepare_extent_to_map 用于初始化这个 struct mpage_da_data 结构

接下来的调用链为：mpage_prepare_extent_to_map->mpage_process_page_bufs->mpage_submit_page->ext4_bio_write_page->io_submit_add_bh。

io_submit_add_bh 函数

\linux-4.13.16\fs\ext4\page-io.c

static int io_submit_add_bh(struct ext4_io_submit *io,
			    struct inode *inode,
			    struct page *page,
			    struct buffer_head *bh)
{
	int ret;

	if (io->io_bio && bh->b_blocknr != io->io_next_block) {
submit_and_retry:
		ext4_io_submit(io);
	}
	if (io->io_bio == NULL) {
		ret = io_submit_init_bio(io, bh);
		if (ret)
			return ret;
		io->io_bio->bi_write_hint = inode->i_write_hint;
	}
	ret = bio_add_page(io->io_bio, page, bh->b_size, bh_offset(bh));
	if (ret != bh->b_size)
		goto submit_and_retry;
	wbc_account_io(io->io_wbc, page, bh->b_size);
	io->io_next_block++;
	return 0;
}

在这里插入图片描述

在 io_submit_add_bh 中，此时的 bio 还是空的，因而要调用 io_submit_init_bio，初始化 bio。

io_submit_init_bio 函数

\linux-4.13.16\fs\ext4\page-io.c


static int io_submit_init_bio(struct ext4_io_submit *io,
            struct buffer_head *bh)
{
  struct bio *bio;


  bio = bio_alloc(GFP_NOIO, BIO_MAX_PAGES);
  if (!bio)
    return -ENOMEM;
  wbc_init_bio(io->io_wbc, bio);
  bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
  bio->bi_bdev = bh->b_bdev;
  bio->bi_end_io = ext4_end_bio;
  bio->bi_private = ext4_get_io_end(io->io_end);
  io->io_bio = bio;
  io->io_next_block = bh->b_blocknr;
  return 0;
}

在这里插入图片描述
再回到 ext4_writepages 中。在 bio 初始化完之后，要调用 ext4_io_submit，提交 I/O。

ext4_io_submit 函数

\linux-4.13.16\fs\ext4\page-io.c


void ext4_io_submit(struct ext4_io_submit *io)
{
  struct bio *bio = io->io_bio;


  if (bio) {
    int io_op_flags = io->io_wbc->sync_mode == WB_SYNC_ALL ?
          REQ_SYNC : 0;
    io->io_bio->bi_write_hint = io->io_end->inode->i_write_hint;
    bio_set_op_attrs(io->io_bio, REQ_OP_WRITE, io_op_flags);
    submit_bio(io->io_bio);
  }
  io->io_bio = NULL;
}

在这里插入图片描述

ext4_io_submit 又是调用 submit_bio，向块设备层传输数据。这同直接I/O 一样 submit_page_section 会调用 dio_bio_submit，进而调用 submit_bio 向块设备层提交数据。

如何向块设备层提交请求？

不管是直接 I/O，还是缓存 I/O，最后都到了 submit_bio 里面

submit_bio 最后会调用 generic_make_request 如图
\linux-4.13.16\block\blk-core.c
在这里插入图片描述

generic_make_request 函数

generic_make_request 函数 最重要的两大逻辑：获取一个请求队列 request_queue [如何向块设备层提交请求？] 和调用这个队列的 make_request_fn 函数。[请求提交与调度]

\linux-4.13.16\block\blk-core.c


blk_qc_t generic_make_request(struct bio *bio)
{
  /*
   * bio_list_on_stack[0] contains bios submitted by the current
   * make_request_fn.
   * bio_list_on_stack[1] contains bios that were submitted before
   * the current make_request_fn, but that haven't been processed
   * yet.
   */
  struct bio_list bio_list_on_stack[2];
  blk_qc_t ret = BLK_QC_T_NONE;
......
  if (current->bio_list) {
    bio_list_add(&current->bio_list[0], bio);
    goto out;
  }


  bio_list_init(&bio_list_on_stack[0]);
  current->bio_list = bio_list_on_stack;
  do {
    struct request_queue *q = bdev_get_queue(bio->bi_bdev);


    if (likely(blk_queue_enter(q, bio->bi_opf & REQ_NOWAIT) == 0)) {
      struct bio_list lower, same;


      /* Create a fresh bio_list for all subordinate requests */
      bio_list_on_stack[1] = bio_list_on_stack[0];
      bio_list_init(&bio_list_on_stack[0]);
      ret = q->make_request_fn(q, bio);


      blk_queue_exit(q);


      /* sort new bios into those for a lower level
       * and those for the same level
       */
      bio_list_init(&lower);
      bio_list_init(&same);
      while ((bio = bio_list_pop(&bio_list_on_stack[0])) != NULL)
        if (q == bdev_get_queue(bio->bi_bdev))
          bio_list_add(&same, bio);
        else
          bio_list_add(&lower, bio);
      /* now assemble so we handle the lowest level first */
      bio_list_merge(&bio_list_on_stack[0], &lower);
      bio_list_merge(&bio_list_on_stack[0], &same);
      bio_list_merge(&bio_list_on_stack[0], &bio_list_on_stack[1]);
    } 
......
    bio = bio_list_pop(&bio_list_on_stack[0]);
  } while (bio);
  current->bio_list = NULL; /* deactivate */
out:
  return ret;
}

在这里插入图片描述
do-while 中先是获取一个请求队列 request_queue，然后调用这个队列的 make_request_fn 函数

request_queue 结构

\linux-4.13.16\include\linux\blkdev.h


struct request_queue {
  /*
   * Together with queue_head for cacheline sharing
   */
  struct list_head  queue_head;
  struct request    *last_merge;
  struct elevator_queue  *elevator;
......
  request_fn_proc    *request_fn;
  make_request_fn    *make_request_fn;
......
}

在这里插入图片描述
从 struct block_device 结构和 struct gendisk 结构 可以发现 每个块设备都有一个请求队列 struct request_queue，用于处理上层发来的请求。

在每个块设备的驱动程序初始化的时候，会生成一个 request_queue。

链表 list_head，保存请求 request

request 结构

\linux-4.13.16\include\linux\blkdev.h


struct request {
  struct list_head queuelist;
......
  struct request_queue *q;
......
  struct bio *bio;
  struct bio *biotail;
......
}

在这里插入图片描述
每个 request 包括一个链表的 struct bio，有指针指向一头一尾

struct bio 结构

\linux-4.13.16\include\linux\blk_types.h


struct bio {
  struct bio    *bi_next;  /* request queue link */
  struct block_device  *bi_bdev;
  blk_status_t    bi_status;
......
    struct bvec_iter  bi_iter;
  unsigned short    bi_vcnt;  /* how many bio_vec's */
  unsigned short    bi_max_vecs;  /* max bvl_vecs we can hold */
  atomic_t    __bi_cnt;  /* pin count */
  struct bio_vec    *bi_io_vec;  /* the actual vec list */
......
};


struct bio_vec {
  struct page  *bv_page;
  unsigned int  bv_len;
  unsigned int  bv_offset;
}

在这里插入图片描述

在这里插入图片描述
bio 中，bi_next 是链表中的下一项，struct bio_vec 指向一组页面

图片来自极客时间趣谈linux操作系统
图片来自极客时间趣谈linux操作系统
在请求队列 request_queue 上，还有两个重要的函数，一个是 make_request_fn 函数，用于生成 request；另一个是 request_fn 函数，用于处理 request。

块设备的初始化

以 scsi 驱动为例， 在初始化设备驱动的时候，调用 scsi_alloc_queue，把 request_fn 设置为 scsi_request_fn，调用 blk_init_allocated_queue->blk_queue_make_request，把 make_request_fn 设置为 blk_queue_bio

scsi_alloc_sdev 调用 scsi_alloc_queue

scsi_alloc_sdev 函数

\drivers\scsi\scsi_scan.c


/**
 * scsi_alloc_sdev - allocate and setup a scsi_Device
 * @starget: which target to allocate a &scsi_device for
 * @lun: which lun
 * @hostdata: usually NULL and set by ->slave_alloc instead
 *
 * Description:
 *     Allocate, initialize for io, and return a pointer to a scsi_Device.
 *     Stores the @shost, @channel, @id, and @lun in the scsi_Device, and
 *     adds scsi_Device to the appropriate list.
 *
 * Return value:
 *     scsi_Device pointer, or NULL on failure.
 **/
static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
             u64 lun, void *hostdata)
{
  struct scsi_device *sdev;
  sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
           GFP_ATOMIC);
......
  sdev->request_queue = scsi_alloc_queue(sdev);
......
}

在这里插入图片描述

scsi_alloc_queue 函数

\linux-4.13.16\drivers\scsi\scsi_lib.c

struct request_queue *scsi_alloc_queue(struct scsi_device *sdev)
{
  struct Scsi_Host *shost = sdev->host;
  struct request_queue *q;


  q = blk_alloc_queue_node(GFP_KERNEL, NUMA_NO_NODE);
  if (!q)
    return NULL;
  q->cmd_size = sizeof(struct scsi_cmnd) + shost->hostt->cmd_size;
  q->rq_alloc_data = shost;
  q->request_fn = scsi_request_fn;
  q->init_rq_fn = scsi_init_rq;
  q->exit_rq_fn = scsi_exit_rq;
  q->initialize_rq_fn = scsi_initialize_rq;


    //调用blk_queue_make_request(q, blk_queue_bio);
  if (blk_init_allocated_queue(q) < 0) {
    blk_cleanup_queue(q);
    return NULL;
  }


  __scsi_init_queue(shost, q);
......
  return q
}

在这里插入图片描述

scsi_alloc_queue 调用 blk_init_allocated_queue

blk_init_allocated_queue 函数

\linux-4.13.16\block\blk-core.c


int blk_init_allocated_queue(struct request_queue *q)
{
  q->fq = blk_alloc_flush_queue(q, NUMA_NO_NODE, q->cmd_size);
......
  blk_queue_make_request(q, blk_queue_bio);
......
  /* init elevator */
  if (elevator_init(q, NULL)) {
......
  }
......
}

在这里插入图片描述

除了初始化 make_request_fn 函数 ，还要做一件很重要的事情，就是初始化 I/O 的电梯算法。

blk_init_allocated_queue 调用 blk_queue_make_request 将 make_request_fn 设置为 blk_queue_bio

blk_queue_make_request 函数

\linux-4.13.16\block\blk-settings.c

void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
{
	/*
	 * set defaults
	 */
	q->nr_requests = BLKDEV_MAX_RQ;

	q->make_request_fn = mfn;
	blk_queue_dma_alignment(q, 511);
	blk_queue_congestion_threshold(q);
	q->nr_batching = BLK_BATCH_REQ;

	blk_set_default_limits(&q->limits);
}

在这里插入图片描述

电梯算法简介

电梯算法有很多种类型，定义为 elevator_type

struct elevator_type 结构

\linux-4.13.16\include\linux\elevator.h


/*
 * identifies an elevator type, such as AS or deadline
 */
struct elevator_type
{
	/* managed by elevator core */
	struct kmem_cache *icq_cache;

	/* fields provided by elevator implementation */
	union {
		struct elevator_ops sq;
		struct elevator_mq_ops mq;
	} ops;
	size_t icq_size;	/* see iocontext.h */
	size_t icq_align;	/* ditto */
	struct elv_fs_entry *elevator_attrs;
	char elevator_name[ELV_NAME_MAX];
	struct module *elevator_owner;
	bool uses_mq;
#ifdef CONFIG_BLK_DEBUG_FS
	const struct blk_mq_debugfs_attr *queue_debugfs_attrs;
	const struct blk_mq_debugfs_attr *hctx_debugfs_attrs;
#endif

	/* managed by elevator core */
	char icq_cache_name[ELV_NAME_MAX + 6];	/* elvname + "_io_cq" */
	struct list_head list;
};

在这里插入图片描述

  • struct elevator_type elevator_noop
    Noop 调度算法是最简单的 IO 调度算法，它将 IO 请求放入到一个 FIFO 队列中，然后逐个执行这些 IO 请求。
  • struct elevator_type iosched_deadline
    Deadline 算法要保证每个 IO 请求在一定的时间内一定要被服务到，以此来避免某个请求饥饿。
  • struct elevator_type iosched_cfq
    CFQ 完全公平调度算法。所有的请求会在多个队列中排序。同一个进程的请求，总是在同一队列中处理。时间片会分配到每个队列，通过轮询算法，保证了 I/O 带宽，以公平的方式，在不同队列之间进行共享。

elevator_init 中会根据名称来指定电梯算法，如果没有选择，那就默认使用 iosched_cfq。

请求提交与调度

回到 generic_make_request函数中
不管是直接 I/O，还是缓存 I/O，最后都到了 submit_bio 里面，submit_bio 会调用 generic_make_request

以 scsi 驱动为例，blk_init_allocated_queue 调用 blk_queue_make_request 将 make_request_fn 设置为 blk_queue_bio

generic_make_request 函数调用队列的 make_request_fn，其实就是调用 blk_queue_bio

blk_queue_bio 函数

\linux-4.13.16\block\blk-core.c


static blk_qc_t blk_queue_bio(struct request_queue *q, struct bio *bio)
{
  struct request *req, *free;
  unsigned int request_count = 0;
......
  switch (elv_merge(q, &req, bio)) {
  case ELEVATOR_BACK_MERGE:
    if (!bio_attempt_back_merge(q, req, bio))
      break;
    elv_bio_merged(q, req, bio);
    free = attempt_back_merge(q, req);
    if (free)
      __blk_put_request(q, free);
    else
      elv_merged_request(q, req, ELEVATOR_BACK_MERGE);
    goto out_unlock;
  case ELEVATOR_FRONT_MERGE:
    if (!bio_attempt_front_merge(q, req, bio))
      break;
    elv_bio_merged(q, req, bio);
    free = attempt_front_merge(q, req);
    if (free)
      __blk_put_request(q, free);
    else
      elv_merged_request(q, req, ELEVATOR_FRONT_MERGE);
    goto out_unlock;
  default:
    break;
  }


get_rq:
  req = get_request(q, bio->bi_opf, bio, GFP_NOIO);
......
  blk_init_request_from_bio(req, bio);
......
  add_acct_request(q, req, where);
  __blk_run_queue(q);
out_unlock:
......
  return BLK_QC_T_NONE;
}

在这里插入图片描述

blk_queue_bio 调用 elv_merge 来判断是否有request可以合并

调用 elv_merge 来判断，当前这个 bio 请求是否能够和目前已有的 request 合并起来，成为同一批 I/O 操作，从而提高读取和写入的性能

判断标准和 struct bio 的成员 struct bvec_iter 有关，它里面有两个变量，一个是起始磁盘簇 bi_sector，另一个是大小 bi_size。

elv_merge 函数

\linux-4.13.16\block\elevator.c


enum elv_merge elv_merge(struct request_queue *q, struct request **req,
    struct bio *bio)
{
  struct elevator_queue *e = q->elevator;
  struct request *__rq;
......
  if (q->last_merge && elv_bio_merge_ok(q->last_merge, bio)) {
    enum elv_merge ret = blk_try_merge(q->last_merge, bio);


    if (ret != ELEVATOR_NO_MERGE) {
      *req = q->last_merge;
      return ret;
    }
  }
......
  __rq = elv_rqhash_find(q, bio->bi_iter.bi_sector);
  if (__rq && elv_bio_merge_ok(__rq, bio)) {
    *req = __rq;
    return ELEVATOR_BACK_MERGE;
  }


  if (e->uses_mq && e->type->ops.mq.request_merge)
    return e->type->ops.mq.request_merge(q, req, bio);
  else if (!e->uses_mq && e->type->ops.sq.elevator_merge_fn)
    return e->type->ops.sq.elevator_merge_fn(q, req, bio);


  return ELEVATOR_NO_MERGE;
}

在这里插入图片描述
elv_merge 尝试了三次合并

  • 第一次，它先判断和上一次合并的 request 能不能再次合并，看看能不能赶上马上要走的这部电梯。

在 blk_try_merge 主要做了这样的判断：

如果 blk_rq_pos(rq) + blk_rq_sectors(rq) == bio->bi_iter.bi_sector，也就是说这个 request 的起始地址加上它的大小（其实是这个 request 的结束地址），如果和 bio 的起始地址能接得上，那就把 bio 放在 request 的最后，称为 ELEVATOR_BACK_MERGE。

如果 blk_rq_pos(rq) - bio_sectors(bio) == bio->bi_iter.bi_sector，也就是说，这个 request 的起始地址减去 bio 的大小等于 bio 的起始地址，这说明 bio 放在 request 的最前面能够接得上，那就把 bio 放在 request 的最前面，称为 ELEVATOR_FRONT_MERGE。否则，那就不合并，称为 ELEVATOR_NO_MERGE。

blk_try_merge 函数
\linux-4.13.16\block\blk-merge.c


enum elv_merge blk_try_merge(struct request *rq, struct bio *bio)
{
......
    if (blk_rq_pos(rq) + blk_rq_sectors(rq) == bio->bi_iter.bi_sector)
    return ELEVATOR_BACK_MERGE;
  else if (blk_rq_pos(rq) - bio_sectors(bio) == bio->bi_iter.bi_sector)
    return ELEVATOR_FRONT_MERGE;
  return ELEVATOR_NO_MERGE;
}

在这里插入图片描述

  • 第二次，如果和上一个合并过的 request 无法合并，那就调用 elv_rqhash_find。
    按照 bio 的起始地址查找 request，看有没有能够合并的。如果有的话，因为是按照起始地址找的，应该接在人家的后面，所以是 ELEVATOR_BACK_MERGE。

  • 第三次，调用 elevator_merge_fn 试图合并

对于 iosched_cfq，调用的是 cfq_merge。在这里面，cfq_find_rq_fmerge 会调用 elv_rb_find 函数，里面的参数是 bio 的结束地址。

能不能找到可以合并的。如果有的话，因为是按照结束地址找的，应该接在人家前面，所以是 ELEVATOR_FRONT_MERGE。

\linux-4.13.16\block\cfq-iosched.c


static enum elv_merge cfq_merge(struct request_queue *q, struct request **req,
         struct bio *bio)
{
  struct cfq_data *cfqd = q->elevator->elevator_data;
  struct request *__rq;


  __rq = cfq_find_rq_fmerge(cfqd, bio);
  if (__rq && elv_bio_merge_ok(__rq, bio)) {
    *req = __rq;
    return ELEVATOR_FRONT_MERGE;
  }


  return ELEVATOR_NO_MERGE;
}


static struct request *
cfq_find_rq_fmerge(struct cfq_data *cfqd, struct bio *bio)
{
  struct task_struct *tsk = current;
  struct cfq_io_cq *cic;
  struct cfq_queue *cfqq;


  cic = cfq_cic_lookup(cfqd, tsk->io_context);
  if (!cic)
    return NULL;


  cfqq = cic_to_cfqq(cic, op_is_sync(bio->bi_opf));
  if (cfqq)
    return elv_rb_find(&cfqq->sort_list, bio_end_sector(bio));


  return NUL
}

在这里插入图片描述
在这里插入图片描述

elv_merge 返回 blk_queue_bio 的时候就知道，应该做哪种类型的合并，接着就要进行真的合并。

如果没有办法合并，那就调用 get_request，创建一个新的 request，调用 blk_init_request_from_bio，将 bio 放到新的 request 里面，然后调用 add_acct_request，把新的 request 加到 request_queue 队列中。

到这里解析完了 generic_make_request 中最重要的两大逻辑：获取一个请求队列 request_queue [如何向块设备层提交请求？] 和调用这个队列的 make_request_fn 函数。[请求提交与调度]

请求的处理

设备驱动程序往设备里面写，调用的是请求队列 request_queue 的另外一个函数 request_fn。
对于 scsi 设备来讲，调用的是 scsi_request_fn

scsi_request_fn 函数

\linux-4.13.16\drivers\scsi\scsi_lib.c


static void scsi_request_fn(struct request_queue *q)
  __releases(q->queue_lock)
  __acquires(q->queue_lock)
{
  struct scsi_device *sdev = q->queuedata;
  struct Scsi_Host *shost;
  struct scsi_cmnd *cmd;
  struct request *req;


  /*
   * To start with, we keep looping until the queue is empty, or until
   * the host is no longer able to accept any more requests.
   */
  shost = sdev->host;
  for (;;) {
    int rtn;
    /*
     * get next queueable request.  We do this early to make sure
     * that the request is fully prepared even if we cannot
     * accept it.
     */
    req = blk_peek_request(q);
......
    /*
     * Remove the request from the request list.
     */
    if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))
      blk_start_request(req);
.....
    cmd = req->special;
......
    /*
     * Dispatch the command to the low-level driver.
     */
    cmd->scsi_done = scsi_done;
    rtn = scsi_dispatch_cmd(cmd);
......
  }
  return;
......
}

在这里插入图片描述
这里面是一个 for 无限循环，从 request_queue 中读取 request，然后封装更加底层的指令，给设备控制器下指令，实施真正的 I/O 操作。

总结

块设备的 I/O 操作分为两种，一种是直接 I/O，另一种是缓存 I/O。

无论是哪种 I/O，最终都会调用 submit_bio 提交块设备 I/O 请求。

所谓的写入块设备，I/O 就是将 page cache 里面的数据写入硬盘。

对于每一种块设备，都有一个 gendisk 表示这个设备，它有一个请求队列，这个队列是一系列的 request 对象。每个 request 对象里面包含多个 BIO 对象，指向 page cache。

对于请求队列来讲，还有两个函数：

  • 一个函数叫 make_request_fn 函数
    用于将请求放入队列。submit_bio 会调用 generic_make_request，然后调用这个函数
  • 另一个函数在设备驱动程序里实现，叫 request_fn 函数
    用于从队列里面取出请求来，写入外部设备。

图片来自极客时间趣谈linux操作系统
图片来自极客时间趣谈linux操作系统

参考资料：

趣谈Linux操作系统（极客时间）链接：
http://gk.link/a/10iXZ
欢迎大家来一起交流学习

墨1024
关注
专栏目录
Linux系统开发: 命令进阶学习(一)
07-28 1443
一、解压缩命令介绍 Linux下最常用的打包程序是tar命令，使用tar打出来的包我们常称为tar包，tar包文件的命令通常都是以.tar结尾的，生成tar包后，就可以用其它的程序来进行压缩了。 1.1.1 tar命令介绍 功能：tar是一个压缩解压工具。利用tar，用户可以为某一特定文件创建档案（备份文件），也可以在档案中改变文件，或者向档案中加入新的文件。tar最初被用来在磁带上创建档案，现在，用户可以在任何设备上创建档案，如软盘。利用tar命令，可以把一大堆的文件和目录全部打包...
Linux驱动开发: 块设备驱动开发
08-30 2332
Linux内核版本: 3.5 测试设备: 友善之臂Tiny4412开发板（CPU型号: 三星Exynos4412） 2019年三星发布的Galaxy S II和MX采用的就是这款CPU。 一、块设备介绍 块是一种具有一定结构的随机存取设备，对这种设备的读写是按块进行的，他使用缓冲区来存放暂时的数据，待条件成熟后，从缓存一次性写入设备或者从设备一次性读到缓冲区。 块设备是与字符设备并列的概念， 这两类设备在 Linux 中驱动的结构有较大差异，总体而言， 块设备驱动比字符...
Linux 文件系统解析（四）IO模式
xyin_kevin的博客
08-02 5377
文件系统是IO流程的起点，为了满足应用程序对IO操作的各种需求，在文件系统层设计了多种IO模式，上一篇介绍的bufferIO是最常见的一种，本篇来梳理一下其他IO模式，它们的作用，流程以及是如何实现的。 DirectIO DAX 异步IO aio iouring 多路复用 select poll epoll mmap ...
Linux IO系统分析（在Linux用户空间，有三种方式提交对SCSI设备请求到通用块层）
Wang20122013的博客
12-23 455
一、概述 Linux内核中SCSI子系统由SCSI上层，中间层，底层驱动模块三部分组成，负责管理SCSI资源和处理其他子系统，如文件系统，提交到SCSI子系统中的IO请求。 因此，理解SCSI子系统的IO处理机制对理解整个SCSI子系统至关重要，同时也有助于理解整个Linux内核的IO处理机制。 二、SCSI SCSI设备访问请求的提交分为两个步骤： 用户空间提交请求到通用块层 通用块层提交块请求到SCSI子系统 　　用户空间提交请求到同样块层： 　　　　在Linux用户空间，有三种方式提交对SCSI设备请
底软驱动 | 一文搞懂块设备
最新发布
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
07-13 960
本文详细叙述了块设备的基本结构体以及块设备从挂载到访问的全部过程，由此可以对块设备有一个全面的了解。
linux块设备
lyq_csdn的博客
05-31 1万+
来自：https://www.cnblogs.com/xuyh/p/5333086.htmlhttp://www.cnblogs.com/xuyh/p/5333191.htmlhttp://www.cnblogs.com/xuyh/p/5340026.html 一： 块设备概念：      一种具有一定结构的随机存取设备，对这种设备的读写是按块进行的，他使用缓冲区来存放暂时的数据，待条件成熟后，从...
十六、Linux驱动之块设备驱动
墨、白的博客
12-04 1170
1. 基本概念     块设备是Linux三大设备之一，其驱动模型主要针对磁盘，Flash等存储类设备，块设备（blockdevice）是一种具有一定结构的随机存取设备，对这种设备的读写是按块(所以叫块设备)进行的，他使用缓冲区来存放暂时的数据，待条件成熟后，从缓存一次性写入设备或者从设备一次性读到缓冲区。 1.1 块设备结构     块设备由Page-&gt;Segment-&gt;Blo...
linux do direct io,Linux DirectIO机制分析
weixin_35472986的博客
05-14 595
DirectIO是write函数的一个选项，用来确定数据内容直接写到磁盘上，而非缓存中，保证即是系统异常了，也能保证紧要数据写到磁盘上，具体写文件的机制流程可以参考前面写的,DirectIO流程也是接续着写文件流程而来的。内核走到__generic_file_aio_write函数时，系统根据file->f_flags & O_DIRECT判断进入DirectIO处理的分支:if (...
Linux系统编程——I/O多路复用select、poll、epoll
墨鱼菜鸡
07-11 410
参考：https://segmentfault.com/a/1190000003063859 Linux下的I/O复用与epoll详解：https://www.cnblogs.com/lojunren/p/3856290.html 彻底学会 epoll 系列：http://blog.chinaunix.net/uid/28541347/sid-1931...
阻塞型与非阻塞型I/O，异步通知
Qinus的博客
07-06 1060
一、ioctl 1.ioctl系统调用可以实现用户空间的各种需求，比如报告错误信息，改变波特率，执行自破坏等 2.用户空间的ioctl(int fd, unsigned long cmd, …)后面的三个点表示的是可变参数目的参数表。这些点并不是数目不定的一串参数，而只是一个可选参数。另外这些点只是为了在编译时防止编译器进行类型检查。第三个参数的具体形式依赖于要完成的控制命令，也就是第二个参数。某...
操作系统实验一到实验九合集(哈工大李治军)
热门推荐
leoabcd12的博客
01-01 4万+
操作系统实验一到实验九合集(哈工大李治军) 有详细代码及注释，程序已在本地测试，均能跑通
十七、块设备驱动
aa508508的博客
07-26 166
在读者学习本章以及后续块设备相关章节之前，最好了解块设备读写过程和操作，可以参考：Nor Flash裸机操作。 一、块设备概念和读写过程 块设备： 块设备是I/O设备中的一类，是将信息存储在固定大小的块中，每个块都有自己的地址，还可以在设备的任意位置读取一定长度的数据。如硬盘，U盘，SD卡等。 块设备组成： 段（Segments）：由若干个块组成，是Linux...
操作系统之输入输出系统
进化的深山猿
09-29 3843
31 输入与输出系统 输入输出设备很多，如键盘、鼠标、显示器、网卡、硬盘、打印机等。对于操作系统，这些用法、功能不同的设备怎么统一管理起来呢？ 设备控制器屏蔽设备差异 cpu和设备通过设备控制器来打交道，如磁盘对应的磁盘控制器、USB对应的USB控制器、显示器的视频控制器等。 设备控制器像代理商一样屏蔽设备的差异性，且类似于小电脑，有自己的小cpu、寄存器，这样cpu可以对控制器下发指令、查看控制器对设备的操作状态。 输入输出设备可以大致分为两类：块设备、字符设备 块设备将信息存储在固定大小的块中，每个
Linux writeback机制
bin_linux96的专栏
11-29 5574
Linux 采用内存页来缓存磁盘文件内容，从而提高系统整体IO访问性能，这就是我们熟知的pagecache机制，对于进程的一次写文件操作，内核只是简单的把修改写到内存，并把页面标记为脏页，然后直接返回，具体的回写操作，由内核周期性的启动线程来完成，这个我们称为writeback机制。 1 脏页的产生 修改文件内容和属性都会产生脏页，当进程调用write进行写操作时，最终会通过set_page_dirty函数标记脏页，并唤醒内核后台回写线程。 如果进程只写了page中的一部分，是否有必要回写整个页了？当
Linux Kernel文件系统写I/O流程代码分析（二）bdi_writeback
weixin_34148456的博客
03-07 356
Linux Kernel文件系统写I/O流程代码分析（二）bdi_writeback 上一篇# Linux Kernel文件系统写I/O流程代码分析（一），我们看到Buffered IO，写操作写入到page cache后就直接返回了，本文主要分析脏页是如何刷盘的。 概述 由于内核page cache的作用，写操作实际被延迟写入。当page cache里的数据被用户写入但是没有刷新到磁盘时，则该p...
块存储：写块设备缓存的代码注释
yiyeguzhou100的专栏
05-28 1331
“块存储：AIO的直接写流程注释”中说到，如果是Direct 写，__generic_file_write_iter将首先调用generic_file_direct_write函数，然后generic_file_direct_write调用块设备的direct_io函数直接写设备，如果direct_io没有将需要写盘的数据写完，就要调用generic_perform_write函数做一次buffer write，即写page cache（块设备也是一种文件，有对应的address_space管理page c
linux驱动---file_operations异步读写aio_read、aio_write
子木
02-06 1万+
简述： file_operations中read,write是同步读写，异步读写用接口是aio_read、aio_wirte（在4.5版本中发现已经把名字改成read_iter、write_iter）。异步读写对应的系统调用API:int aio_read(struct aiocb *__aiocbp); int aio_write(struct aiocb *__aiocbp);定义在头文件中（
linux bio bh关系,一个IO的传奇一生 (5) --- 块设备层
weixin_32369749的博客
05-16 483
无论是经过EXT3文件系统还是块设备文件,最终都要通过writeback机制将数据刷新到磁盘，除非用户在对文件进行读写的时候采用了DirectIO的方式。为了提高性能，文件系统或者是裸设备都会采用Linux的cache机制对数据读写性能进行优化，因此都会采用writeback回写机制将数据写入磁盘。通过上述分析我们已经知道，writeback机制会调用不同底层设备的address_space_op...
f2fs学习笔记 - 9. f2fs 写文件
HZero
01-11 1209
1.前言 本文主要介绍f2fs写入流程. 写入流程主要分为meta, data, node的写入，本文主要介绍data的写入流程。 2.总体流程 sys_write fdget file_pos_read vfs_write file_pos_write fdget是从当前进程的文件描述符表获取一个fd; file_pos_read获取文件描述符当前的读写位置 vfs_write执行文件写入操作 file_pos_write更新文件的写入位置 3.vfs_write vfs_w
操作系统中的设备管理与I/O系统详解
"数据交付方式-操作系统设备管理" 操作系统在处理数据交付时，主要涉及的是I/O（输入/输出）系统，这是操作系统的重要组成部分，负责管理硬件设备，特别是数据的读取和写入操作。在本资源中，重点讨论了数据交付的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

墨1024

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值