Linux3.10.0块IO子系统流程（4）-- 为请求构造SCSI命令

首先来看scsi_prep_fn

 

int scsi_prep_fn(struct request_queue *q, struct request *req)
{
    struct scsi_device *sdev = q->queuedata;
    int ret = BLKPREP_KILL;

    if (req->cmd_type == REQ_TYPE_BLOCK_PC)
        ret = scsi_setup_blk_pc_cmnd(sdev, req);
    return scsi_prep_return(q, req, ret);
}

 

scsi_prep_fn只能处理来自SCSI公共层的命令，在scsi_setup_blk_pc_cmnd函数返回后，根据返回值调用scsi_prep_return进行相应的处理

 

int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
{
    struct scsi_cmnd *cmd;
    int ret = scsi_prep_state_check(sdev, req);    // 根据请求的标志位以及SCSI设备的状态进行初步检查

    if (ret != BLKPREP_OK)
        return ret;

    /*
      * 分配一个新的scsi_cmnd描述符，将它记录在special域；如果这里已经指向了一个现有的scsi_cmnd描述符，直接使用它
      */ 
    cmd = scsi_get_cmd_from_req(sdev, req);    
    if (unlikely(!cmd))
        return BLKPREP_DEFER;

    /*
     * BLOCK_PC requests may transfer data, in which case they must a bio attached to them.  Or they might contain a SCSI command
     * that does not transfer data, in which case they may optionally submit a request without an attached bio.
     * 尽管请求来自SCSI公共服务层，但是这些请求也可以涉及数据传输，在bio中保存的数据最终需要复制到SCSI命令描述符的数据缓冲区中
     * 具体的工作由scsi_init_io完成，后续分析
     * 如果不涉及数据传输，就将SCSI命令缓冲区清零
     */
    if (req->bio) {
        int ret;

        BUG_ON(!req->nr_phys_segments);

        ret = scsi_init_io(cmd, GFP_ATOMIC);
        if (unlikely(ret))
            return ret;
    } else {
        BUG_ON(blk_rq_bytes(req));

        memset(&cmd->sdb, 0, sizeof(cmd->sdb));
        req->buffer = NULL;
    }

    cmd->cmd_len = req->cmd_len;
    if (!blk_rq_bytes(req))
        cmd->sc_data_direction = DMA_NONE;
    else if (rq_data_dir(req) == WRITE)
        cmd->sc_data_direction = DMA_TO_DEVICE;
    else
        cmd->sc_data_direction = DMA_FROM_DEVICE;
    
    cmd->transfersize = blk_rq_bytes(req);
    cmd->allowed = req->retries;
    return BLKPREP_OK;
}

 

sd_prep_fn函数从request结构中的信息构造SCSI（读或写）命令，将结果保存在request的special域，sd_prep_fn只能处理来自上层的请求（REQ_TYPE_FS），以及来自SCSI层的（REQ_TYPE_BLOCK_PC）请求。有一种请求比较特殊，即所谓的DISCARD请求。这个请求来自上层，但需要被转换成SCSI请求来处理

 

/**
*    sd_prep_fn - build a scsi (read or write) command from
*    information in the request structure.
*    @SCpnt: pointer to mid-level's per scsi command structure that
*    contains request and into which the scsi command is written
*
*    Returns 1 if successful and 0 if error (or cannot be done now).
**/
static int sd_prep_fn(struct request_queue *q, struct request *rq)
{
    struct scsi_cmnd *SCpnt;
    struct scsi_device *sdp = q->queuedata;
    struct gendisk *disk = rq->rq_disk;
    struct scsi_disk *sdkp;
    sector_t block = blk_rq_pos(rq);
    sector_t threshold;
    unsigned int this_count = blk_rq_sectors(rq);
    int ret, host_dif;
    unsigned char protect;

    /*
     * Discard request come in as REQ_TYPE_FS but we turn them into
     * block PC requests to make life easier.
     */
    if (rq->cmd_flags & REQ_DISCARD) {
        ret = sd_setup_discard_cmnd(sdp, rq);
        goto out;
    } else if (rq->cmd_flags & REQ_WRITE_SAME) {
        ret = sd_setup_write_same_cmnd(sdp, rq);
        goto out;
    } else if (rq->cmd_flags & REQ_FLUSH) {
        ret = scsi_setup_flush_cmnd(sdp, rq);
        goto out;
    } else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
        ret = scsi_setup_blk_pc_cmnd(sdp, rq);
        goto out;
    } else if (rq->cmd_type != REQ_TYPE_FS) {
        ret = BLKPREP_KILL;
        goto out;
    }
    ret = scsi_setup_fs_cmnd(sdp, rq);
    if (ret != BLKPREP_OK)
        goto out;
    SCpnt = rq->special;
    sdkp = scsi_disk(disk);

    /* from here on until we're complete, any goto out
     * is used for a killable error condition */
    ret = BLKPREP_KILL;

    SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
                    "sd_prep_fn: block=%llu, "
                    "count=%d\n",
                    (unsigned long long)block,
                    this_count));

    /*
     * 以下几种情况直接结束命令：
     * 1.SCSI不在线
     * 2.请求数据超出了设备容量
     * 3.磁盘介质发生了变化
     */
    if (!sdp || !scsi_device_online(sdp) ||
        block + blk_rq_sectors(rq) > get_capacity(disk)) {
        SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
                        "Finishing %u sectors\n",
                        blk_rq_sectors(rq)));
        SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
                        "Retry with 0x%p\n", SCpnt));
        goto out;
    }

    if (sdp->changed) {
        /*
         * quietly refuse to do anything to a changed disc until
         * the changed bit has been reset
         */
        /* printk("SCSI disk has been changed or is not present. Prohibiting further I/O.\n"); */
        goto out;
    }

    /*
     * Some SD card readers can't handle multi-sector accesses which touch the last one or two hardware sectors.  Split accesses as needed.
     * 某些设备（如SD卡）不能多扇区访问最后的部分扇区，需分割访问
     */
    threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS *
        (sdp->sector_size / 512);

    if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) {
        if (block < threshold) {
            /* Access up to the threshold but not beyond */
            this_count = threshold - block;
        } else {
            /* Access only a single hardware sector */
            this_count = sdp->sector_size / 512;
        }
    }

    SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
                    (unsigned long long)block));

    /*
     * If we have a 1K hardware sectorsize, prevent access to single 512 byte sectors.  
     * In theory we could handle this - in fact the scsi cdrom driver must be able to handle this because
     * we typically use 1K blocksizes, and cdroms typically have 2K hardware sectorsizes.  
     * Of course, things are simpler with the cdrom, since it is read-only.  For performance reasons, 
     * the filesystems should be able to handle this and not force the scsi disk driver to use bounce buffers for this.
     * 磁盘的硬件扇区长度可能不是512，而是1024/2048或4096
     */
    if (sdp->sector_size == 1024) {
        if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
            scmd_printk(KERN_ERR, SCpnt,
                    "Bad block number requested\n");
            goto out;
        } else {
            block = block >> 1;
            this_count = this_count >> 1;
        }
    }
    if (sdp->sector_size == 2048) {
        if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
            scmd_printk(KERN_ERR, SCpnt,
                    "Bad block number requested\n");
            goto out;
        } else {
            block = block >> 2;
            this_count = this_count >> 2;
        }
    }
    if (sdp->sector_size == 4096) {
        if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
            scmd_printk(KERN_ERR, SCpnt,
                    "Bad block number requested\n");
            goto out;
        } else {
            block = block >> 3;
            this_count = this_count >> 3;
        }
    }
    if (rq_data_dir(rq) == WRITE) {
        if (!sdp->writeable) {
            goto out;
        }
        SCpnt->cmnd[0] = WRITE_6;
        SCpnt->sc_data_direction = DMA_TO_DEVICE;

        if (blk_integrity_rq(rq))
            sd_dif_prepare(rq, block, sdp->sector_size);

    } else if (rq_data_dir(rq) == READ) {
        SCpnt->cmnd[0] = READ_6;
        SCpnt->sc_data_direction = DMA_FROM_DEVICE;
    } else {
        scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
        goto out;
    }

    SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
                    "%s %d/%u 512 byte blocks.\n",
                    (rq_data_dir(rq) == WRITE) ?
                    "writing" : "reading", this_count,
                    blk_rq_sectors(rq)));

    /* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
    host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
    if (host_dif)
        protect = 1 << 5;
    else
        protect = 0;

    if (host_dif == SD_DIF_TYPE2_PROTECTION) {
        SCpnt->cmnd = mempool_alloc(sd_cdb_pool, GFP_ATOMIC);

        if (unlikely(SCpnt->cmnd == NULL)) {
            ret = BLKPREP_DEFER;
            goto out;
        }

        SCpnt->cmd_len = SD_EXT_CDB_SIZE;
        memset(SCpnt->cmnd, 0, SCpnt->cmd_len);
        SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD;
        SCpnt->cmnd[7] = 0x18;
        SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32;
        SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);

        /* LBA */
        SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
        SCpnt->cmnd[13] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
        SCpnt->cmnd[14] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
        SCpnt->cmnd[15] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
        SCpnt->cmnd[16] = (unsigned char) (block >> 24) & 0xff;
        SCpnt->cmnd[17] = (unsigned char) (block >> 16) & 0xff;
        SCpnt->cmnd[18] = (unsigned char) (block >> 8) & 0xff;
        SCpnt->cmnd[19] = (unsigned char) block & 0xff;

        /* Expected Indirect LBA */
        SCpnt->cmnd[20] = (unsigned char) (block >> 24) & 0xff;
        SCpnt->cmnd[21] = (unsigned char) (block >> 16) & 0xff;
        SCpnt->cmnd[22] = (unsigned char) (block >> 8) & 0xff;
        SCpnt->cmnd[23] = (unsigned char) block & 0xff;

        /* Transfer length */
        SCpnt->cmnd[28] = (unsigned char) (this_count >> 24) & 0xff;
        SCpnt->cmnd[29] = (unsigned char) (this_count >> 16) & 0xff;
        SCpnt->cmnd[30] = (unsigned char) (this_count >> 8) & 0xff;
        SCpnt->cmnd[31] = (unsigned char) this_count & 0xff;
    } else if (sdp->use_16_for_rw) {
        SCpnt->cmnd[0] += READ_16 - READ_6;
        SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
        SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
        SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
        SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
        SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
        SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
        SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
        SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
        SCpnt->cmnd[9] = (unsigned char) block & 0xff;
        SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
        SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
        SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
        SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
        SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
    } else if ((this_count > 0xff) || (block > 0x1fffff) ||
           scsi_device_protection(SCpnt->device) ||
           SCpnt->device->use_10_for_rw) {
        if (this_count > 0xffff)
            this_count = 0xffff;

        SCpnt->cmnd[0] += READ_10 - READ_6;
        SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
        SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
        SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
        SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
        SCpnt->cmnd[5] = (unsigned char) block & 0xff;
        SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
        SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
        SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
    } else {
        if (unlikely(rq->cmd_flags & REQ_FUA)) {
            /*
             * This happens only if this drive failed
             * 10byte rw command with ILLEGAL_REQUEST
             * during operation and thus turned off
             * use_10_for_rw.
             */
            scmd_printk(KERN_ERR, SCpnt,
                    "FUA write on READ/WRITE(6) drive\n");
            goto out;
        }

        SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
        SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
        SCpnt->cmnd[3] = (unsigned char) block & 0xff;
        SCpnt->cmnd[4] = (unsigned char) this_count;
        SCpnt->cmnd[5] = 0;
    }
    SCpnt->sdb.length = this_count * sdp->sector_size;

    /* If DIF or DIX is enabled, tell HBA how to handle request */
    if (host_dif || scsi_prot_sg_count(SCpnt))
        sd_prot_op(SCpnt, host_dif);

    /*
     * We shouldn't disconnect in the middle of a sector, so with a dumb
     * host adapter, it's safe to assume that we can at least transfer
     * this many bytes between each connect / disconnect.
     */
    SCpnt->transfersize = sdp->sector_size;
    SCpnt->underflow = this_count << 9;
    SCpnt->allowed = SD_MAX_RETRIES;

    /*
     * This indicates that the command is ready from our end to be
     * queued.
     */
    ret = BLKPREP_OK;
out:
    return scsi_prep_return(q, rq, ret);
}

 

scsi_setup_fs_cmnd函数前面和之前分析过的差不多，来自文件系统的请求是需要传输数据的，也就是要为bio描述符中的数据分配SCSI数据缓冲区，就是scsi_init_io

 

/*
* Setup a REQ_TYPE_FS command.  These are simple read/write request
* from filesystems that still need to be translated to SCSI CDBs from
* the ULD.
*/
int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req)
{
    struct scsi_cmnd *cmd;
    int ret = scsi_prep_state_check(sdev, req);

    if (ret != BLKPREP_OK)
        return ret;

    if (unlikely(sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh
             && sdev->scsi_dh_data->scsi_dh->prep_fn)) {
        ret = sdev->scsi_dh_data->scsi_dh->prep_fn(sdev, req);
        if (ret != BLKPREP_OK)
            return ret;
    }

    /*
     * Filesystem requests must transfer data.
     */
    BUG_ON(!req->nr_phys_segments);

    cmd = scsi_get_cmd_from_req(sdev, req);
    if (unlikely(!cmd))
        return BLKPREP_DEFER;

    /* 
     * 来自上层的请求信息都在bio里，和SCSI公共层请求不一样，我们需要重新为它构造SCSI规范定义的SCSI命令
     * 构造好的内容会保存在scsi_cmnd描述符的cmnd域，所以首先将这个命令缓冲区清零
     */
    memset(cmd->cmnd, 0, BLK_MAX_CDB);
    return scsi_init_io(cmd, GFP_ATOMIC);
}