noop io scheduler

最新推荐文章于 2021-05-13 16:09:17 发布

yiyeguzhou100

最新推荐文章于 2021-05-13 16:09:17 发布

阅读量450

点赞数

分类专栏： Storage

Storage 专栏收录该内容

70 篇文章 4 订阅 ¥9.90 ¥99.00

订阅专栏

定义了一个elevator_noop的调度器类型：

static struct elevator_type elevator_noop = {
   .ops = {
       .elevator_merge_req_fn       = noop_merged_requests,//查询一个request，用于将bio并入
       .elevator_dispatch_fn       = noop_dispatch,//将noop调度器链表中最前面的请求取出，分派给块设备的请求队列
       .elevator_add_req_fn       = noop_add_request,//将一个新request加入noop调度器链表的尾部
       .elevator_queue_empty_fn   = noop_queue_empty,//判断noop调度器链表中是否存在请求
       .elevator_former_req_fn       = noop_former_request,//在noop调度器链表中，获取指定请求的前一个请求
       .elevator_latter_req_fn       = noop_latter_request,//在noop调度器链表中，获取指定请求的后一个请求
       .elevator_init_fn       = noop_init_queue,
       .elevator_exit_fn       = noop_exit_queue,
   },
   .elevator_name = "noop",
   .elevator_owner = THIS_MODULE,
};

定义了一个管理noop调度器的数据结构：
struct noop_data {
struct list_head queue;
};
只有一个成员queue，其实就是noop中维护的一个fifo（先进先出）链表的链表头，当io请求过来了，就会被加入到这个链表的尾部。
在链表前面的才会被移到块设备的请求队列(request_queue)中。我们来看看关键的两个函数。
static void noop_add_request(struct request_queue *q, struct request *rq)
{
struct noop_data *nd = q->elevator->elevator_data;
list_add_tail(&rq->queuelist, &nd->queue);
}

看到了list_add_tail了吧，这里就将请求加入到链表的尾部。

再来看看请求是如何从noop调度器的fifo链表移动到块设备的请求队列(request_queue)中的

static int noop_dispatch(struct request_queue *q, int force)
{
struct noop_data *nd = q->elevator->elevator_data;

if (!list_empty(&nd->queue)) //调度器链表中有请求
{
struct request *rq;
rq = list_entry(nd->queue.next, struct request, queuelist);//获取调度器链表中的第一个请求
list_del_init(&rq->queuelist);//将该请求从调度器链表中删除
/*
将该请求发往块设备的请求队列request_queue
并通过request需要访问的起始地址，将该请求插入到块设备请求队列的适当位置
*/
elv_dispatch_sort(q, rq);
return 1;
}
return 0;
}

同样很简单 rq = list_entry(nd->queue.next, struct request, queuelist);
这个list_entry宏是根据当前的链表节点找到对应的对象。其实质是container_of()宏，内核中大量使用这个宏，可以说它是内核的基础。
如果你之前接触过驱动，那么对这个宏肯定不陌生。
这个对象的类型是由第二参数决定的，这个节点在对象结构体中的名字是由第三个参数决定的，那么第一个参数就是要处理的节点了。
为什么是queue.next呢？因为queue是头(head)，它的下一个(next)才是链表的第一个节点(node)。

list_del_init(&rq->queuelist);
将刚才找到的节点(node)从链表中删掉，为什么呢？因为这个即将进入块设备的request_queue，得让第二节点变成第一个，否则后面的请求就永无翻身之日了。

elv_dispatch_sort(q, rq);
相信大家已经知道这个函数是将刚才取出的第一个rq放入到块设备的请求队列(request_queue)中。

好了，noop就是这么简单。

附：2.6.32版本下noop的完整代码加注释

struct noop_data {
   struct list_head queue;
};

//将合并后多余的那个请求给删除
static void noop_merged_requests(struct request_queue *q, struct request *rq,
               struct request *next)
{
   list_del_init(&next->queuelist);
}

//将noop调度器中首结点对应的请求发往块设备的请求队列request_queue
static int noop_dispatch(struct request_queue *q, int force)
{
   struct noop_data *nd = q->elevator->elevator_data;

   if (!list_empty(&nd->queue)) {//调度器链表中有请求
       struct request *rq;
       rq = list_entry(nd->queue.next, struct request, queuelist);//获取调度器链表中的第一个请求
       list_del_init(&rq->queuelist);//将该请求从调度器链表中删除
       /*
       将该请求发往块设备的请求队列request_queue
       并通过request需要访问的起始地址，将该请求插入到块设备请求队列的适当位置
       */
       elv_dispatch_sort(q, rq);
       return 1;
   }
   return 0;
}

//将请求加入调度器链表的尾部
static void noop_add_request(struct request_queue *q, struct request *rq)
{
   struct noop_data *nd = q->elevator->elevator_data;

   list_add_tail(&rq->queuelist, &nd->queue);
}

//判断调度器链表中是否没有请求
static int noop_queue_empty(struct request_queue *q)
{
   struct noop_data *nd = q->elevator->elevator_data;

   return list_empty(&nd->queue);
}

//在调度器链表中，获取请求rq的前一个请求
static struct request *
noop_former_request(struct request_queue *q, struct request *rq)
{
   struct noop_data *nd = q->elevator->elevator_data;

   if (rq->queuelist.prev == &nd->queue)//如果该请求rq已经是第一个请求，则返回NULL
       return NULL;
   /*
   通过内嵌的双向链表结构获取request的地址
   该list_head结点的起始地址 + list_head成员在request结构中的偏移地址 = request的起始地址
   */
   return list_entry(rq->queuelist.prev, struct request, queuelist);
}

//在调度器链表中，获取请求rq的下一个请求
static struct request *
noop_latter_request(struct request_queue *q, struct request *rq)
{
   struct noop_data *nd = q->elevator->elevator_data;

   if (rq->queuelist.next == &nd->queue)
       return NULL;
   return list_entry(rq->queuelist.next, struct request, queuelist);
}

static void *noop_init_queue(struct request_queue *q)
{
   struct noop_data *nd;

   nd = kmalloc_node(sizeof(*nd), GFP_KERNEL, q->node);
   if (!nd)
       return NULL;
   INIT_LIST_HEAD(&nd->queue);
   return nd;
}

static void noop_exit_queue(struct elevator_queue *e)
{
   struct noop_data *nd = e->elevator_data;

   BUG_ON(!list_empty(&nd->queue));
   kfree(nd);
}

static struct elevator_type elevator_noop = {
   .ops = {
       .elevator_merge_req_fn       = noop_merged_requests,//查询一个request，用于将bio并入
       .elevator_dispatch_fn       = noop_dispatch,//将调度器的链表中最前面的元素取出，分派给块设备的请求队列
       .elevator_add_req_fn       = noop_add_request,//将一个新request加入noop调度器链表的尾部
       .elevator_queue_empty_fn   = noop_queue_empty,//判断noop调度器链表中是否存在请求
       .elevator_former_req_fn       = noop_former_request,//在noop调度器链表中，获取指定请求的前一个请求
       .elevator_latter_req_fn       = noop_latter_request,//在noop调度器链表中，获取指定请求的后一个请求
       .elevator_init_fn       = noop_init_queue,
       .elevator_exit_fn       = noop_exit_queue,
   },
   .elevator_name = "noop",
   .elevator_owner = THIS_MODULE,
};

static int __init noop_init(void)
{
   elv_register(&elevator_noop);

   return 0;
}

static void __exit noop_exit(void)
{
   elv_unregister(&elevator_noop);
}

module_init(noop_init);
module_exit(noop_exit);

---------------------
作者：在hust快乐的学习
来源：CSDN
原文：https://blog.csdn.net/hs794502825/article/details/24663041
版权声明：本文为博主原创文章，转载请附上博文链接！

请求队列request_queue
请求队列是由一个大的数据结构request_queue表示的。

struct request_queue {
struct list_head queue_head; //待处理请求的链表，请求队列中的请求用链表组织在一起
struct request *last_merge; //指向队列中首先可能合并的请求描述符
struct elevator_queue *elevator;//指向elevator对象的指针（电梯算法）
struct request_list root_rl;///为分配请求描述符所使用的数据结构

request_fn_proc *request_fn;//实现驱动程序的策略例程入口点的方法,由他处理队列中请求
make_request_fn *make_request_fn;//将一个新请求插入请求队列时调用的方法
prep_rq_fn *prep_rq_fn; //该方法把这个处理请求的命令发送给硬件设备

softirq_done_fn *softirq_done_fn;
rq_timed_out_fn *rq_timed_out_fn;

sector_t end_sector;
struct request *boundary_rq;
struct delayed_work delay_work;

struct backing_dev_info backing_dev_info;

/*
* The queue owner gets to use this for whatever they like.
* ll_rw_blk doesn't touch it.
*/
void *queuedata;
spinlock_t __queue_lock; //请求队列锁
spinlock_t *queue_lock; //指向请求队列锁的指针

unsigned long nr_requests;/* 请求队列中允许的最大请求数 */

struct queue_limits limits;//队列的其他限制
};

该结构是串联整个块设备驱动的核心，下面列举几个特别重要的元素：

request_fn_proc *request_fn; 它是实现驱动程序的策略例程入口点的方法,由他处理队列中请求，我们所写的块设备驱动程序的核心就是它的请求处理函数（request_fn）。
make_request_fn *make_request_fn;将一个新请求插入请求队列时调用的方法，块设备的io调度程序主要是在该函数内完成。
struct elevator_queue *elevator;指向elevator对象的指针（电梯算法），决定了io调度层使用的io调度算法。
请求队列是一个双向链表，其元素就是请求描述符（也就是request数据结构）。请求队列描述符中的queue_head字段存放链表的头（第一个伪元素），而请求描述符中queuelist字段的指针把任一请求链接到链表的前一个和后一个元素之间。

队列链表中元素的排序方式对每个块设备驱动程序是特定的；然而，I/O调度程序提供了几种预先确定好的元素排序方式，牵涉到“I/O调度算法”的概念。

我们通过一个图把前面的知识串联起来：

è¿éåå¾çæè¿°
---------------------
作者：uestc-leon
来源：CSDN
原文：https://blog.csdn.net/weixin_36145588/article/details/72941021
版权声明：本文为博主原创文章，转载请附上博文链接！

yiyeguzhou100

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
noop io scheduler

定义了一个elevator_noop的调度器类型：static struct elevator_type elevator_noop = { .ops = { .elevator_merge_req_fn = noop_merged_requests,//查询一个request，用于将bio并入 .elevator_dispatch_fn...
复制链接

扫一扫