为设备建立请求队列

最新推荐文章于 2022-02-09 10:01:47 发布

苍月代表我

最新推荐文章于 2022-02-09 10:01:47 发布

阅读量450

点赞数

1.5.4 为设备建立请求队列

好啦，磁盘和分区建立好了，block_device数据结构也关联起来了，回到add_disk中，我们需要调用第三个函数了，也就是blk_register_queue(disk)，来建立请求队列与bio等数据结构了，让我们来仔细分析。

4079 int blk_register_queue(struct gendisk *disk)

4080 {

4081 int ret;

4082

4083 request_queue_t *q = disk->queue;

4084

4085 if (!q || !q->request_fn)

4086 return -ENXIO;

4087

4088 q->kobj.parent = kobject_get(&disk->kobj);

4089

4090 ret = kobject_add(&q->kobj);

4091 if (ret < 0)

4092 return ret;

4093

4094 kobject_uevent(&q->kobj, KOBJ_ADD);

4095

4096 ret = elv_register_queue(q);

4097 if (ret) {

4098 kobject_uevent(&q->kobj, KOBJ_REMOVE);

4099 kobject_del(&q->kobj);

4100 return ret;

4101 }

4102

4103 return 0;

4104 }

首先，4090行这个kobject_add很好解释，在/sys/block/sda/目录下面又多一个子目录而已，但问题是，这个q究竟是什么？这里我们把disk->queue赋给了它，而disk->queue又是什么呢？回过头去看sd_probe()，当时我们有这么一句：

gd->queue = sdkp->device->request_queue;

而sdkp是struct scsi_disk结构体指针，其device成员是struct scsi_device指针，那么这个request_queue则是struct request_queue结构体指针，表示的是一个请求队列。在scsi的probe函数，也就是sd_probe的被调用之前，核心层实际上已经为它们做了许多工作了。这里涉及到scsi总线驱动的概念，我们将在“块设备驱动层的处理”一节中详细介绍这一过程，这里只提一下，这个过程中会调用scsi_probe_and_add_lun为对应scsi磁盘申请一个scsi_device结构体变量，为它的一些成员赋好了值，这其中就包括了这个请求队列。

准确地说，在scsi总线扫描的时候，每当探测到一个设备，scsi_probe_and_add_lun函数会通过scsi_alloc_sdev函数申请一个scsi_device，scsi_alloc_sdev会调用scsi_alloc_queue初始化这个块设备的request_queue。而这个函数涉及到很多block层提供的函数，所以我们不得不从这里开始看起，来自drivers/scsi/scsi_lib.c：

1569 struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,

1570 request_fn_proc *request_fn)

1571 {

1572 struct request_queue *q;

1573

1574 q = blk_init_queue(request_fn, NULL);

1575 if (!q)

1576 return NULL;

1577

1578 blk_queue_max_hw_segments(q, shost->sg_tablesize);

1579 blk_queue_max_phys_segments(q, SCSI_MAX_PHYS_SEGMENTS);

1580 blk_queue_max_sectors(q, shost->max_sectors);

1581 blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));

1582 blk_queue_segment_boundary(q, shost->dma_boundary);

1583

1584 if (!shost->use_clustering)

1585 clear_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);

1586 return q;

1587 }

1588 EXPORT_SYMBOL(__scsi_alloc_queue);

1589

1590 struct request_queue *scsi_alloc_queue(struct scsi_device *sdev)

1591 {

1592 struct request_queue *q;

1593

1594 q = __scsi_alloc_queue(sdev->host, scsi_request_fn);

1595 if (!q)

1596 return NULL;

1597

1598 blk_queue_prep_rq(q, scsi_prep_fn);

1599 blk_queue_issue_flush_fn(q, scsi_issue_flush_fn);

1600 blk_queue_softirq_done(q, scsi_softirq_done);

1601 return q;

1602 }

这两个函数因为调用关系所以一并贴了出来。我们首先要看的很自然就是blk_init_queue(),它来自block/ll_rw_blk.c:

1893 request_queue_t *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)

1894 {

1895 return blk_init_queue_node(rfn, lock, -1);

1896 }

1897 EXPORT_SYMBOL(blk_init_queue);

1898

1899 request_queue_t *

1900 blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)

1901 {

1902 request_queue_t *q = blk_alloc_queue_node(GFP_KERNEL, node_id);

1903

1904 if (!q)

1905 return NULL;

1906

1907 q->node = node_id;

1908 if (blk_init_free_list(q)) {

1909 kmem_cache_free(requestq_cachep, q);

1910 return NULL;

1911 }

1912

1913 /*

1914 * if caller didn't supply a lock, they get per-queue locking with

1915 * our embedded lock

1916 */

1917 if (!lock) {

1918 spin_lock_init(&q->__queue_lock);

1919 lock = &q->__queue_lock;

1920 }

1921

1922 q->request_fn = rfn;

1923 q->prep_rq_fn = NULL;

1924 q->unplug_fn = generic_unplug_device;

1925 q->queue_flags = (1 << QUEUE_FLAG_CLUSTER);

1926 q->queue_lock = lock;

1927

1928 blk_queue_segment_boundary(q, 0xffffffff);

1929

1930 blk_queue_make_request(q, __make_request);

1931 blk_queue_max_segment_size(q, MAX_SEGMENT_SIZE);

1932

1933 blk_queue_max_hw_segments(q, MAX_HW_SEGMENTS);

1934 blk_queue_max_phys_segments(q, MAX_PHYS_SEGMENTS);

1935

1936 q->sg_reserved_size = INT_MAX;

1937

1938 /*

1939 * all done

1940 */

1941 if (!elevator_init(q, NULL)) {

1942 blk_queue_congestion_threshold(q);

1943 return q;

1944 }

1945

1946 blk_put_queue(q);

1947 return NULL;

1948 }

别看这些函数都很可怕，正我们目前需要关注的其实只是其中的某几个而已。它们这个blk_alloc_queue_node和elevator_init()。前者来自block/ll_rw_blk.c，后者则来自block/elevator.c：

1836 request_queue_t *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)

1837 {

1838 request_queue_t *q;

1839

1840 q = kmem_cache_alloc_node(requestq_cachep, gfp_mask, node_id);

1841 if (!q)

1842 return NULL;

1843

1844 memset(q, 0, sizeof(*q));

1845 init_timer(&q->unplug_timer);

1846

1847 snprintf(q->kobj.name, KOBJ_NAME_LEN, "%s", "queue");

1848 q->kobj.ktype = &queue_ktype;

1849 kobject_init(&q->kobj);

1850

1851 q->backing_dev_info.unplug_io_fn = blk_backing_dev_unplug;

1852 q->backing_dev_info.unplug_io_data = q;

1853

1854 mutex_init(&q->sysfs_lock);

1855

1856 return q;

1857 }

还记得块设备初始化的那个blk_dev_init吧，当时我们调用kmem_cache_create()申请了一个slab内存分配器request_cachep，现在就该用它了。从这个分配器里申请了一个struct request_queue_t结构体的空间，给了指针q，然后1844行初始化为0。而1847行让q的kobj.name等于“queue”，这就是为什么今后我们在/sys/block/sda/目录下面能看到一个叫做“queue”的目录。

而这个queue目录下面的内容是什么呢？

[root@localhost ~]# ls /sys/block/sda/queue/

iosched max_hw_sectors_kb max_sectors_kb nr_requests read_ahead_kb scheduler

这几个文件从哪来的？注意1848行那个queue_ktype：

static struct kobj_type queue_ktype = {

.sysfs_ops = &queue_sysfs_ops,

.default_attrs = default_attrs,

.release = blk_release_queue,

};

这些就是定义了一些属性，kobject的属性。不过有一个东西例外，它就是iosched，这不是一个文件，这是一个目录：

[root@localhost ~]# ls /sys/block/sdf/queue/iosched/

back_seek_max

fifo_expire_async

quantum

slice_async_rq

slice_sync

back_seek_penalty

fifo_expire_sync

slice_async

slice_idle

关于这个目录，我们需要分析blk_init_queue_node函数中的另一个函数，elevator_init()。要弄清这个函数，需要学习块设备I/O调度层的核心——I/O调度算法。下面我们就一同进入。

苍月代表我

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
为设备建立请求队列

1.5.4 为设备建立请求队列好啦，磁盘和分区建立好了，block_device数据结构也关联起来了，回到add_disk中，我们需要调用第三个函数了，也就是blk_register_queue(disk)，来建立请求队列与bio等数据结构了，让我们来仔细分析。 4079 int blk_register_queue(struct gendisk *disk)
复制链接

扫一扫