加载中…
个人资料
微博
  • 博客等级：
  • 博客积分：
  • 博客访问：
  • 关注人气：
  • 获赠金笔：0支
  • 赠出金笔：0支
  • 荣誉徽章：
正文 字体大小：大 中 小

kernel 3.10内核源码分析--块设备层request plug/unplug机制 3

(2015-01-30 16:25:11)
2) kblockd工作队列的工作内容
kblockd工作队列的工作内容有由blk_delay_work()函数实现，主要就是调用__blk_run_queue进行unplug请求队列。

点击(此处)折叠或打开

  1. /*IO请求队列的delay_work，用于在kblockd中异步unplug请求队列*/
  2. static void blk_delay_work(struct work_struct *work)
  3. {
  4. struct request_queue *q;
  5. /*获取delay_work所在的请求队列*/
  6. q = container_of(work, struct request_queue, delay_work.work);
  7. spin_lock_irq(q->queue_lock);
  8. /*直接run queue，最终调用request_fn对队列中的请求逐一处理*/
  9. __blk_run_queue(q);
  10. spin_unlock_irq(q->queue_lock);
  11. }

2、unplug机制
内核中设计了两种unplug机制：
1）调度时进行unplug(异步方式)
当发生内核调度时，当前进程sleep前，先将当前task的plug列表中的请求flush到派发队列中，并进行unplug。
主要代码流程如下：
schedule->
    sched_submit_work ->
        blk_schedule_flush_plug()->
            blk_flush_plug_list(plug, true) ->注意:这里传入的from_schedule参数为true，表示将触发异步unplug，即唤醒kblockd工作队列来进行unplug操作。后续的kblockd的唤醒周期在块设备驱动中设置，比如scsi中设置为3ms。
                queue_unplugged->
                    blk_run_queue_async

queue_unplugged():

点击(此处)折叠或打开

  1. /*unplug请求队列，plug相当于蓄水，将请求放入池子(请求队列)中，unplug相当于放水，即开始调用请求队列的request_fn(scsi_request_fn)来处理请求队列中的请求，将请求提交到scsi层(块设备驱动层)*/
  2. static void queue_unplugged(struct request_queue *q, unsigned int depth,
  3.    bool from_schedule)
  4. __releases(q->queue_lock)
  5. {
  6. trace_block_unplug(q, depth, !from_schedule);
  7. /*调用块设备驱动层提供的request_fn接口处理请求队列中的请求，分异步和同步两种情况。*/
  8. if (from_schedule)
  9. /*异步unplug，即通过kblockd工作队列来处理，该工作队列定期唤醒(5s)，通过这种方式可以控制流量，提高吞吐量*/
  10. blk_run_queue_async(q);
  11. else
  12. /*同步unplug，即直接调用设备驱动层提供的request_fn接口处理请求队列中的请求*/
  13. __blk_run_queue(q);
  14. spin_unlock(q->queue_lock);
  15. }

blk_run_queue_async():

点击(此处)折叠或打开

  1. /*异步unplug，即通过kblockd工作队列来处理，该工作队列定期唤醒(5s)，通过这种方式可以控制流量，提高吞吐量*/
  2. void blk_run_queue_async(struct request_queue *q)
  3. {
  4. if (likely(!blk_queue_stopped(q) && !blk_queue_dead(q)))
  5. /*唤醒kblockd相关的工作队列，进行unplug处理，注意:这里的delay传入0表示立刻唤醒，kblockd对应的处理接口为:blk_delay_work*/
  6. mod_delayed_work(kblockd_workqueue, &q->delay_work, 0);
  7. }

scsi_request_fn()://scsi块设备驱动的request_fn()接口，其中当scsi命令下发失败时，会重设kblockd，延迟unplug请求队列。

点击(此处)折叠或打开

  1. static void scsi_request_fn(struct request_queue *q)
  2. {
  3. ...
  4. /*
  5. * Dispatch the command to the low-level driver.
  6. */
  7. /*将scsi命令下发到底层驱动，当返回非0时，表示命令下发失败，则当前的请求队列需要被plug*/
  8. rtn = scsi_dispatch_cmd(cmd);
  9. spin_lock_irq(q->queue_lock);
  10. /*命令下发失败，需要plug请求队列*/
  11. if (rtn)
  12. goto out_delay
  13. ...
  14. out_delay:
  15. if (sdev->device_busy == 0)
  16. /*命令下发失败，需要延迟处理，需plug请求队列，设置3ms定时启动kblockd工作队列，进行请求队列的unplug*/
  17. blk_delay_queue(q, SCSI_QUEUE_DELAY);
  18. blk_delay_queue
  19. /*在指定msecs时间后启动kblockd工作队列*/
  20. void blk_delay_queue(struct request_queue *q, unsigned long msecs)
  21. {
  22. if (likely(!blk_queue_dead(q)))
  23. queue_delayed_work(kblockd_workqueue, &q->delay_work,
  24.   msecs_to_jiffies(msecs));
  25. }

2）提交IO请求时(make_request)进行unplug
提交IO请求时(make_request)，先将请求提交时先链入此队列，当该队列满时(>BLK_MAX_REQUEST_COUNT)，会flush到相应设备的请求队列中(request_queue)。
主要代码流程为：
submit_bio->
    generic_make_request->
        make_request->
            blk_queue_bio->
                blk_flush_plug_list(plug, false) ->注意:这里传入的from_schedule参数为false，表示将触发同步unplug，即当即下发请求。
                    queue_unplugged->
                        blk_run_queue_async ->
                            __blk_run_queue

普通块设备的make_request接口在3.10内核版本中被设置为blk_queue_bio，相应代码分析如下：

点击(此处)折叠或打开

  1. /*在submit_bio中被调用，用于合并bio，并提交请求(request)，请求提交到per task的plug list中*/
  2. void blk_queue_bio(struct request_queue *q, struct bio *bio)
  3. {
  4.     const bool sync = !!(bio->bi_rw & REQ_SYNC);
  5.     struct blk_plug *plug;
  6.     int el_ret, rw_flags, where = ELEVATOR_INSERT_SORT;
  7.     struct request *req;
  8.     unsigned int request_count = 0;

  10.     /*
  11.      * low level driver can indicate that it wants pages above a
  12.      * certain limit bounced to low memory (ie for highmem, or even
  13.      * ISA dma in theory)
  14.      */
  15.     /*bounce buffer(回弹缓冲区)使用*/ 
  16.     blk_queue_bounce(q, &bio);

  18.     if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
  19.         bio_endio(bio, -EIO);
  20.         return;
  21.     }

  23.     if (bio->bi_rw & (REQ_FLUSH | REQ_FUA)) {
  24.         spin_lock_irq(q->queue_lock);
  25.         where = ELEVATOR_INSERT_FLUSH;
  26.         goto get_rq;
  27.     }

  29.     /*
  30.      * Check if we can merge with the plugged list before grabbing
  31.      * any locks.
  32.      */
  33.     /*尝试将bio合并到request中*/
  34.     if (blk_attempt_plug_merge(q, bio, &request_count))
  35.         return;

  37.     spin_lock_irq(q->queue_lock);

  39.     el_ret = elv_merge(q, &req, bio);
  40.     /*向后合并*/
  41.     if (el_ret == ELEVATOR_BACK_MERGE) {
  42.         if (bio_attempt_back_merge(q, req, bio)) {
  43.             elv_bio_merged(q, req, bio);
  44.             if (!attempt_back_merge(q, req))
  45.                 elv_merged_request(q, req, el_ret);
  46.             goto out_unlock;
  47.         }
  48.     /*向前合并*/
  49.     } else if (el_ret == ELEVATOR_FRONT_MERGE) {
  50.         if (bio_attempt_front_merge(q, req, bio)) {
  51.             elv_bio_merged(q, req, bio);
  52.             if (!attempt_front_merge(q, req))
  53.                 elv_merged_request(q, req, el_ret);
  54.             goto out_unlock;
  55.         }
  56.     }
  57. /*不能合并，需要新建request来处理bio*/
  58. get_rq:
  59.     /*
  60.      * This sync check and mask will be re-done in init_request_from_bio(),
  61.      * but we need to set it earlier to expose the sync flag to the
  62.      * rq allocator and io schedulers.
  63.      */
  64.     rw_flags = bio_data_dir(bio);
  65.     /*判断是否需要sync，即直接将IO请求unplug(提交到块设备驱动层)，不用等待kblockd来定期plug*/
  66.     if (sync)
  67.         rw_flags |= REQ_SYNC;

  69.     /*
  70.      * Grab a free request. This is might sleep but can not fail.
  71.      * Returns with the queue unlocked.
  72.      */
  73.     /*从请求队列中取一个request*/
  74.     req = get_request(q, rw_flags, bio, GFP_NOIO);
  75.     if (unlikely(!req)) {
  76.         bio_endio(bio, -ENODEV);    /* @q is dead */
  77.         goto out_unlock;
  78.     }

  80.     /*
  81.      * After dropping the lock and possibly sleeping here, our request
  82.      * may now be mergeable after it had proven unmergeable (above).
  83.      * We don't worry about that case for efficiency. It won't happen
  84.      * often, and the elevators are able to handle it.
  85.      */
  86.     /*将bio加入新的request中*/
  87.     init_request_from_bio(req, bio);

  89.     if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags))
  90.         req->cpu = raw_smp_processor_id();

  92.     plug = current->plug;
  93.     /*如果有plug，则将请求加入到plug的list中，如果没有则直接调用__blk_run_queue提交请求*/
  94.     if (plug) {
  95.         /*
  96.          * If this is the first request added after a plug, fire
  97.          * of a plug trace. If others have been added before, check
  98.          * if we have multiple devices in this plug. If so, make a
  99.          * note to sort the list before dispatch.
  100.          */
  101.         if (list_empty(&plug->list))
  102.             trace_block_plug(q);
  103.         else {/*如果请求队列中的请求数超过了限值，则先unplug?*/
  104.             if (request_count >= BLK_MAX_REQUEST_COUNT) {
  105.                 blk_flush_plug_list(plug, false);
  106.                 trace_block_plug(q);
  107.             }
  108.         }
  109.         /*把请求加入到plug的list中，当plug的list满了后(>BLK_MAX_REQUEST_COUNT)，会flush到相应设备的请求队列中(request_queue)*/
  110.         list_add_tail(&req->queuelist, &plug->list);
  111.         blk_account_io_start(req, true);
  112.     } else {
  113.         spin_lock_irq(q->queue_lock);
  114.         add_acct_request(q, req, where);
  115.         /*如果没有plug控制，最终调用此接口处理队列中的请求，最终会调用请求队列的request_fn接口处理请求*/
  116.         __blk_run_queue(q);
  117. out_unlock:
  118.         spin_unlock_irq(q->queue_lock);
  119.     }
  120. }
本文章有上海计算机培训 上海电脑培训 机构推荐阅读

喜欢

0

阅读┊ 收藏 ┊ 喜欢▼ ┊打印┊举报/Report
  

新浪BLOG意见反馈留言板　欢迎批评指正

新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 产品答疑

Copyright © 1996 - 2022 SINA Corporation, All Rights Reserved

新浪公司 版权所有