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），并准备好用于与操作系统和文件系统交互，抽象成操作系统或文件系统能够交互的设备。

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函数

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 中记录创建文件的元数据操作。

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

具体文件系统驱动（如 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 ,真的再一次感受代码改变世界。