块设备底层驱动的核心是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 底层驱动层。
