linux 内核之block trim BLKDISCARD过程

对SSD进行trim，是通过ioclt发送BLKDISCARD命令完成的。

下面是block层ioctl的调用栈。

sys_ioctl->do_vfs_ioctl->block_ioctl->blkdev_ioctl->blkdev_issue_discard->__blk_run_queue->scsi_request_fn->....

具体通过代码讲解BLKDISCARD执行流程。

static long vfs_ioctl(struct file *filp, unsigned int cmd,

              unsigned long arg)

{

    int error = -ENOTTY;

    if (!filp->f_op->unlocked_ioctl)

        goto out;

    error = filp->f_op->unlocked_ioctl(filp, cmd, arg);//这里f_op注册的是def_blk_fops->unlocked_ioctl,即block_ioctl

    if (error == -ENOIOCTLCMD)

        error = -ENOTTY;

 out:

    return error;

}

static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)

{

    struct block_device *bdev = I_BDEV(file->f_mapping->host);

    fmode_t mode = file->f_mode;

    /*

     * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have

     * to updated it before every ioctl.

     */

    if (file->f_flags & O_NDELAY)

        mode |= FMODE_NDELAY;

    else

        mode &= ~FMODE_NDELAY;

    return blkdev_ioctl(bdev, mode, cmd, arg);

}

int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,

            unsigned long arg)

{

     ....

     case BLKDISCARD: //对于cmd为BLKDISCARD的命令，走该分支；

    case BLKSECDISCARD: {

        uint64_t range[2];

        if (!(mode & FMODE_WRITE))

            return -EBADF;

        if (copy_from_user(range, (void __user *)arg, sizeof(range)))

            return -EFAULT;

        return blk_ioctl_discard(bdev, range[0], range[1],

                     cmd == BLKSECDISCARD);

         }

     .....

}

static int blk_ioctl_discard(struct block_device *bdev, uint64_t start,

                 uint64_t len, int secure) //参数为起始sector，discard的长度len，单位为sector

{

    unsigned long flags = 0;

    if (start & 511)

        return -EINVAL;

    if (len & 511)

        return -EINVAL;

    start >>= 9;

    len >>= 9;

    if (start + len > (i_size_read(bdev->bd_inode) >> 9))

        return -EINVAL;

    if (secure)

        flags |= BLKDEV_DISCARD_SECURE;

    return blkdev_issue_discard(bdev, start, len, GFP_KERNEL, flags);

}

int blkdev_issue_discard(struct block_device *bdev, sector_t sector,

        sector_t nr_sects, gfp_t gfp_mask, unsigned long flags)

{

    DECLARE_COMPLETION_ONSTACK(wait);

    struct request_queue *q = bdev_get_queue(bdev);

    int type = REQ_WRITE | REQ_DISCARD; //将bio的类型设置为WRITE|DISCARD

    unsigned int max_discard_sectors, granularity;

    int alignment;

    struct bio_batch bb;

    struct bio *bio;

    int ret = 0;

    struct blk_plug plug;

    if (!q)

        return -ENXIO;

    if (!blk_queue_discard(q))

        return -EOPNOTSUPP;

    /* Zero-sector (unknown) and one-sector granularities are the same.  */

    granularity = max(q->limits.discard_granularity >> 9, 1U);

    alignment = (bdev_discard_alignment(bdev) >> 9) % granularity;

    /*

     * Ensure that max_discard_sectors is of the proper

     * granularity, so that requests stay aligned after a split.

     */

    max_discard_sectors = min(q->limits.max_discard_sectors, UINT_MAX >> 9);

    max_discard_sectors -= max_discard_sectors % granularity;

    if (unlikely(!max_discard_sectors)) {

        /* Avoid infinite loop below. Being cautious never hurts. */

        return -EOPNOTSUPP;

    }

    if (flags & BLKDEV_DISCARD_SECURE) {

        if (!blk_queue_secdiscard(q))

            return -EOPNOTSUPP;

        type |= REQ_SECURE;

    }

    atomic_set(&bb.done, 1);

    bb.flags = 1 << BIO_UPTODATE;

    bb.wait = &wait;

    blk_start_plug(&plug);

    while (nr_sects) { 

        unsigned int req_sects;//循环发送bio请求给硬盘

        sector_t end_sect, tmp;

        bio = bio_alloc(gfp_mask, 1); //分配一个bio

        if (!bio) {

            ret = -ENOMEM;

            break;

        }

        req_sects = min_t(sector_t, nr_sects, max_discard_sectors);

        /*

         * If splitting a request, and the next starting sector would be

         * misaligned, stop the discard at the previous aligned sector.

         */

        end_sect = sector + req_sects;

        tmp = end_sect;

        if (req_sects < nr_sects &&

            sector_div(tmp, granularity) != alignment) {

            end_sect = end_sect - alignment;

            sector_div(end_sect, granularity);

            end_sect = end_sect * granularity + alignment;

            req_sects = end_sect - sector;

        }

        bio->bi_iter.bi_sector = sector; //初始化bio的一些成员

        bio->bi_end_io = bio_batch_end_io;

        bio->bi_bdev = bdev;

        bio->bi_private = &bb;

        bio->bi_iter.bi_size = req_sects << 9;

        nr_sects -= req_sects;

        sector = end_sect;

        atomic_inc(&bb.done);

        submit_bio(type, bio);//发送bio

        /*

         * We can loop for a long time in here, if someone does

         * full device discards (like mkfs). Be nice and allow

         * us to schedule out to avoid softlocking if preempt

         * is disabled.

         */

        cond_resched();

    }

    blk_finish_plug(&plug);

    /* Wait for bios in-flight */

    if (!atomic_dec_and_test(&bb.done))

        wait_for_completion_io(&wait);

    if (!test_bit(BIO_UPTODATE, &bb.flags))

        ret = -EIO;

    return ret;

}

发送bio的调用栈：

submit_bio->generic_make_request->blk_queue_bio{这里将bio转换成request，并插入到request_queue中}->__blk_run_queue->scsi_request_fn.

在scsi_request_fn中，首先通过blk_peek_request从request_queue中取出一个req，并通过scsi_prep_fn，对req做一些准备工作。

static int scsi_prep_fn(struct request_queue *q, struct request *req)

{

    struct scsi_device *sdev = q->queuedata;

    struct scsi_cmnd *cmd;

    int ret;

    ret = scsi_prep_state_check(sdev, req);

    if (ret != BLKPREP_OK)

        goto out;

    cmd = scsi_get_cmd_from_req(sdev, req);//通过req构建scsi_cmd结构体，完成block向scsi层转换

    if (unlikely(!cmd)) {

        ret = BLKPREP_DEFER;

        goto out;

    }

    if (req->cmd_type == REQ_TYPE_FS)

        ret = scsi_cmd_to_driver(cmd)->init_command(cmd);//对于req属于fs的类型，调用sd_init_command;

    else if (req->cmd_type == REQ_TYPE_BLOCK_PC)

        ret = scsi_setup_blk_pc_cmnd(sdev, req);

    else

        ret = BLKPREP_KILL;

out:

    return scsi_prep_return(q, req, ret);

}

对于BLKDISCARD的情形，发送的为FS TYPE的cmd，因此，这里走sd_init_command;

static int sd_init_command(struct scsi_cmnd *SCpnt)

{

    struct request *rq = SCpnt->request;

    struct scsi_device *sdp = SCpnt->device;

    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) { //由于cmd_flags包含有REQ_DISCARD flag，因此走该分支；

        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;

    }

     ...

     正常的IO请求初始化走下面分支，这里不再介绍。

     ...

}

static int sd_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)

{

    struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);

    sector_t sector = blk_rq_pos(rq);

    unsigned int nr_sectors = blk_rq_sectors(rq);

    unsigned int nr_bytes = blk_rq_bytes(rq);

    unsigned int len;

    int ret;

    char *buf;

    struct page *page;

    sector >>= ilog2(sdp->sector_size) - 9;

    nr_sectors >>= ilog2(sdp->sector_size) - 9;

    rq->timeout = SD_TIMEOUT;

    memset(rq->cmd, 0, rq->cmd_len);

    page = alloc_page(GFP_ATOMIC | __GFP_ZERO);//分配一个全零的Page

    if (!page)

        return BLKPREP_DEFER;

    switch (sdkp->provisioning_mode) { //根据scsi device的规定的等级，选择不同的discard command，这里provisioning_mode为SD_LBP_WS16

    case SD_LBP_UNMAP:

        buf = page_address(page);

        rq->cmd_len = 10;

        rq->cmd[0] = UNMAP;

        rq->cmd[8] = 24;

        put_unaligned_be16(6 + 16, &buf[0]);

        put_unaligned_be16(16, &buf[2]);

        put_unaligned_be64(sector, &buf[8]);

        put_unaligned_be32(nr_sectors, &buf[16]);

        len = 24;

        break;

    case SD_LBP_WS16:

        rq->cmd_len = 16;

        rq->cmd[0] = WRITE_SAME_16;

        rq->cmd[1] = 0x8; /* UNMAP */

        put_unaligned_be64(sector, &rq->cmd[2]);

        put_unaligned_be32(nr_sectors, &rq->cmd[10]);

        len = sdkp->device->sector_size;

        break;

    case SD_LBP_WS10:

    case SD_LBP_ZERO:

        rq->cmd_len = 10;

        rq->cmd[0] = WRITE_SAME;

        if (sdkp->provisioning_mode == SD_LBP_WS10)

            rq->cmd[1] = 0x8; /* UNMAP */

        put_unaligned_be32(sector, &rq->cmd[2]);

        put_unaligned_be16(nr_sectors, &rq->cmd[7]);

        len = sdkp->device->sector_size;

        break;

    default:

        ret = BLKPREP_KILL;

        goto out;

    }

    rq->completion_data = page;//这里将page 赋值给rq->completion_data，在最后scsi_unprep_fn，调用sd_uninit_command中，通过该变量来释放该page的。

    blk_add_request_payload(rq, page, len);

    ret = scsi_setup_blk_pc_cmnd(sdp, rq);

    rq->__data_len = nr_bytes;

out:

    if (ret != BLKPREP_OK)

        __free_page(page);

    return ret;

}

static void sd_uninit_command(struct scsi_cmnd *SCpnt)

{

    struct request *rq = SCpnt->request;

    if (rq->cmd_flags & REQ_DISCARD)

        __free_page(rq->completion_data);

    if (SCpnt->cmnd != rq->cmd) {

        mempool_free(SCpnt->cmnd, sd_cdb_pool);

        SCpnt->cmnd = NULL;

        SCpnt->cmd_len = 0;

    }

}

接下来，将初始化的scsi_cmd dispatch出去。

scsi_request_fn->scsi_dispatch_cmd->ata_scsi_queuecmd->__ata_scsi_queuecmd.

static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,

                      struct ata_device *dev)

{

    u8 scsi_op = scmd->cmnd[0];

    ata_xlat_func_t xlat_func;

    int rc = 0;

    if (dev->class == ATA_DEV_ATA) {//针对ATA device，走该分支

        if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))

            goto bad_cdb_len;

        xlat_func = ata_get_xlat_func(dev, scsi_op);

    } else {

        if (unlikely(!scmd->cmd_len))

            goto bad_cdb_len;

        xlat_func = NULL;

        if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {

            /* relay SCSI command to ATAPI device */

            int len = COMMAND_SIZE(scsi_op);

            if (unlikely(len > scmd->cmd_len || len > dev->cdb_len))

                goto bad_cdb_len;

            xlat_func = atapi_xlat;

        } else {

            /* ATA_16 passthru, treat as an ATA command */

            if (unlikely(scmd->cmd_len > 16))

                goto bad_cdb_len;

            xlat_func = ata_get_xlat_func(dev, scsi_op);

        }

    }

    if (xlat_func)

        rc = ata_scsi_translate(dev, scmd, xlat_func);

    else

        ata_scsi_simulate(dev, scmd);

    return rc;

 bad_cdb_len:

    DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",

        scmd->cmd_len, scsi_op, dev->cdb_len);

    scmd->result = DID_ERROR << 16;

    scmd->scsi_done(scmd);

    return 0;

}

static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)

{

    switch (cmd) {

    case READ_6:

    case READ_10:

    case READ_16:

    case WRITE_6:

    case WRITE_10:

    case WRITE_16:

        return ata_scsi_rw_xlat;

    case WRITE_SAME_16:

        return ata_scsi_write_same_xlat;//由于discard通过write_same_16 cmd实现，因此xlat_fn=ata_scsi_write_same_xlat;

    case SYNCHRONIZE_CACHE:

        if (ata_try_flush_cache(dev))

            return ata_scsi_flush_xlat;

        break;

    case VERIFY:

    case VERIFY_16:

        return ata_scsi_verify_xlat;

    case ATA_12:

    case ATA_16:

        return ata_scsi_pass_thru;

    case MODE_SELECT:

    case MODE_SELECT_10:

        return ata_scsi_mode_select_xlat;

        break;

    case START_STOP:

        return ata_scsi_start_stop_xlat;

    }

    return NULL;

}

下面通过ata_scsi_translate把scsi_cmd转换成具体的ata_command发送出去。

static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,

                  ata_xlat_func_t xlat_func)

{

    struct ata_port *ap = dev->link->ap;

    struct ata_queued_cmd *qc;

    int rc;

    VPRINTK("ENTER\n");

    qc = ata_scsi_qc_new(dev, cmd);

    if (!qc)

        goto err_mem;

    /* data is present; dma-map it */

    if (cmd->sc_data_direction == DMA_FROM_DEVICE ||

        cmd->sc_data_direction == DMA_TO_DEVICE) {

        if (unlikely(scsi_bufflen(cmd) < 1)) {

            ata_dev_warn(dev, "WARNING: zero len r/w req\n");

            goto err_did;

        }

        ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));

        qc->dma_dir = cmd->sc_data_direction;

    }

    qc->complete_fn = ata_scsi_qc_complete;

    if (xlat_func(qc)) //具体转换函数

        goto early_finish;

    if (ap->ops->qc_defer) {

        if ((rc = ap->ops->qc_defer(qc)))

            goto defer;

    }

    /* select device, send command to hardware */

    ata_qc_issue(qc); //具体调用sata driver的函数发送命令给controller。

    VPRINTK("EXIT\n");

    return 0;

}

命令完成过程，跟正常command 命令完成流程一样，这里不再列出。