SCSI驱动与 UFS 驱动交互概况

SCSI子系统概况

SCSI（Small Computer System Interface）子系统是 Linux 中的一个模块化框架，用于提供与存储设备的通用接口。通过 SCSI 子系统，可以支持不同类型的存储协议（如 UFS、SATA、SAS），使操作系统能够通过相同的命令集与这些设备交互。

驱动的分工

UFS 驱动：负责与 UFS 主控直接交互，包括初始化、配置和电源管理。UFS 驱动会解析设备树（DTS）中的信息，启动并配置硬件，使其进入工作状态。
SCSI 子系统：提供一个上层的抽象层，将对存储设备的访问抽象为标准 SCSI 命令（如读、写、格式化）。应用程序和文件系统通过 SCSI 子系统向存储设备发出 I/O 请求，而 SCSI 子系统负责将请求传递给对应的驱动。

初始化阶段

UFS 驱动注册到SCSI系统

UFS驱动会等待调用，调用的话他就是接收或者发送通用SCSI 的命令，处理这些操作就需要一个主机，所以首先scsi_host_alloc 会分配一个主机适配器scsi host。代码在**/** drivers / scsi / hosts.c
scsi_add_host 注册主机适配器，使得SCSI 子系统得知有一个新的 SCSI 主机适配器（即 UFS 设备）已经上线并准备接受命令。

设备扫描和初始化

代码在drivers / scsi / scsi_scan.c
一旦确认设备在线，SCSI 子系统会为每个检测到的 UFS 存储设备分配一个 struct scsi_device 结构体。这一结构体包含设备的基本信息和状态，使系统可以通过这个结构体与 UFS 设备进行读写操作。
发现到 UFS 设备后，SCSI 子系统会为其分配 SCSI 设备结构（struct scsi_device），并准备好用于与操作系统和文件系统交互，抽象成操作系统或文件系统能够交互的设备。

C 复制代码

void scsi_scan_host(struct Scsi_Host *shost)
{
        struct async_scan_data *data;

        if (strncmp(scsi_scan_type, "none", 4) == 0 ||
            strncmp(scsi_scan_type, "manual", 6) == 0)
                return;
        if (scsi_autopm_get_host(shost) < 0)
                return;

        data = scsi_prep_async_scan(shost);
        if (!data) {
                do_scsi_scan_host(shost);
                scsi_autopm_put_host(shost);
                return;
        }

        /* register with the async subsystem so wait_for_device_probe()
         * will flush this work
         */
        async_schedule(do_scan_async, data);

        /* scsi_autopm_put_host(shost) is called in scsi_finish_async_scan() */
}
EXPORT_SYMBOL(scsi_scan_host);

文件IO的处理流程

系统发起读写请求时，SCSI子系统和UFS 驱动协同合作，将请求传递到UFS 设备。

请求创建：系统通过读写命令的系统调用来调用虚拟文件系统 ，虚拟文件进一步调用具体的文件系统例如F2FS , F2FS的读写操作进一步传达到SCSI 子系统 ，SCSI最终调用 UFS子系统，所以请求在SCSI这块生成SCSI命令描述块。
请求处理：SCSI 子系统封装命令描述块为SCSI命令，并调用ufshcd_queuecommand函数

C 复制代码

static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
{
    // 获取 UFS 主控（Host Bus Adapter, HBA）的私有数据
    struct ufs_hba *hba = shost_priv(host);
    // 从 SCSI 命令提取请求的 tag，用于定位 UFS 请求块（LUN/队列标识）
    int tag = scsi_cmd_to_rq(cmd)->tag;
    struct ufshcd_lrb *lrbp;
    int err = 0;
    struct ufs_hw_queue *hwq = NULL;

    // 检查 UFS 主控当前的状态
    switch (hba->ufshcd_state) {
        case UFSHCD_STATE_OPERATIONAL:
            // 如果 UFS 处于正常操作状态，则继续处理命令
            break;

        case UFSHCD_STATE_EH_SCHEDULED_NON_FATAL:
            /*
             * SCSI 错误处理程序可能在 UFS 错误处理中调用此命令队列函数。
             * 当错误处理中状态从 RESET 转到 EH_SCHEDULED_NON_FATAL 时，防止
             * 在此情况下发出新的请求。
             */
            if (ufshcd_eh_in_progress(hba)) {
                err = SCSI_MLQUEUE_HOST_BUSY; // 主机忙碌，暂时无法处理命令
                goto out;
            }
            break;

        case UFSHCD_STATE_EH_SCHEDULED_FATAL:
            /*
             * 在错误处理准备阶段会调用 pm_runtime_get_sync()。
             * 若从 HBA 的电源管理操作发送 SCSI 命令（如 SSU 命令），
             * 如果 UFS 状态不佳而允许命令通过，可能导致超时阻塞。
             * 因此直接返回错误，以便错误处理程序恢复 PM 错误。
             */
            if (hba->pm_op_in_progress) {
                hba->force_reset = true;
                set_host_byte(cmd, DID_BAD_TARGET); // 设置命令目标状态为 BAD
                scsi_done(cmd); // 完成命令
                goto out;
            }
            fallthrough; // 继续往下执行到 RESET

        case UFSHCD_STATE_RESET:
            err = SCSI_MLQUEUE_HOST_BUSY; // 主机忙碌
            goto out;

        case UFSHCD_STATE_ERROR:
            set_host_byte(cmd, DID_ERROR); // 设置错误状态
            scsi_done(cmd); // 结束命令
            goto out;
    }

    // 重置请求的中止计数
    hba->req_abort_count = 0;

    // 保持 UFS 资源
    ufshcd_hold(hba);

    // 初始化逻辑请求块（Logical Request Block, LRB）信息
    lrbp = &hba->lrb[tag];
    lrbp->cmd = cmd; // 设置 SCSI 命令
    lrbp->task_tag = tag; // 任务标识
    lrbp->lun = ufshcd_scsi_to_upiu_lun(cmd->device->lun); // 逻辑单元号转换
    lrbp->intr_cmd = !ufshcd_is_intr_aggr_allowed(hba); // 检查是否允许中断聚合

    // 准备加密信息
    ufshcd_prepare_lrbp_crypto(scsi_cmd_to_rq(cmd), lrbp);

    // 标记该请求不跳过中止
    lrbp->req_abort_skip = false;

    // 构建 SCSI UPIU（UFS 协议单元）数据包
    ufshcd_comp_scsi_upiu(hba, lrbp);

    // 映射 Scatter-Gather 列表，准备传输数据
    err = ufshcd_map_sg(hba, lrbp);
    if (err) {
        // 如果映射失败，释放 UFS 资源并退出
        ufshcd_release(hba);
        goto out;
    }

    // 如果启用了多队列 (MCQ)，则将请求映射到硬件队列
    if (is_mcq_enabled(hba))
        hwq = ufshcd_mcq_req_to_hwq(hba, scsi_cmd_to_rq(cmd));

    // 发送 UFS 命令，执行传输
    ufshcd_send_command(hba, tag, hwq);

out:
    // 如果需要触发错误处理程序，进行调度
    if (ufs_trigger_eh(hba)) {
        unsigned long flags;

        // 锁定主机的自旋锁以安全调度错误处理程序
        spin_lock_irqsave(hba->host->host_lock, flags);
        ufshcd_schedule_eh_work(hba); // 调度错误处理工作
        spin_unlock_irqrestore(hba->host->host_lock, flags);
    }

    // 返回错误代码（如果有）
    return err;
}

主控与UFS驱动的交互

传入的SCSI 命令会写入到 UFS 主控寄存器中。
存储命令后进一步执行命令，与存储介质通信，执行具体的读写操作。
**状态反馈：**操作完成时，UFS 主控会通过中断或者状态寄存器通知UFS操作结果。

数据返回和错误处理

数据返回：如果命令执行成功，数据会通过UFS 主控返回 ufs驱动，驱动则将数据放到缓冲区，通知SCSI 子系统完成。

**错误处理：**设备没有空闲空间，UFS 报告错误状态，SCSI子系统重新执行或终止请求。

SCSI 子系统传递到上层

其中的过程应该是 块设备 --->文件系统--->**应用程序，**类似U型锁一样往复从底层到上层。

详细文件构造过程

用户空间： open()** 系统调用**

在用户空间，应用程序调用 open("filename", O_CREAT | O_RDWR, 0644)。这里的 O_CREAT 标志告诉系统要创建文件。此调用通过 glibc 传递到内核，进入 VFS 层处理。

VFS 层：调用 open() 方法

VFS 层解析路径，并在目标目录中检查文件是否存在：

如果文件不存在，则调用文件系统特定的 create 方法（如 EXT4 文件系统的 ext4_create）来创建文件。
如果文件系统支持 journaling（如 EXT4），会在 journal 中记录创建文件的元数据操作。

文件系统驱动层：更新元数据

具体文件系统驱动（如 EXT4）负责管理和更新文件元数据，包括文件的 inode、目录项等：

分配 inode ：调用 inode 分配函数分配一个新的 inode。
更新目录项：在父目录的目录表中添加一个新的条目，指向新创建的文件 inode。
提交元数据更新：如果文件系统使用 journaling，则会将元数据变更提交到 journal 中，并在适当时写入磁盘。

块层：分配并写入数据块

文件系统驱动调用块层，将分配给文件的 inode 及数据块标记为已使用。然后数据写入请求被传递到块层，由块设备驱动负责分配块并将数据写入存储设备。

SCSI 子系统：封装请求并调度

块层的请求被传递到 SCSI 子系统。在这里，块 I/O 请求会被封装为 SCSI 命令。SCSI 子系统负责：

命令封装 ：将 I/O 请求转换成合适的 SCSI 命令，如 WRITE。
命令调度：根据 I/O 调度算法（如 CFQ、Deadline 等）安排命令的执行顺序。
错误处理：如果命令执行失败，SCSI 子系统可以重试请求或返回错误。

UFS 驱动 **：处理 SCSI 命令

SCSI 子系统将封装好的 SCSI 命令传递给 UFS 驱动层。UFS 驱动会执行以下步骤：

解析命令：UFS 驱动解析 SCSI 命令，将其转换为 UFS 协议（UPIU）命令。
发送命令：UFS 驱动将 UPIU 命令通过寄存器写入 UFS 主控（Host Controller），启动数据传输。
等待传输完成：UFS 主控完成操作后会通过中断通知 UFS 驱动。
状态返回：UFS 驱动解析状态并将结果返回给 SCSI 子系统。

UFS 存储设备：执行写入操作

最终，UFS 主控接收并处理 UPIU 命令，UFS 存储设备执行数据写入操作，并返回状态信息（成功或错误），将结果返回给 UFS 驱动。

返回结果

UFS 驱动将操作结果返回给 SCSI 子系统。
SCSI 子系统通知块层请求已完成，或者进行错误重试。
块层通知文件系统写入成功，文件系统驱动层更新状态。
VFS 层完成文件创建过程，将成功结果返回给用户空间应用。

小结

我们再回顾一下创建文件的整体流程吧，从用户态到硬件层起始并没有我们想象的哪么简单，需要涉及到用户端--->系统调用（open or write）--->文件系统（vfs)--->实际文件系统（f2fs_open or f2fs_write）--->块设备处理-封装IO请求（封装 IO）--->SCSI---> UFS ,真的再一次感受代码改变世界。