scsi总线驱动的初始化

1.6.1 scsi总线驱动的初始化

块设备底层驱动的核心是scsi总线层驱动，在总线层驱动之上为各种不同的scsi设备驱动，在总线层驱动之下为scsi host驱动。其在内核中的位置如下图所示：

 

前面我们已经知道了上三层的工作，接下来大部分知识来自底下三层。

 

在Linux中scsi驱动基本分为三大层：top level，middle level以及lower level。top level为具体的scsi设备驱动，例如我们常用的磁盘设备驱动就在该层（Linux中的实现为sd.c），scsi disk的驱动向上表现为块设备，因此，具有块设备的接口及一切属性，向下表现scsi设备，因为scsi disk基于scsi总线进行数据通信。top level驱动与具体的scsi设备相关，所以该类驱动往往由设备开发者提供，但是如果scsi设备为标准类设备，那么驱动可以通用。

 

middle level实际上就是scsi总线层驱动，按照scsi协议进行设备枚举、数据传输、出错处理。middle level层的驱动与scsi specification相关，在一类操作系统平台上只需实现一次，所以该类驱动往往由操作系统开发者提供。

 

lower level为scsi控制器的驱动，该驱动与具体的硬件适配器相关，其需要与scsi middle level层进行接口，所以往往由提供适配器的硬件厂商完成驱动开发，只有硬件厂商才对自己定义的register file（寄存器堆）最清楚。当然，在lower level层可以做虚拟的scsi host，所以该层的驱动也不一定对硬件进行操作。

 

Linux中，scsi三层驱动模型如下图所示：

 

 

而前面提到的scsi device的数据结构就是在scsi middle level定义的，用于描述一个scsi的具体功能单元，其在scsi host中通过channel、id、lun进行寻址。

 

首先，什么是channel、id和lun。通常SCSI总线适配器作为PCI设备的形式存在，其在计算机体系结构中的位置如下图所示：

 

 

在系统初始化时会扫描系统PCI总线，由于scsi端口适配器挂接在pci总线上，因此会被pci扫描软件扫描得到，并且生成一个pci device(PDO)。然后扫描软件需要为该pci device加载相应的驱动程序。

 

在linux系统中，系统初始化时会遍历pci bus上存在的所有驱动程序，检查是否有符合要求的驱动程序存在，这里假设scsi host是USB或marwell中的设备，那么，如果存在USB或marwell提供的scsi端口驱动，就会被成功调用。加载scsi端口驱动时，pci扫描程序会调用对应scsi端口驱动提供的probe函数，该probe函数是scsi端口驱动程序在初始化驱动时注册到pci-driver上的(Linux的总线驱动都是采用的这种思路)。

 

在scsi host具体的probe函数中会初始化scsi host，注册中断处理函数，并且调用scsi_host_alloc函数生成一个scsi host，然后添加到scsi middle level，最后调用scsi_scan_host函数扫描scsi端口适配器所管理的所有scsi总线。

 

一个scsi端口适配器可能拥有多个channel，每个channel拥有一条scsi总线。传统scsi总线是并行共享总线，现有的SATA、SAS等P2P接口在逻辑上可以理解成总线的一种特例，所以scsi middle level驱动程序是通用的。由于一个scsi host可能存在多个channel，因此依次扫描每个channel。按照spec，传统scsi bus上最多可以连接16个scsi target，因此，scsi扫描程序会依次探测target。一个scsi target可以存在多种功能，每种功能称之为LUN，对于单功能设备(例如磁盘)，其LUN通常为0。

 

Scsi host的扫描过程在系统初始化中进行，详细的代码我们就不去分析了，这里从网上摘录了一段伪代码对其进行简单地描述：

 

For (channel = 0; channel

　　/* 对一个适配器的每个通道中的设备进行识别 */

　　…

　　For (id=0; id

　　/* 对一个通道中的每个ID对应设备进行识别 */

　　…

　　　　For (lun=1; lun

　　　　/* 对一个ID对应设备的每个LUN进行识别 */

　　　　…

　　　　}

　　}

}

          

在计算机系统启动过程中，操作系统会扫描默认的PCI根节点，从而触发了PCI设备扫描的过程，开始构建PCI设备树。

 

首先scsi host作为PCI设备会被PCI总线驱动层扫描到（PCI设备的扫描采用配置信息读取的方式），扫描到scsi host之后，操作系统开始加载scsi host的驱动，scsi host driver就是上面说所的low level driver。scsi host driver初始化scsi控制器，通过PCI配置空间的信息分配硬件资源，注册中断服务。最后开始扫描通过scsi控制器扩展出来的下一级总线—— scsi bus。

 

scsi bus的扫描通过scsi middle level提供的服务完成。scsi host driver可以调用scsi middle level提供的扫描算法完成scsi总线设备的扫描，扫描过程可以描述如下：

a.   采用scsi_add_host()函数为扫描出来的scsi host添加一个对象，注册到scsi middle level。

b.  通过__scsi_add_device()函数循环扫描scsi host，扫描过程采用了scsi middle level的服务scsi_probe_and_add_lun()。

c.   通过向scsi device发送INQUIRY命令获取scsi设备信息，得知scsi设备的vendor id、product id以及设备类型等关键信息。至此，操作系统得知了scsi设备所具备的各种能力，并且向scsi middle level注册了scsi设备对象——scsi device。

d.  根据scsi设备的信息初始化scsi device对象，并且通知内核去加载该设备的驱动程序。如果被枚举的设备为scsi disk，那么scsi磁盘的驱动程序将被加载，至此，一个scsi设备被枚举成功。

e.   循环（b）（c）（d）将scsi总线扫描完毕。结束scsi host的扫描工作。

 

通过上述扫描过程可以知道，在系统中可以采用如下方法对一个scsi device进行描述：host_id : channel_id : target_id : lun_id

 

其中，host_id是系统动态分配的，这与PCI总线的扫描顺序相关，对于固定硬件的系统host_id扫描得到的结果不会改变，但是，如果动态添加一个scsi host(PCI device)，系统的host_id可能会发生变化，这一点需要注意。

 

最终，上述过程结束之后，scsi的硬件逻辑可以采用如下的总线拓扑结构进行描述：

 

 

scsi_device就是对lun的抽象。下面对scsi_device中的重要域进行说明：

那么，什么又是Scsi_Host呢？在scsi middle level定义了scsi设备的数据结构，用于描述一个scsi的具体功能单元，其在scsi host中通过channel、id、lun进行寻址。

 

通过上述描述可以知道scsi_device是对lun的抽象。下面对scsi_device中的重要域进行说明：

 

struct scsi_device {

       struct Scsi_Host *host;                     /* 与scsi device相关的scsi host */

       struct request_queue *request_queue;         /* 块设备接口的请求队列 */

 

       unsigned int device_busy;                    /* 命令执行标记 */

      

       struct list_head cmd_list;                     /* scsi_cmnd队列 */

      

       struct scsi_cmnd *current_cmnd;        /* 当前执行的命令 */

 

       unsigned int id, lun, channel;              /* SCSI设备的标识 */

 

       void *hostdata;               /* 通常指向low-level driver定义的scsi device */

       …

} __attribute__((aligned(sizeof(unsigned long))));

 

在scsi总线对一个ID对应设备的每个LUN进行识别的过程中，scsi middle level会为每个lun生成一个scsi_device结构，实现的核心函数为scsi_probe_and_add_lun()，来自drivers/scsi/scsi_scan.c：

 

static int scsi_probe_and_add_lun(struct scsi_target *starget,

                              uint lun, int *bflagsp,

                              struct scsi_device **sdevp, int rescan,

                              void *hostdata)

{

       struct scsi_device *sdev;

       unsigned char *result;

       int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;

       struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

 

       /*

        * The rescan flag is used as an optimization, the first scan of a

        * host adapter calls into here with rescan == 0.

        */

       sdev = scsi_device_lookup_by_target(starget, lun);

       if (sdev) {

              if (rescan || sdev->sdev_state != SDEV_CREATED) {

                     SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO

                            "scsi scan: device exists on %s/n",

                            sdev->sdev_gendev.bus_id));

                     if (sdevp)

                            *sdevp = sdev;

                     else

                            scsi_device_put(sdev);

 

                     if (bflagsp)

                            *bflagsp = scsi_get_device_flags(sdev,

                                                         sdev->vendor,

                                                         sdev->model);

                     return SCSI_SCAN_LUN_PRESENT;

              }

              scsi_device_put(sdev);

       } else

              sdev = scsi_alloc_sdev(starget, lun, hostdata);

       if (!sdev)

              goto out;

 

       result = kmalloc(result_len, GFP_ATOMIC |

                     ((shost->unchecked_isa_dma) ? __GFP_DMA : 0));

       if (!result)

              goto out_free_sdev;

 

       if (scsi_probe_lun(sdev, result, result_len, &bflags))

              goto out_free_result;

 

       if (bflagsp)

              *bflagsp = bflags;

       /*

        * result contains valid SCSI INQUIRY data.

        */

       if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {

              /*

               * For a Peripheral qualifier 3 (011b), the SCSI

               * spec says: The device server is not capable of

               * supporting a physical device on this logical

               * unit.

               *

               * For disks, this implies that there is no

               * logical disk configured at sdev->lun, but there

               * is a target id responding.

               */

              SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"

                               " peripheral qualifier of 3, device not"

                               " added/n"))

              if (lun == 0) {

                     SCSI_LOG_SCAN_BUS(1, {

                            unsigned char vend[9];

                            unsigned char mod[17];

 

                            sdev_printk(KERN_INFO, sdev,

                                   "scsi scan: consider passing scsi_mod."

                                   "dev_flags=%s:%s:0x240 or 0x800240/n",

                                   scsi_inq_str(vend, result, 8, 16),

                                   scsi_inq_str(mod, result, 16, 32));

                     });

              }

             

              res = SCSI_SCAN_TARGET_PRESENT;

              goto out_free_result;

       }

 

       /*

        * Non-standard SCSI targets may set the PDT to 0x1f (unknown or

        * no device type) instead of using the Peripheral Qualifier to

        * indicate that no LUN is present.  For example, USB UFI does this.

        */

       if (starget->pdt_1f_for_no_lun && (result[0] & 0x1f) == 0x1f) {

              SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO

                                   "scsi scan: peripheral device type"

                                   " of 31, no device added/n"));

              res = SCSI_SCAN_TARGET_PRESENT;

              goto out_free_result;

       }

 

       res = scsi_add_lun(sdev, result, &bflags);

       if (res == SCSI_SCAN_LUN_PRESENT) {

              if (bflags & BLIST_KEY) {

                     sdev->lockable = 0;

                     scsi_unlock_floptical(sdev, result);

              }

       }

 

 out_free_result:

       kfree(result);

 out_free_sdev:

       if (res == SCSI_SCAN_LUN_PRESENT) {

              if (sdevp) {

                     if (scsi_device_get(sdev) == 0) {

                            *sdevp = sdev;

                     } else {

                            __scsi_remove_device(sdev);

                            res = SCSI_SCAN_NO_RESPONSE;

                     }

              }

       } else

              scsi_destroy_sdev(sdev);

 out:

       return res;

}

 

传给该函数的参数是scsi_target类型，表示scsi总线上的一个scsi node。注意结合前面那个图观察，每个scsi target可能拥有多个lun，即多个scsi devie，而这个。scsi target数据结构中的重要域定义如下：

 

struct scsi_target {

       struct scsi_device   *starget_sdev_user;              /* 当前活动的scsi device */

       struct list_head       siblings;

       struct list_head       devices;                        /* scsi device链表 */

       struct device          dev;

       unsigned int           reap_ref;

       unsigned int           channel;                      /* 当前channel号 */

       unsigned int           id;                           /* scsi target的ID号 */

       …

} __attribute__((aligned(sizeof(unsigned long))));

 

而scsi_probe_and_add_lun函数就是在对一个ID对应设备的LUN进行识别的过程中向这个Scsi节点增加这个lun。函数内部还有一个Scsi_Host类型的内部变量shost，表示对一个scsi适配器（很多地方又称为scsi总线控制器）。

 

在很多实际的系统中，scsi host为一块基于PCI总线的HBA或者为一个SCSI控制器芯片。每个scsi host可以存在多个channel，一个channel实际扩展了一条SCSI总线。每个channel可以连接多个scsi节点，具体连接的数量与scsi总线带载能力有关。scsi host的重要域描述如下：

 

struct Scsi_Host {

       struct list_head       __devices;                    /* scsi device链表 */

       struct list_head       __targets;

      

       struct scsi_host_template *hostt;                /* scsi host操作接口方法 */

       struct scsi_transport_template *transportt;        /* scsi host transport方法 */

       unsigned int host_busy;                       /* scsi host忙标记 */

       unsigned int host_failed;                      /* commands that failed. */

       unsigned int max_id;                         /* 最大的scsi node数量 */

       unsigned int max_lun;                        /* 最大的lun数量 */

       unsigned int max_channel;                     /* 最大的channel数量 */

       unsigned char max_cmd_len;                   /* scsi命令的长度 */

       int this_id;                                  /* scsi host在总线的id */

       int can_queue;                    /* scsi cmd是否可以queue在host标记 */

       short cmd_per_lun;                /* 每个lun可以queue多少scsi cmd */

       short unsigned int sg_tablesize;       /* scatter-gather table大小 */

       short unsigned int max_sectors;

       ……

};

 

这里有一个重点字段，是scsi_host_template ，翻译成SCSI总线端口样板，表示scsi host操作接口方法：

 

struct scsi_host_template {

/* scsi middle level层驱动通过该函数将scsi command提交给low level层驱动，并且告 诉low level驱动完成scsi命令之后需要调用done（）函数 */

       int (* queuecommand)(struct scsi_cmnd *,

                          void (*done)(struct scsi_cmnd *));   

……

       /* scsi host出错处理函数 */

       int (* eh_abort_handler)(struct scsi_cmnd *);

       int (* eh_device_reset_handler)(struct scsi_cmnd *);

       int (* eh_bus_reset_handler)(struct scsi_cmnd *);

       int (* eh_host_reset_handler)(struct scsi_cmnd *);

 

       /* 更改scsi设备的队列深度 */

       int (* change_queue_depth)(struct scsi_device *, int);

 

       int can_queue;                      /* scsi host队列深度 */

       int this_id;                           /* scsi host的ID号 */

       unsigned short sg_tablesize;   /* scatter-gather table的容量 */

       short cmd_per_lun;                     /* 每个lun能够queue的命令数 */

 

       unsigned emulated:1;             /* 虚拟scsi host flag */

};

 

比如，USB的scsi_host_template方法就定义如下：

 

struct scsi_host_template usb_stor_host_template = {

       /* basic userland interface stuff */

       .name =                        "usb-storage",

       .proc_name =                "usb-storage",

       .proc_info =                 proc_info,

       .info =                         host_info,

 

       /* command interface -- queued only */

       .queuecommand =                queuecommand,

 

       /* error and abort handlers */

       .eh_abort_handler =              command_abort,

       .eh_device_reset_handler =    device_reset,

       .eh_bus_reset_handler =        bus_reset,

 

       /* queue commands only, only one command per LUN */

       .can_queue =                1,

       .cmd_per_lun =                    1,

 

       /* unknown initiator id */

       .this_id =               -1,

 

       .slave_alloc =                slave_alloc,

       .slave_configure =         slave_configure,

 

       /* lots of sg segments can be handled */

       .sg_tablesize =                     SG_ALL,

 

       /* limit the total size of a transfer to 120 KB */

       .max_sectors =                  240,

 

       /* merge commands... this seems to help performance, but

        * periodically someone should test to see which setting is more

        * optimal.

        */

       .use_clustering =           1,

 

       /* emulated HBA */

       .emulated =                  1,

 

       /* we do our own delay after a device or bus reset */

       .skip_settle_delay =              1,

 

       /* sysfs device attributes */

       .sdev_attrs =                 sysfs_device_attr_list,

 

       /* module management */

       .module =                     THIS_MODULE

};

 

整个块设备驱动层的工作，其实就是一个东西：封装一个scsi_cmnd结构。在完成scsi_cmnd的封装后，SCSI 中间层通过调用scsi_host_template结构中定义的queuecommand函数将 SCSI 命令提交给 SCSI 底层驱动部分。

 

queuecommand函数，是一个 SCSI 命令队列处理函数，在 SCSI 底层驱动中，定义了queuecommand函数的具体实现。因此，SCSI 中间层，调用queuecommand函数实际上就是调用了底层驱动定义的queuecommand函数的处理实体，将 SCSI 命令提交给了各个厂家定义的 SCSI 底层驱动进行处理。这个过程和通用块设备层调用 SCSI 中间层的处理函数进行块请求处理的机制很相似，这也体现了 LINUX 内核代码具有很好的扩展性。

 

底层驱动接受到请求后，就要开始处理 SCSI 命令了，这一层和硬件关系紧密，所以这块代码一般都是由各个厂家自己实现。基本流程可概括为：从底层驱动维护的队列中，取出一个 SCSI 命令，封装成厂家自定义的请求格式，然后采用 DMA或者其他方式，将请求提交给 SCSI TARGET 端，由 SCSI TARGET 端对请求处理，并返回执行结果给 SCSI 底层驱动层。