• linux内核源码分析 - nvme设备的初始化

    【好文推荐】

    浅析linux内核网络协议栈--linux bridge

    深入理解SR-IOV和IO虚拟化

    virtio-net 实现机制【一】（图文并茂）

    驱动的加载

    驱动加载实际就是module的加载,而module加载时会对整个module进行初始化,nvme驱动的module初始化函数为nvme_init(),如下:

    1. static struct pci_driver nvme_driver = {
    2.     .name        = "nvme",
    3.     .id_table    = nvme_id_table,
    4.     .probe        = nvme_probe,
    5.     .remove        = nvme_remove,
    6.     .shutdown    = nvme_shutdown,
    7.     .driver        = {
    8.         .pm    = &nvme_dev_pm_ops,
    9.     },
    10.     .err_handler    = &nvme_err_handler,
    11. };
    12.  
    13. static int __init nvme_init(void)
    14. {
    15.     int result;
    16.  
    17.     /* 初始化等待队列nvme_kthread_wait,此等待队列用于创建nvme_kthread(只允许单进程创建nvme_kthread) */
    18.     init_waitqueue_head(&nvme_kthread_wait);
    19.  
    20.     /* 创建一个workqueue叫nvme */
    21.     nvme_workq = create_singlethread_workqueue("nvme");
    22.     if (!nvme_workq)
    23.         return -ENOMEM;
    24.  
    25.     /* 在内核中注册新的一类块设备驱动,名字叫nvme,注意这里只是注册,表示kernel支持了nvme类的块设备,返回一个major,之后所有的nvme设备的major都是此值 */
    26.     result = register_blkdev(nvme_major, "nvme");
    27.     if (result < 0)
    28.         goto kill_workq;
    29.     else if (result > 0)
    30.         nvme_major = result;
    31.  
    32.     /* 注册一些通知信息 */
    33.     nvme_nb.notifier_call = &nvme_cpu_notify;
    34.     result = register_hotcpu_notifier(&nvme_nb);
    35.     if (result)
    36.         goto unregister_blkdev;
    37.  
    38.     /* 注册pci nvme驱动 */
    39.     result = pci_register_driver(&nvme_driver);
    40.     if (result)
    41.         goto unregister_hotcpu;
    42.     return 0;
    43.  
    44.  unregister_hotcpu:
    45.     unregister_hotcpu_notifier(&nvme_nb);
    46.  unregister_blkdev:
    47.     unregister_blkdev(nvme_major, "nvme");
    48.  kill_workq:
    49.     destroy_workqueue(nvme_workq);
    50.     return result;
    51. }

    这里面其实最重要的就是做了两件事,一件事是register_blkdev,注册nvme这类块设备,返回一个major,另一件事是注册了nvme_driver,注册了nvme_driver后,当有nvme设备插入后系统后,系统会自动调用nvme_driver->nvme_probe去初始化这个nvme设备.这时候可能会有疑问,系统是如何知道插入的设备是nvme设备的呢,注意看struct pci_driver nvme_driver这个结构体,里面有一个nvme_id_table,其内容如下:

    1. /* Move to pci_ids.h later */
    2. #define PCI_CLASS_STORAGE_EXPRESS    0x010802
    3.  
    4. static const struct pci_device_id nvme_id_table[] = {
    5.     { PCI_DEVICE_CLASS(PCI_CLASS_STORAGE_EXPRESS, 0xffffff) },
    6.     { 0, }
    7. };

    再看看PCI_DEVICE_CLASS宏是如何定义的

    1. #define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
    2.      .class = (dev_class), .class_mask = (dev_class_mask), \
    3.      .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
    4.      .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID

    也就是当pci class为PCI_CLASS_STORAGE_EXPRESS时,就表示是nvme设备,并且这个是写在设备里的,当设备插入host时,pci driver(并不是nvme driver)回去读取这个值,然后判断它需要哪个驱动去做处理.

    nvme数据结构

    现在假设nvme.ko已经加载完了(注册了nvme类块设备,并且注册了nvme driver),这时候如果有nvme盘插入pcie插槽,pci会自动识别到,并交给nvme driver去处理,而nvme driver就是调用nvme_probe去处理这个新加入的设备.

    在说nvme_probe之前,先说一下nvme设备的数据结构,首先,内核使用一个nvme_dev结构体来描述一个nvme设备, 一个nvme设备对应一个nvme_dev,nvme_dev如下:

    1. /* nvme设备描述符,描述一个nvme设备 */
    2. struct nvme_dev {
    3.     struct list_head node;
    4.     /* 设备的queue,一个nvme设备至少有2个queue,一个admin queue,一个io queue,实际情况一般都是一个admin queue,多个io queue,并且io queue会与CPU做绑定 */
    5.     struct nvme_queue __rcu **queues;
    6.     /* unsigned short的数组，每个CPU占一个,主要用于存放CPU上绑定的io queue的qid,一个CPU绑定一个queues,一个queues绑定到1到多个CPU上 */
    7.     unsigned short __percpu *io_queue;
    8.     /* ((void __iomem *)dev->bar) + 4096 */
    9.     u32 __iomem *dbs;
    10.     /* 此nvme设备对应的pci dev */
    11.     struct pci_dev *pci_dev;
    12.     /* dma池,主要是以4k为大小的dma块,用于dma分配 */
    13.     struct dma_pool *prp_page_pool;
    14.     /* 也是dma池,但是不是以4k为大小的,是小于4k时使用 */
    15.     struct dma_pool *prp_small_pool;
    16.     /* 实例的id,第一个加入的nvme dev,它的instance为0,第二个加入的nvme,instance为1,也用于做/dev/nvme%d的显示,%d实际就是instance的数值 */
    17.     int instance;
    18.     /* queue的数量, 等于admin queue + io queue */
    19.     unsigned queue_count;
    20.     /* 在线可以使用的queue数量,跟online cpu有关 */
    21.     unsigned online_queues;
    22.     /* 最大的queue id */
    23.     unsigned max_qid;
    24.     /* nvme queue支持的最大cmd数量，为((bar->cap) & 0xffff)或者1024的最小值 */
    25.     int q_depth;
    26.     /* 1 << (((bar->cap) >> 32) & 0xf)，应该是每个io queue占用的bar空间 */
    27.     u32 db_stride;
    28.     /*    初始化设置的值
    29.      *    dev->ctrl_config = NVME_CC_ENABLE | NVME_CC_CSS_NVM;
    30.      *    dev->ctrl_config |= (PAGE_SHIFT - 12) << NVME_CC_MPS_SHIFT;
    31.      *    dev->ctrl_config |= NVME_CC_ARB_RR | NVME_CC_SHN_NONE;
    32.      *    dev->ctrl_config |= NVME_CC_IOSQES | NVME_CC_IOCQES;
    33.      */
    34.     u32 ctrl_config;
    35.     /* msix中断所使用的entry,指针表示会使用多个msix中断,使用的中断的个数与io queue对等,多少个io queue就会申请多少个中断
    36.      * 并且让每个io queue的中断尽量分到不同的CPU上运行
    37.      */
    38.     struct msix_entry *entry;
    39.     /* bar的映射地址，默认是映射8192，当io queue过多时，有可能会大于8192 */
    40.     struct nvme_bar __iomem *bar;
    41.     /* 其实就是块设备,一张nvme卡有可能会有多个块设备 */
    42.     struct list_head namespaces;
    43.     /* 对应的在/sys下的结构 */
    44.     struct kref kref;
    45.     /* 对应的字符设备,用于ioctl操作 */
    46.     struct miscdevice miscdev;
    47.     /* 2个work,暂时还不知道什么用 */
    48.     work_func_t reset_workfn;
    49.     struct work_struct reset_work;
    50.     struct work_struct cpu_work;
    51.     /* 这个nvme设备的名字,为nvme%d */
    52.     char name[12];
    53.     /* SN号 */
    54.     char serial[20];
    55.     char model[40];
    56.     char firmware_rev[8];
    57.     /* 这些值都是从nvme盘上获取 */
    58.     u32 max_hw_sectors;
    59.     u32 stripe_size;
    60.     u16 oncs;
    61.     u16 abort_limit;
    62.     u8 vwc;
    63.     u8 initialized;
    64. };

    在nvme_dev结构中,最最重要的数据就是nvme_queue,struct nvme_queue用来表示一个nvme的queue,每一个nvme_queue会申请自己的中断,也有自己的中断处理函数,也就是每个nvme_queue在驱动层面是完全独立的.nvme_queue有两种,一种是admin queue,一种是io queue,这两种queue都用struct nvme_queue来描述,而这两种queue的区别如下:

    • admin queue: 用于发送控制命令的queue,所有非io命令都会通过此queue发送给nvme设备,一个nvme设备只有一个admin queue,在nvme_dev中,使用queues[0]来描述.
    • io queue: 用于发送io命令的queue,所有io命令都是通过此queue发送给nvme设备,简单来说读/写操作都是通过io queue发送给nvme设备的,一个nvme设备有一个或多个io queue,每个io queue的中断会绑定到不同的一个或多个CPU上.在nvme_dev中,使用queues[1~N]来描述.

    以上说的io命令和非io命令都是nvme命令,比如快层下发一个写request,nvme驱动就会根据此request构造出一个写命令,将这个写命令放入某个io queue中,当controller完成了这个写命令后,会通过此io queue的中断返回完成信息,驱动再将此完成信息返回给块层.明白了两种队列的作用,我们看看具体的数据结构struct nvme_queue

    1. /* nvme的命令队列，其中包括sq和cq。一个nvme设备至少包含两个命令队列
    2.  * 一个是控制命令队列，一个是IO命令队列
    3.  */
    4. struct nvme_queue {
    5.     struct rcu_head r_head;
    6.     struct device *q_dmadev;
    7.     /* 所属的nvme_dev */
    8.     struct nvme_dev *dev;
    9.     /* 中断名字，名字格式为nvme%dq%d，在proc/interrupts可以查看到 */
    10.     char irqname[24];    /* nvme4294967295-65535\0 */
    11.     /* queue的锁，当操作nvme_queue时，需要占用此锁 */
    12.     spinlock_t q_lock;
    13.     /* sq的虚拟地址空间，主机需要发给设备的命令就存在这里面 */
    14.     struct nvme_command *sq_cmds;
    15.     /* cq的虚拟地址空间，设备返回的命令就存在这里面 */
    16.     volatile struct nvme_completion *cqes;
    17.     /* 实际就是sq_cmds的dma地址 */
    18.     dma_addr_t sq_dma_addr;
    19.     /* cq的dma地址，实际就是cqes对应的dma地址，用于dma传输 */
    20.     dma_addr_t cq_dma_addr;
    21.     /* 等待队列，当sq满时，进程会加到此等待队列，等待有空闲的cmd区域 */
    22.     wait_queue_head_t sq_full;
    23.     /* wait queue的一个entry,主要是当cmdinfo满时,会将它放入sq_full,而sq_full最后会通过它,唤醒nvme_thread */
    24.     wait_queue_t sq_cong_wait;
    25.     struct bio_list sq_cong;
    26.     /* iod是读写请求的封装,可以看成是一个bio的封装,此链表有可能为空,比如admin queue就为空 */
    27.     struct list_head iod_bio;
    28.     /* 当前sq_tail位置，是nvme设备上的一个寄存器，告知设备最新的发送命令存在哪，存在于bar空间中 */
    29.     u32 __iomem *q_db;
    30.     /* cq和sq最大能够存放的command数量 */
    31.     u16 q_depth;
    32.     /* 如果是admin queue，那么为0，之后的io queue按分配顺序依次增加，主要用于获取对应的irq entry，因为所有的queue的irq entry是一个数组 */
    33.     u16 cq_vector;
    34.     /* 当完成命令时会更新，当sq_head == sq_tail时表示cmd queue为空 */
    35.     u16 sq_head;
    36.     /* 当有新的命令存放到sq时，sq_tail++，如果sq_tail == q_depth，那么sq_tail会被重新设置为0，并且cq_phase翻转 
    37.      * 实际上就是一个环
    38.      */
    39.     u16 sq_tail;
    40.     /* 驱动已经处理完成的cmd位置,当cq_head == sq_tail时,表示cmd队列为空,当sq_tail == cq_head - 1时表示cmd队列已满 */
    41.     u16 cq_head;
    42.     /* 此nvme queue在此nvme设备中的queue id 
    43.      * 0: 控制命令队列
    44.      */
    45.     u16 qid;
    46.     /* 初始设为1，主要用于判断命令是否完成，当cqe.status & 1 != cq_phase时，表示命令还没有完成
    47.      * 当每次sq_tail == q_depth时,此值会取反
    48.      */
    49.     u8 cq_phase;
    50.     u8 cqe_seen;
    51.     /* 初始设为1 */
    52.     u8 q_suspended;
    53.     /* CPU亲和性，用于设置此nvme queue能够在哪些CPU上做中断和中断处理 */
    54.     cpumask_var_t cpu_mask;
    55.     struct async_cmd_info cmdinfo;
    56.     /* 实际就是cmdinfo，此包含d_depth个cmdinfo，一个cmdid表示一个cmdinfo，当对应的bit为0时，表示此槽位空闲，为1时表示此槽位存有cmd 
    57.      * 空闲的cmdinfo的默认完成回调函数都是special_completion
    58.      * 其内存结构如下
    59.      *                      d_depth bits                                       d_depth cmdinfo
    60.      *   (每个bit一个cmdid，用于表示此cmdinfo是空闲还是被占用)              (d_depth个struct nvme_cmd_info)
    61.      * |                                                      |                                                   |
    62.      */
    63.     unsigned long cmdid_data[];
    64. };

    nvme_queue是nvme驱动最核心的数据结构,它是nvme驱动和nvme设备通信的桥梁,重点也要围绕nvme_queue来说,之前也说过,一个nvme设备有多个nvme_queue(一个admin queue,至少一个io queue),每个nvme_queue是独立的,它们有

    • 自己对应的中断(irq)
    • 自己的submission queue(sq),用于将struct nvme command发送给nvme设备,并且最多能存dev->d_depth个nvme command
    • 自己的completion queue(cq),用于nvme设备将完成的命令信息(struct nvme_completion)发送给host,并且最多能存dev->d_depth个nvme_completion.
    • 自己的cmdinfo,用于描述一个nvme command.(struct nvme_cmd_info)

    可以把sq想象成一个struct nvme_command sq[dev->d_depth]的数组,而cq为struct nvme_completion cq[dev->d_depth]的数组.

    struct nvme_command主要用于存储一个nvme命令,包括io命令,或者控制命令,当初始化好一个struct nvme_command后,直接将其下发给nvme设备,nvme设备就会根据它来执行对应操作,其结构如下:

    1. struct nvme_command {
    2.     union {
    3.         struct nvme_common_command common;
    4.         struct nvme_rw_command rw;
    5.         struct nvme_identify identify;
    6.         struct nvme_features features;
    7.         struct nvme_create_cq create_cq;
    8.         struct nvme_create_sq create_sq;
    9.         struct nvme_delete_queue delete_queue;
    10.         struct nvme_download_firmware dlfw;
    11.         struct nvme_format_cmd format;
    12.         struct nvme_dsm_cmd dsm;
    13.         struct nvme_abort_cmd abort;
    14.     };
    15. };
    16.  
    17.  
    18. struct nvme_format_cmd {
    19.     __u8            opcode;
    20.     __u8            flags;
    21.     __u16            command_id;　　
    22.     __le32            nsid;
    23.     __u64            rsvd2[4];
    24.     __le32            cdw10;
    25.     __u32            rsvd11[5];
    26. };

    联合体里面就是nvme支持的所有种类的命令,我随便取了一个nvme_format_cmd,可以看看里面的变量,只要将这些变量设置正确,传给nvme设备,nvme是能够执行这个命令的.

    再看看struct nvme_completion,它用于描述完成的命令

    1. struct nvme_completion {
    2.     __le32    result;        /* Used by admin commands to return data */
    3.     __u32    rsvd;
    4.     __le16    sq_head;    /* how much of this queue may be reclaimed */
    5.     __le16    sq_id;        /* submission queue that generated this entry */
    6.     __u16    command_id;    /* of the command which completed */
    7.     __le16    status;        /* did the command fail, and if so, why? */
    8. };

    按之前说的,我们把sq和cq想象成两个数组,比如驱动之前将一个nvme_format_cmd放到了sq[10]中,设备对这个nvme_format_cmd命令做了处理,这时候设备就会返回一个nvme_completion,并且把这个nvme_completion放入到cq[6](这里的index为6是假设,实际上我认为一个nvme_command对应一个nvme_completion,如果这个假设成立的话,正常情况这里应该也是为10),并且产生一个中断,在nvme queue的中断处理中,会获取到这个nvme_completion,并通过nvme_completion->sq_head就能够获取到sq[10]中的nvme_format_cmd.这样sq和cq就能够完全联系起来了.

    对于驱动来说,一个命令应该是由两部分组成:

    1. 命令的格式,要通过怎样的格式发送给硬件,硬件能够识别.
    2. 命令的额外信息.

    对于第一点,实际上就是nvme_command来做,而对于第二点,就需要用nvme_cmd_info来保存了,nvme_cmd_info也是一个数组,根据d_depth来分配长度(因为sq和cq都是根据d_depth来分配长度),并且nvme_queue还会维护一个nvme_cmd_info的used_bitmap,用来表示哪个nvme_cmd_info数组中哪个cmd_info已经被占用,nvme_cmd_info如下:

    1. struct nvme_cmd_info {
    2.     nvme_completion_fn fn;    // 命令完成后的回调函数
    3.     void *ctx;                // 命令的信息,不同命令使用不同结构来描述,所以这里只提供一个指针
    4.     unsigned long timeout;    // 命令允许的超时时间
    5.     int aborted;            // 命令是否作废
    6. };

    现在来说说nvme驱动怎么把nvme_command,nvme_completion和nvme_cmd_info联系起来,以上面的nvme_format_cmd为例,假设nvme驱动要发送一个nvme_format_cmd命令,那么先会从nvme_cmd_info的used_bitmap中获取一个空闲的nvme_cmd_info(包括这个cmd_info对应的index,实际就是nvme_cmd_info的数组下标,也称为cmdid),然后根据nvme_format_cmd驱动需要做的事情和信息,来初始化这个nvme_cmd_info,将nvme_format_cmd中的command_id设置为cmdid,发送nvme_format_cmd给nvme设备,nvme设备处理完毕后,发送nvme_format_cmd对应的nvme_completion给host,host获取到此nvme_comletion,从command_id中获取到cmdid,根据获取到的cmdid就能够获取到对应的nvme_cmd_info了.也就是说,在将命令发送给nvme设备时,要将cmd_info对应的cmd_id也一并传下去,之后命令返回时,nvme设备也会将这个cmd_id传回来,这样就能够将三者对应联系起来了.

    nvme设备初始化

    之前也说了,nvme驱动加载好后,如果有新的nvme设备加入,那么会通过nvme_probe来初始化这个nvme设备,我们先看看nvme_probe这个函数.

    1. /* 当插入一个nvme设备时，会通过此函数进行nvme设备的初始化 */
    2. static int nvme_probe(struct pci_dev *pdev, const struct pci_device_id *id)
    3. {
    4.     int result = -ENOMEM;
    5.     /* nvme设备描述符 */
    6.     struct nvme_dev *dev;
    7.  
    8.     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    9.     if (!dev)
    10.         return -ENOMEM;
    11.     /* nvme用的是msi/msix中断，这里应该是是按numa内的CPU个数来分配entry数量，entry是msix_entry */
    12.     dev->entry = kcalloc(num_possible_cpus(), sizeof(*dev->entry),
    13.                                 GFP_KERNEL);
    14.     if (!dev->entry)
    15.         goto free;
    16.     /* struct nvme_queue，数量是numa内的CPU个数+1 */
    17.     dev->queues = kcalloc(num_possible_cpus() + 1, sizeof(void *),
    18.                                 GFP_KERNEL);
    19.     if (!dev->queues)
    20.         goto free;
    21.     /* unsigned short的数组，每个CPU占一个 */
    22.     dev->io_queue = alloc_percpu(unsigned short);
    23.     if (!dev->io_queue)
    24.         goto free;
    25.  
    26.     /* 初始化namespace链表 */
    27.     INIT_LIST_HEAD(&dev->namespaces);
    28.     /* reset work的调用函数 */
    29.     dev->reset_workfn = nvme_reset_failed_dev;
    30.     INIT_WORK(&dev->reset_work, nvme_reset_workfn);
    31.     INIT_WORK(&dev->cpu_work, nvme_cpu_workfn);
    32.     dev->pci_dev = pdev;
    33.     pci_set_drvdata(pdev, dev);
    34.     /* 分配一个ID，保存到dev->instance里,实际上第一个加入的nvme设备,它的instance为0,第二个加入的nvme设备,instance为1,以此类推 */
    35.     result = nvme_set_instance(dev);
    36.     if (result)
    37.         goto free;
    38.  
    39.     /* 主要创建两个dma pool，一个是4k大小(prp list page)，一个是256B大小(prp list 256) */
    40.     result = nvme_setup_prp_pools(dev);
    41.     if (result)
    42.         goto release;
    43.  
    44.     kref_init(&dev->kref);
    45.     /* 1.做bar空间的映射，映射地址存放到nvme_dev->bar 
    46.       * 2.当此设备是系统中第一个加载的nvme设备或者nvme_thread没有启动时，就会启动一个nvme_thread
    47.      * 3.初始化nvme的io queue(主要)
    48.      */
    49.     result = nvme_dev_start(dev);
    50.     if (result) {
    51.         if (result == -EBUSY)
    52.             goto create_cdev;
    53.         goto release_pools;
    54.     }
    55.  
    56.     /* 分配request queue和disk,执行完此函数后,在/dev/下就有此nvme设备了 */
    57.     result = nvme_dev_add(dev);
    58.     if (result)
    59.         goto shutdown;
    60.  
    61.  create_cdev:
    62.      /* 这里开始分配一个对应的混杂设备,可以理解为字符设备,主要用于应用层用ioctl接口来操作此nvme设备 
    63.       * 这个字符设备的名字为nvme%d
    64.       */
    65.     scnprintf(dev->name, sizeof(dev->name), "nvme%d", dev->instance);
    66.     dev->miscdev.minor = MISC_DYNAMIC_MINOR;
    67.     dev->miscdev.parent = &pdev->dev;
    68.     dev->miscdev.name = dev->name;
    69.     dev->miscdev.fops = &nvme_dev_fops;
    70.     result = misc_register(&dev->miscdev);
    71.     if (result)
    72.         goto remove;
    73.  
    74.     dev->initialized = 1;
    75.     return 0;
    76.  
    77.  remove:
    78.     nvme_dev_remove(dev);
    79.     nvme_free_namespaces(dev);
    80.  shutdown:
    81.     nvme_dev_shutdown(dev);
    82.  release_pools:
    83.     nvme_free_queues(dev, 0);
    84.     nvme_release_prp_pools(dev);
    85.  release:
    86.     nvme_release_instance(dev);
    87.  free:
    88.     free_percpu(dev->io_queue);
    89.     kfree(dev->queues);
    90.     kfree(dev->entry);
    91.     kfree(dev);
    92.     return result;
    93. }

    nvme_probe函数主要做如下几件事情:

    1. 为中断创建msi/msix的entry,按CPU的数量进行entry的分配,为什么要按照CPU数量进行分配,因为每个io queue会占用一个.而整个系统io queue最大值也就是possible_cpus.
    2. 分配possible个cpus+1的queue结构体,possible应该是系统最大能够插入的cpu核个数,其不等于online_cpus,注意这里是possible_cpus+1,而中断的msi/msix的entry个数为possible_cpus,而每个queue会用一个entry,这样不是就会导致有一个queue是没有entry用的吗?实际上admin queue和第一个io queue会共用entry0.
    3. 分配instance,实际上就是一个nvme id,从0开始依次递增.
    4. 分配两个dma pool,一个pool中的元素大小为4k,一个是256B,这两个pool都是用于数据传输时做dma分配用的.
    5. 调用nvme_dev_start和nvme_dev_add,这两个是主要函数,之后重点看这两个函数.

    nvme_dev_start和nvme_dev_add是负责不同的初始化,简单点说,nvme_dev_start是将硬件和驱动的联系进行初始化,当nvme_dev_start执行完成后,此nvme设备实际已经能够通过驱动正常使用了,但实际操作系统还是无法使用此设备,原因是需要nvme_dev_add函数将此设备注册到操作系统中,实际就是注册对应的gendisk和request queue,这样在/dev/和操作系统中都能过对此nvme设备进行操作.

    nvme_dev_start

    nvme_dev_start函数主要是做硬件方面与驱动方面的传输通道的初始化和硬件的一些初始化,实际主要就是建立admin queue和io queue,并且为这些queue绑定到各自的irq上.

    1. /* 1.做bar空间的映射，映射地址存放到nvme_dev->bar 
    2.  * 2.当此设备是系统中第一个加载的nvme设备或者nvme_thread没有启动时，就会启动一个nvme_thread
    3.  * 3.初始化nvme的io queue
    4.  */
    5. static int nvme_dev_start(struct nvme_dev *dev)
    6. {
    7.     int result;
    8.     bool start_thread = false;
    9.  
    10.     /* 主要做bar空间的映射，映射地址存放到nvme_dev->bar,并且从bar空间获取nvme设备的d_queue,d_queue是queue中允许的最大cmd数量 */
    11.     result = nvme_dev_map(dev);
    12.     if (result)
    13.         return result;
    14.  
    15.     /* 初始化控制命令队列，中断处理函数为nvme_irq */
    16.     result = nvme_configure_admin_queue(dev);
    17.     if (result)
    18.         goto unmap;
    19.  
    20.     spin_lock(&dev_list_lock);
    21.     /* 当此设备是系统中第一个加载的nvme设备或者nvme_thread没有启动时，就会启动一个nvme_thread */
    22.     if (list_empty(&dev_list) && IS_ERR_OR_NULL(nvme_thread)) {
    23.         start_thread = true;
    24.         nvme_thread = NULL;
    25.     }
    26.     list_add(&dev->node, &dev_list);
    27.     spin_unlock(&dev_list_lock);
    28.  
    29.     if (start_thread) {
    30.         /* 在此nvme设备的加载上下文中创建nvme_thread */
    31.         nvme_thread = kthread_run(nvme_kthread, NULL, "nvme");
    32.         wake_up(&nvme_kthread_wait);
    33.     } else
    34.         /* 非创建nvme_thread的nvme设备就会在这里等待nvme_thread创建完成 */
    35.         wait_event_killable(nvme_kthread_wait, nvme_thread);
    36.  
    37.     if (IS_ERR_OR_NULL(nvme_thread)) {
    38.         result = nvme_thread ? PTR_ERR(nvme_thread) : -EINTR;
    39.         goto disable;
    40.     }
    41.  
    42.     /* 初始化nvme的io queue，此为nvme_queue，一个nvme设备至少一个admin queue，一个io queue */
    43.     result = nvme_setup_io_queues(dev);
    44.     if (result && result != -EBUSY)
    45.         goto disable;
    46.  
    47.     return result;
    48.  
    49.  disable:
    50.     nvme_disable_queue(dev, 0);
    51.     nvme_dev_list_remove(dev);
    52.  unmap:
    53.     nvme_dev_unmap(dev);
    54.     return result;
    55. }

    需要注意,d_queue默认是1024,驱动会通过此nvme设备的pci bar空间获取到设备支持的d_queue,并取两者的最小值作为此设备所有queue的d_queue,d_queue是queue中允许存放的cmd数量最大值.

    d_queue获取到后,第一件事情是初始化admin queue,使用nvme_configure_admin_queue:

    1. /* 初始化控制命令队列，中断处理函数为nvme_irq */
    2. static int nvme_configure_admin_queue(struct nvme_dev *dev)
    3. {
    4.     int result;
    5.     u32 aqa;
    6.     u64 cap = readq(&dev->bar->cap);
    7.     struct nvme_queue *nvmeq;
    8.  
    9.     /* 应该是告诉nvme设备禁止操作 
    10.      * 实现方法是对bar空间的NVME_CC_ENABLEbit做操作,因为当前还没有做irq分配和使用,只能通过寄存器的方法做设置
    11.      */
    12.     result = nvme_disable_ctrl(dev, cap);
    13.     if (result < 0)
    14.         return result;
    15.  
    16.     /* 获取qid为0的nvme queue，实际上就是admin queue */
    17.     nvmeq = raw_nvmeq(dev, 0);
    18.     /* 如果不存在，则分配一个nvme queue的内存空间用于admin queue(qid 0) */
    19.     /* 主要分配cq和sq的dma空间，大小为depth*(struct nvme_completion)，depth*(struct nvme_command) 
    20.      * 注意sq和cq的dma空间都必须使用dma_alloc_coherent来分配
    21.      */
    22.     if (!nvmeq) {
    23.         nvmeq = nvme_alloc_queue(dev, 0, 64, 0);
    24.         if (!nvmeq)
    25.             return -ENOMEM;
    26.     }
    27.  
    28.     aqa = nvmeq->q_depth - 1;
    29.     aqa |= aqa << 16;
    30.  
    31.     dev->ctrl_config = NVME_CC_ENABLE | NVME_CC_CSS_NVM;
    32.     dev->ctrl_config |= (PAGE_SHIFT - 12) << NVME_CC_MPS_SHIFT;
    33.     dev->ctrl_config |= NVME_CC_ARB_RR | NVME_CC_SHN_NONE;
    34.     dev->ctrl_config |= NVME_CC_IOSQES | NVME_CC_IOCQES;
    35.  
    36.     /* 初始化sq和cq */
    37.     writel(aqa, &dev->bar->aqa);
    38.     writeq(nvmeq->sq_dma_addr, &dev->bar->asq);
    39.     writeq(nvmeq->cq_dma_addr, &dev->bar->acq);
    40.     writel(dev->ctrl_config, &dev->bar->cc);
    41.  
    42.     /* 应该是告诉nvme设备使能操作 */
    43.     result = nvme_enable_ctrl(dev, cap);
    44.     if (result)
    45.         return result;
    46.  
    47.     /* 分配中断，这里主要分配cq的中断，中断处理函数为nvme_irq */
    48.     result = queue_request_irq(dev, nvmeq, nvmeq->irqname);
    49.     if (result)
    50.         return result;
    51.  
    52.     spin_lock_irq(&nvmeq->q_lock);
    53.     /* 初始化cq和sq */
    54.     nvme_init_queue(nvmeq, 0);
    55.     spin_unlock_irq(&nvmeq->q_lock);
    56.     return result;
    57. }
    58.  
    59.  
    60. /* 分配cq和sq的dma空间，大小为depth*(struct nvme_completion)，depth*(struct nvme_command) */
    61. static struct nvme_queue *nvme_alloc_queue(struct nvme_dev *dev, int qid,
    62.                             int depth, int vector)
    63. {
    64.     struct device *dmadev = &dev->pci_dev->dev;
    65.     unsigned extra = nvme_queue_extra(depth);
    66.     struct nvme_queue *nvmeq = kzalloc(sizeof(*nvmeq) + extra, GFP_KERNEL);
    67.     if (!nvmeq)
    68.         return NULL;
    69.  
    70.     /* cq的dma区域,存放completion cmd的地方 */
    71.     nvmeq->cqes = dma_alloc_coherent(dmadev, CQ_SIZE(depth),
    72.                     &nvmeq->cq_dma_addr, GFP_KERNEL);
    73.     if (!nvmeq->cqes)
    74.         goto free_nvmeq;
    75.     memset((void *)nvmeq->cqes, 0, CQ_SIZE(depth));
    76.  
    77.     /* sq的dma区域,存放submission cmd的地方 */
    78.     nvmeq->sq_cmds = dma_alloc_coherent(dmadev, SQ_SIZE(depth),
    79.                     &nvmeq->sq_dma_addr, GFP_KERNEL);
    80.     if (!nvmeq->sq_cmds)
    81.         goto free_cqdma;
    82.  
    83.     if (qid && !zalloc_cpumask_var(&nvmeq->cpu_mask, GFP_KERNEL))
    84.         goto free_sqdma;
    85.  
    86.     nvmeq->q_dmadev = dmadev;
    87.     nvmeq->dev = dev;
    88.     snprintf(nvmeq->irqname, sizeof(nvmeq->irqname), "nvme%dq%d",
    89.             dev->instance, qid);
    90.     spin_lock_init(&nvmeq->q_lock);
    91.     nvmeq->cq_head = 0;
    92.     nvmeq->cq_phase = 1;
    93.     /* 当sq中的cmdinfo满时,会将进程加入到此waitqueue做等待 */
    94.     init_waitqueue_head(&nvmeq->sq_full);
    95.     /* sq_cong_wait是用于加入到sq_full,当sq_full唤醒sq_cong_wait时,实际上是唤醒了nvme_thread */
    96.     init_waitqueue_entry(&nvmeq->sq_cong_wait, nvme_thread);
    97.     bio_list_init(&nvmeq->sq_cong);
    98.     INIT_LIST_HEAD(&nvmeq->iod_bio);
    99.     /* 当前sq_tail位置，是nvme设备上的一个寄存器，存在于bar空间中 
    100.      * 发送命令流程: cmd放入sq_cmds,sq_head++,更新sq_head到此q_db,nvme设置会感知到,然后dma sq cmds,并处理sq cmd.
    101.      */
    102.     nvmeq->q_db = &dev->dbs[qid * 2 * dev->db_stride];
    103.     /* 1024或者nvme设备支持的最大值 */
    104.     nvmeq->q_depth = depth;
    105.     /* admin queue为0,io queue从0~io queue count */
    106.     nvmeq->cq_vector = vector;
    107.     /* queue id, admin queue为0, io queue为1~ io_queue_count+1 */
    108.     nvmeq->qid = qid;
    109.     nvmeq->q_suspended = 1;
    110.     /* nvme设备的queue_count++ */
    111.     dev->queue_count++;
    112.     rcu_assign_pointer(dev->queues[qid], nvmeq);
    113.  
    114.     return nvmeq;
    115.  
    116.  free_sqdma:
    117.     dma_free_coherent(dmadev, SQ_SIZE(depth), (void *)nvmeq->sq_cmds,
    118.                             nvmeq->sq_dma_addr);
    119.  free_cqdma:
    120.     dma_free_coherent(dmadev, CQ_SIZE(depth), (void *)nvmeq->cqes,
    121.                             nvmeq->cq_dma_addr);
    122.  free_nvmeq:
    123.     kfree(nvmeq);
    124.     return NULL;
    125. }
    126.  
    127.  
    128.  
    129. /* 初始化cq和sq */
    130. static void nvme_init_queue(struct nvme_queue *nvmeq, u16 qid)
    131. {
    132.     struct nvme_dev *dev = nvmeq->dev;
    133.     /* 大部分情况都是0 */
    134.     unsigned extra = nvme_queue_extra(nvmeq->q_depth);
    135.  
    136.     nvmeq->sq_tail = 0;
    137.     nvmeq->cq_head = 0;
    138.     nvmeq->cq_phase = 1;
    139.     nvmeq->q_db = &dev->dbs[qid * 2 * dev->db_stride];
    140.     memset(nvmeq->cmdid_data, 0, extra);
    141.     memset((void *)nvmeq->cqes, 0, CQ_SIZE(nvmeq->q_depth));
    142.     /* 告诉设备取消处理当前设备中的io请求 */
    143.     nvme_cancel_ios(nvmeq, false);
    144.     nvmeq->q_suspended = 0;
    145.     dev->online_queues++;
    146. }

    到这里admin queue已经初始化完成,可以通过对admin queue发送nvme控制命令来操作nvme设置.admin queue初始化完成后的结果如下:

    • qid为0就是admin queue,并且nvme_dev->queues[0]就是admin queue.
    • nvme_dev->entrys[0]是admin queue使用的.

    admin queue初始化完成后,创建nvme_thread,此内核线程不会在初始化流程中使用,暂时先不看,接下来就是初始化io queue了.

    初始化io queue是nvme_setup_io_queue函数

    1. /* 初始化nvme设备的所有io queue */
    2. static int nvme_setup_io_queues(struct nvme_dev *dev)
    3. {
    4.     struct nvme_queue *adminq = raw_nvmeq(dev, 0);
    5.     struct pci_dev *pdev = dev->pci_dev;
    6.     int result, i, vecs, nr_io_queues, size;
    7.  
    8.     /* 以CPU个数来分配io queue */
    9.     nr_io_queues = num_possible_cpus();
    10.     /* 此函数用于设置controller支持的io queue数量(通过发送NVME_FEAT_NUM_QUEUES命令)，nvme driver最优的结果是cpus个数个io queue
    11.      * 在服务器上nvme设备肯定不会支持那么多io queue，所以设置时controller最多只会设置自己支持的io queue，并返回自己支持的io queue个数
    12.      * 最后我们选择最小的那个数作为io queue个数，因为也有可能CPU很少，controller支持的io queue很多
    13.      */
    14.     result = set_queue_count(dev, nr_io_queues);
    15.     if (result < 0)
    16.         return result;
    17.     if (result < nr_io_queues)
    18.         nr_io_queues = result;
    19.  
    20.     /* 4096 + ((nr_io_queues + 1) * 8 * dev->db_stride) */
    21.     size = db_bar_size(dev, nr_io_queues);
    22.     /* size过大，重新映射bar空间 */
    23.     if (size > 8192) {
    24.         iounmap(dev->bar);
    25.         do {
    26.             dev->bar = ioremap(pci_resource_start(pdev, 0), size);
    27.             if (dev->bar)
    28.                 break;
    29.             if (!--nr_io_queues)
    30.                 return -ENOMEM;
    31.             size = db_bar_size(dev, nr_io_queues);
    32.         } while (1);
    33.         dev->dbs = ((void __iomem *)dev->bar) + 4096;
    34.         adminq->q_db = dev->dbs;
    35.     }
    36.  
    37.     /* Deregister the admin queue's interrupt */
    38.     /* 释放admin queue的irq */
    39.     free_irq(dev->entry[0].vector, adminq);
    41.     for (i = 0; i < nr_io_queues; i++)
    42.         dev->entry[i].entry = i;
    43.     /* 每个io queue申请一个msix，如果不支持msix，则用msi */
    44.     vecs = pci_enable_msix_range(pdev, dev->entry, 1, nr_io_queues);
    45.     if (vecs < 0) {
    46.         vecs = pci_enable_msi_range(pdev, 1, min(nr_io_queues, 32));
    47.         if (vecs < 0) {
    48.             vecs = 1;
    49.         } else {
    50.             for (i = 0; i < vecs; i++)
    51.                 dev->entry[i].vector = i + pdev->irq;
    52.         }
    53.     }
    55.     /*
    56.      * Should investigate if there's a performance win from allocating
    57.      * more queues than interrupt vectors; it might allow the submission
    58.      * path to scale better, even if the receive path is limited by the
    59.      * number of interrupts.
    60.      */
    61.     nr_io_queues = vecs;
    62.     dev->max_qid = nr_io_queues;
    63.  
    64.     /* 重新分配admin queue的irq */
    65.     result = queue_request_irq(dev, adminq, adminq->irqname);
    66.     if (result) {
    67.         adminq->q_suspended = 1;
    68.         goto free_queues;
    69.     }
    70.  
    71.     /* Free previously allocated queues that are no longer usable */
    72.     /* 释放多余的io queue */
    73.     nvme_free_queues(dev, nr_io_queues + 1);
    74.     /* 分配io queue需要的内存，并且分配对应的irq，最后设置CPU亲和性 */
    75.     nvme_assign_io_queues(dev);
    76.  
    77.     return 0;
    78.  
    79.  free_queues:
    80.     nvme_free_queues(dev, 1);
    81.     return result;
    82. }
    83.  
    84.  
    85.  
    86. /* 分配一个nvme queue，包括其需要的CQ和SQ空间和DMA地址 */
    87. /* 通过admin queue告知nvme设备创建cq和sq，并且分配对应的irq */
    88. static void nvme_create_io_queues(struct nvme_dev *dev)
    89. {
    90.     unsigned i, max;
    91.  
    92.     max = min(dev->max_qid, num_online_cpus());
    93.     for (i = dev->queue_count; i <= max; i++)
    94.         /* 分配一个nvme queue，包括其需要的CQ和SQ空间和DMA地址,注意这里第一个io queue使用的entry是0,也就是和admin queue共用 */
    95.         if (!nvme_alloc_queue(dev, i, dev->q_depth, i - 1))
    96.             break;
    97.  
    98.     max = min(dev->queue_count - 1, num_online_cpus());
    99.     for (i = dev->online_queues; i <= max; i++)
    100.         /* 通过admin queue告知nvme设备创建cq和sq，并且分配对应的irq */
    101.         if (nvme_create_queue(raw_nvmeq(dev, i), i))
    102.             break;
    103. }
    104.  
    105.  
    106. static int nvme_create_queue(struct nvme_queue *nvmeq, int qid)
    107. {
    108.     struct nvme_dev *dev = nvmeq->dev;
    109.     int result;
    110.  
    111.     /* 通过admin queue将nvme_admin_create_cq命令发送给nvme设备,主要将当前queue的cq_dma地址和qid传给nvme设备,这样就能将cq关联起来 */
    112.     result = adapter_alloc_cq(dev, qid, nvmeq);
    113.     if (result < 0)
    114.         return result;
    115.  
    116.     /* 通过admin queue将nvme_admin_create_sq命令发送给nvme设备,主要将当前queue的sq_dma地址和qid传给nvme设备,这样就能将sq关联起来 */
    117.     result = adapter_alloc_sq(dev, qid, nvmeq);
    118.     if (result < 0)
    119.         goto release_cq;
    120.  
    121.     /* 为此queue创建一个irq */
    122.     result = queue_request_irq(dev, nvmeq, nvmeq->irqname);
    123.     if (result < 0)
    124.         goto release_sq;
    125.  
    126.     spin_lock_irq(&nvmeq->q_lock);
    127.     nvme_init_queue(nvmeq, qid);
    128.     spin_unlock_irq(&nvmeq->q_lock);
    129.  
    130.     return result;
    131.  
    132.  release_sq:
    133.     adapter_delete_sq(dev, qid);
    134.  release_cq:
    135.     adapter_delete_cq(dev, qid);
    136.     return result;
    137. }
    138.  
    139.  
    140.  
    141. /* 分配io queue需要的内存，并且分配对应的irq，最后设置CPU亲和性 */
    142. static void nvme_assign_io_queues(struct nvme_dev *dev)
    143. {
    144.     unsigned cpu, cpus_per_queue, queues, remainder, i;
    145.     cpumask_var_t unassigned_cpus;
    146.  
    147.     /* 分配一个nvme queue，包括其需要的CQ和SQ空间和DMA地址 */
    148.     /* 告知nvme设备创建cq和sq，并且分配对应的irq */
    149.     nvme_create_io_queues(dev);
    150.  
    151.     /* 获取queue的数量,其至少<=CPUS */
    152.     queues = min(dev->online_queues - 1, num_online_cpus());
    153.     if (!queues)
    154.         return;
    155.  
    156.     /* 计算每个io queue的中断可以绑定到多少个CPU上,结果>=1 */
    157.     cpus_per_queue = num_online_cpus() / queues;
    158.     /* 剩余的CPU个数,因为queues <= cpus,当queues < cpus时,那么必然有一些queues绑定的cpus比其他的少一个,具体看下面的代码 */
    159.     remainder = queues - (num_online_cpus() - queues * cpus_per_queue);
    160.     if (!alloc_cpumask_var(&unassigned_cpus, GFP_KERNEL))
    161.         return;
    162.  
    163.     /* 将所有可用的CPU的mask复制到unassigned_cpus */
    164.     cpumask_copy(unassigned_cpus, cpu_online_mask);
    165.     /* 获取第一个可用的CPU */
    166.     cpu = cpumask_first(unassigned_cpus);
    167.     /* 遍历所有的io queue,从1开始是因为0是admin queue */
    168.     for (i = 1; i <= queues; i++) {
    169.         /* 根据获取对应的io queue */
    170.         struct nvme_queue *nvmeq = lock_nvmeq(dev, i);
    171.         cpumask_t mask;
    172.  
    173.         /* 清除此io queue的cpumask */
    174.         cpumask_clear(nvmeq->cpu_mask);
    175.         /* 如果unassigned_cpus为0,表示没有CPU可以使用,则退出,之后会初始化nvme dev失败 */
    176.         if (!cpumask_weight(unassigned_cpus)) {
    177.             unlock_nvmeq(nvmeq);
    178.             break;
    179.         }
    180.  
    181.         /* 根据CPU ID.获取此CPU的cpumask */
    182.         mask = *get_cpu_mask(cpu);
    183.         /* 设置此io queue使用此CPU */
    184.         nvme_set_queue_cpus(&mask, nvmeq, cpus_per_queue);
    185.         /* 如果绑定的CPU个数少于cpus_per_queue,那么先绑定此CPU对应的超线程的其他CPU */
    186.         if (cpus_weight(mask) < cpus_per_queue)
    187.             nvme_add_cpus(&mask, unassigned_cpus,
    188.                 topology_thread_cpumask(cpu),
    189.                 nvmeq, cpus_per_queue);
    190.  
    191.         /* 如果绑定的CPU个数还少于cpus_per_queue,那么绑定此CPU对应的同一个socket上其他CPU */
    192.         if (cpus_weight(mask) < cpus_per_queue)
    193.             nvme_add_cpus(&mask, unassigned_cpus,
    194.                 topology_core_cpumask(cpu),
    195.                 nvmeq, cpus_per_queue);
    196.  
    197.         /* 如果绑定的CPU个数还少于cpus_per_queue,那么绑定此CPU对应的node上的所有CPU */
    198.         if (cpus_weight(mask) < cpus_per_queue)
    199.             nvme_add_cpus(&mask, unassigned_cpus,
    200.                 cpumask_of_node(cpu_to_node(cpu)),
    201.                 nvmeq, cpus_per_queue);
    202.  
    203.         /* 如果绑定的CPU个数还少于cpus_per_queue,那么绑定此CPU对应的node最近的node上的所有CPU */
    204.         if (cpus_weight(mask) < cpus_per_queue)
    205.             nvme_add_cpus(&mask, unassigned_cpus,
    206.                 cpumask_of_node(
    207.                     nvme_find_closest_node(
    208.                         cpu_to_node(cpu))),
    209.                 nvmeq, cpus_per_queue);
    210.  
    211.         /* 如果绑定的CPU个数还少于cpus_per_queue,那么绑定所有可用的CPU */
    212.         if (cpus_weight(mask) < cpus_per_queue)
    213.             nvme_add_cpus(&mask, unassigned_cpus,
    214.                 unassigned_cpus,
    215.                 nvmeq, cpus_per_queue);
    216.  
    217.         WARN(cpumask_weight(nvmeq->cpu_mask) != cpus_per_queue,
    218.             "nvme%d qid:%d mis-matched queue-to-cpu assignment\n",
    219.             dev->instance, i);
    220.  
    221.         /* 到这里,已经获取到了此queue对应绑定的CPU的cpumask,并且哪个CPU绑定哪个queue,已经写到nvme_dev->io_queue */
    222.         
    223.         /* 根据cpumask,设置中断的亲和性 */
    224.         irq_set_affinity_hint(dev->entry[nvmeq->cq_vector].vector,
    225.                             nvmeq->cpu_mask);
    226.         /* 将这些绑定的CPU从unassigned_cpus中删除 */
    227.         cpumask_andnot(unassigned_cpus, unassigned_cpus,
    228.                         nvmeq->cpu_mask);
    229.         /* cpu += 1 */
    230.         cpu = cpumask_next(cpu, unassigned_cpus);
    231.         /* 如果此时remainder为0了,那么从下一个queue开始,它绑定的cpus+1,也就是下一个及其之后的queue,绑定的CPUS都比之前的多1 */
    232.         if (remainder && !--remainder)
    233.             cpus_per_queue++;
    234.         unlock_nvmeq(nvmeq);
    235.     }
    236.     WARN(cpumask_weight(unassigned_cpus), "nvme%d unassigned online cpus\n",
    237.                                 dev->instance);
    238.     i = 0;
    239.     cpumask_andnot(unassigned_cpus, cpu_possible_mask, cpu_online_mask);
    240.     /* 如果还有剩余的可用CPU的情况,那么就从queue1开始依次绑到剩余这些CPU上 */
    241.     for_each_cpu(cpu, unassigned_cpus)
    242.         *per_cpu_ptr(dev->io_queue, cpu) = (i++ % queues) + 1;
    243.     free_cpumask_var(unassigned_cpus);
    244. }

    一个nvme设备会有多个io queue,每个io queue会有自己的中断,并且nvme设备会将每个io queue的中断绑定到不同的CPU上(实际上并不是真正的做了绑定,注意irq_set_affinity_hint这个函数,它实际上是告知使用者,这个irq更适合在哪些CPU上做处理,但是kernel还是有可能将这个IRQ放到不属于这些CPU中的CPU去处理,不过如果在用户层使用了irqbalance命令,那么irqbalance会将这个IRQ放到这个函数设置的CPU上去处理.具体可以看/proc/irq中的值就能明白了,它改变的是smp_affinity_hint值,而非smp_affinity),就有了上面的代码.一般情况应该是一个io queue绑定到多个CPU上,比如CPU有16个,io queue有8个,那么io queue[0]绑定到cpu0,1上,io queue[1]绑定到cpu2,3上,依次类推.当io queue初始化完成后,一些需要注意的细节如下:

    • io queue使用的entry是从0开始的,也就是io queue0会与admin queue共用一个entry.
    • nvme_dev->queues是从1开始保存io queue.
    • queue的sq_dma,cq_dma和qid通过admin queue发送给nvme设备,nvme设备会将其做绑定.并且注意,在nvme_alloc_queue时,queue->q_db指向的位置是通过qid计算的,所以实际上,sq_dma,cq_dma,qid和q_db都能过联系起来了.

    到这里,admin queue和io queue都初始化完成了,之后就是在块层注册设备的操作.

    nvme_add_dev

    1. static int nvme_dev_add(struct nvme_dev *dev)
    2. {
    3.     struct pci_dev *pdev = dev->pci_dev;
    4.     int res;
    5.     unsigned nn, i;
    6.     struct nvme_ns *ns;
    7.     struct nvme_id_ctrl *ctrl;
    8.     struct nvme_id_ns *id_ns;
    9.     void *mem;
    10.     dma_addr_t dma_addr;
    11.     int shift = NVME_CAP_MPSMIN(readq(&dev->bar->cap)) + 12;
    12.  
    13.     /* 分配一个一致性dma区域,注意大小是8192B,前4096B放盘的信息,后面4096B空闲,之后会使用 */
    14.     mem = dma_alloc_coherent(&pdev->dev, 8192, &dma_addr, GFP_KERNEL);
    15.     if (!mem)
    16.         return -ENOMEM;
    17.  
    18.     /* 向controller发送一个identify命令,此命令会让controller将nvme卡的信息保存到mem这块一致性dma区域中 */
    19.     res = nvme_identify(dev, 0, 1, dma_addr);
    20.     if (res) {
    21.         dev_err(&pdev->dev, "Identify Controller failed (%d)\n", res);
    22.         res = -EIO;
    23.         goto out;
    24.     }
    25.  
    26.     /* 已经获取到信息,包括sn号,model,fw版本,用户可用容量等信息,注意,nn是表示此nvme物理盘生成多少个块设备 */
    27.     ctrl = mem;
    28.     /* 决定了生成多少个块设备 */
    29.     nn = le32_to_cpup(&ctrl->nn);
    30.     dev->oncs = le16_to_cpup(&ctrl->oncs);
    31.     dev->abort_limit = ctrl->acl + 1;
    32.     dev->vwc = ctrl->vwc;
    33.     memcpy(dev->serial, ctrl->sn, sizeof(ctrl->sn));
    34.     memcpy(dev->model, ctrl->mn, sizeof(ctrl->mn));
    35.     memcpy(dev->firmware_rev, ctrl->fr, sizeof(ctrl->fr));
    36.     if (ctrl->mdts)
    37.         dev->max_hw_sectors = 1 << (ctrl->mdts + shift - 9);
    38.     if ((pdev->vendor == PCI_VENDOR_ID_INTEL) &&
    39.             (pdev->device == 0x0953) && ctrl->vs[3])
    40.         dev->stripe_size = 1 << (ctrl->vs[3] + shift);
    41.  
    42.     id_ns = mem;
    43.     for (i = 1; i <= nn; i++) {
    44.         res = nvme_identify(dev, i, 0, dma_addr);
    45.         if (res)
    46.             continue;
    47.  
    48.         if (id_ns->ncap == 0)
    49.             continue;
    50.  
    51.         /* 通过admin queue获取设备盘容量,lba大小等信息,存放到mem的后4096B中 */
    52.         res = nvme_get_features(dev, NVME_FEAT_LBA_RANGE, i,
    53.                             dma_addr + 4096, NULL);
    54.         if (res)
    55.             memset(mem + 4096, 0, 4096);
    56.  
    57.         /* 分配disk和request queue,一个块设备就是一个namespace */
    58.         ns = nvme_alloc_ns(dev, i, mem, mem + 4096);
    59.         /* 加入到nvme_dev->namespace链表中 */
    60.         if (ns)
    61.             list_add_tail(&ns->list, &dev->namespaces);
    62.     }
    63.     /* 将disk添加到系统中,这样用户就能在/dev/下面看到了 */
    64.     list_for_each_entry(ns, &dev->namespaces, list)
    65.         add_disk(ns->disk);
    66.     res = 0;
    67.  
    68.  out:
    69.     dma_free_coherent(&dev->pci_dev->dev, 8192, mem, dma_addr);
    70.     return res;
    71. }

    此函数主要做几件事情:

    1. 获取nvme设备的信息.
    2. 根据nvme设备的信息,创建对应的namespace,一个namespace实际就是一个块设备
    3. 将创建的namespace加入到系统中的块设备中.

    主要是通过nvme_alloc_ns函数来初始化一个namespace,一个namespace是一个块设备,一个块设备主要初始化两个结构,一个是gendisk,一个是request queue,当两个结构都初始化好后,调用add_disk()函数,这个块设备就会正式加入到系统中的块设备中.

    1. static struct nvme_ns *nvme_alloc_ns(struct nvme_dev *dev, unsigned nsid,
    2.             struct nvme_id_ns *id, struct nvme_lba_range_type *rt)
    3. {
    4.     struct nvme_ns *ns;
    5.     struct gendisk *disk;
    6.     int lbaf;
    7.  
    8.     if (rt->attributes & NVME_LBART_ATTRIB_HIDE)
    9.         return NULL;
    10.  
    11.     ns = kzalloc(sizeof(*ns), GFP_KERNEL);
    12.     if (!ns)
    13.         return NULL;
    14.     /* 分配一个request queue */
    15.     ns->queue = blk_alloc_queue(GFP_KERNEL);
    16.     if (!ns->queue)
    17.         goto out_free_ns;
    18.     ns->queue->queue_flags = QUEUE_FLAG_DEFAULT;
    19.     /* 禁止合并操作，包括bio合并到request操作，两个request合并操作 */
    20.     queue_flag_set_unlocked(QUEUE_FLAG_NOMERGES, ns->queue);
    21.     /* 表示是一个ssd设备 */
    22.     queue_flag_set_unlocked(QUEUE_FLAG_NONROT, ns->queue);
    23.     queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, ns->queue);
    24.     /* 绑定request queue的make_request_fn函数到nvme_make_request */
    25.     blk_queue_make_request(ns->queue, nvme_make_request);
    26.     ns->dev = dev;
    27.     ns->queue->queuedata = ns;
    28.  
    29.     /* 分配一个gendisk结构,gendisk用于描述一个块设备 */
    30.     disk = alloc_disk(0);
    31.     if (!disk)
    32.         goto out_free_queue;
    33.     ns->ns_id = nsid;
    34.     ns->disk = disk;
    35.     lbaf = id->flbas & 0xf;
    36.     ns->lba_shift = id->lbaf[lbaf].ds;
    37.     ns->ms = le16_to_cpu(id->lbaf[lbaf].ms);
    38.     /* 物理sector的大小,用户看到的逻辑sector大小一般是512B,而物理sector大小不同厂商不同定义,可能跟一个nand flash page一样,也可能小于一个nand flash page */
    39.     blk_queue_logical_block_size(ns->queue, 1 << ns->lba_shift);
    40.     /* 设备允许的一次request支持最大sector数量,request中的sector数量不能超过此值 */
    41.     if (dev->max_hw_sectors)
    42.         blk_queue_max_hw_sectors(ns->queue, dev->max_hw_sectors);
    43.     if (dev->vwc & NVME_CTRL_VWC_PRESENT)
    44.         blk_queue_flush(ns->queue, REQ_FLUSH | REQ_FUA);
    45.  
    46.     disk->major = nvme_major;
    47.     disk->first_minor = 0;
    48.     /* 此块设备的操作函数 */
    49.     disk->fops = &nvme_fops;
    50.     disk->private_data = ns;
    51.     /* 将上面初始化好的request queue与gendisk联系一起 */
    52.     disk->queue = ns->queue;
    53.     disk->driverfs_dev = &dev->pci_dev->dev;
    54.     /* 标记为允许扩展的设备,暂时不清楚什么意思 */
    55.     disk->flags = GENHD_FL_EXT_DEVT;
    56.     /* 在/dev/下显示的名字 */
    57.     sprintf(disk->disk_name, "nvme%dn%d", dev->instance, nsid);
    58.     /* 设置用户可用容量 */
    59.     set_capacity(disk, le64_to_cpup(&id->nsze) << (ns->lba_shift - 9));
    60.  
    61.     /* 如果此nvme盘支持discard操作,则设置discard的一些初始参数,如discard必须以物理sector大小对齐 */
    62.     if (dev->oncs & NVME_CTRL_ONCS_DSM)
    63.         nvme_config_discard(ns);
    64.  
    65.     return ns;
    66.  
    67.  out_free_queue:
    68.     blk_cleanup_queue(ns->queue);
    69.  out_free_ns:
    70.     kfree(ns);
    71.     return NULL;
    72. }

    这里主要初始化gendisk和request queue,gendisk用于描述一个块设备,也就是当gendisk初始化好后,并调用add_disk(),就会在/dev/下出现一个此gendisk->name的块设备.而request_queue有什么用呢,注意看gendisk初始化时,会将gendisk->queue设置为一个初始化好的request_queue.对于request_queue,最重要的是初始化一个make_request_fn的函数指针,当有进程对此gendisk对应的块设备进行读写时,最终都会调用到gendisk的request_queue的make_request_fn所指的函数.在nvme驱动中,主要将request_queue的make_request_fn初始化为了nvme_make_request()函数,未来在说nvme设备的读写流程时,会详细说明此函数.

  • 相关阅读:
    华为静态路由配置实验（超详细讲解+详细命令行）
    java 获取格林威治时间（GMT） 时区 0时区 东八区【全网最详细】
    FPS游戏漫谈优化包体传输
    Linux xargs命令
    solidity函数重载以及调用
    3交换机的配置与使用
    GRDB和FMDB学习篇（各处摘抄）
    从0基础到车载测试工程师，薪资11K，肯拼搏的人，总会有所收获
    【TiDB】一些很有意思的sql调优案例分享
    8.09 Day38---Java基础面试题
  • 原文地址：https://blog.csdn.net/m0_74282605/article/details/128132816