trim 是ata 的一个指令，对应scsi指令是unmap，那么什么是trim呢？

trim就是OS发送给ssd  or other type controller, 告诉它哪些数据对应的LBA地址是无效的。之后trim就不做什么其他操作了。后续的事情由GC来进行。

Secure erase是一则ATA安全擦除命令，用户清除磁盘上的所有数据。这则命令可以理解为主控的返厂状态命令。

trim对于传统磁盘来讲没有什么意义，因为磁介质是可以覆盖写的。而在flash stroage上，由于nand一个天生的特性，写之前必须擦干净，也就是要释放掉flash里面的电子。

所以trim是flash必须支持的特性。

在用户态如果不发起trim，那么flash设备是不会trim掉相应的数据，只有LBA地址重复时，才会标记数据为脏。那么对于块设备的使用者，可以明确哪些块不使用时，可以直接把数据删除掉，而不必等着LBA重复地址写，标记为脏块。否则只有GC来进行回收脏数据了。

带来的好处是，用户不要的数据，及时被清理掉。这样有效数据块减少，GC的效率也提高了。

这样OP空间及时释放，有利于提高性能。（空间及时释放，OP并不是单独分离的空间）

SSD是以块为单位进行擦除的，大小通常是512KB，这意味着如果某个块上的一个页面发生了变化，整个SSD都需要重写，重写过程需要经历漫长的“读-修改-擦除-写”周期，“读”通常指的是将块上的所有数据读入到缓存中，接着将“修改的”数据和缓存中已有的数据合并，然后“擦除”那个块上的全部数据，最后将缓存中的新数据“回写”到已被擦除的块上。

SSD的擦除速度要比读取速度慢好多倍，导致整个“读-修改-擦除-写”周期花费的总时间变长。更糟糕的是，“读-修改-擦除-写”周期会产生一个所谓的写放大系数，它指的是即使是块上单个页面发生变化或更新，也会导致使用额外的写周期，理想情况下，写放大系数应等于1，即向存储介质写入数据时，不需要额外的写周期，如果写放大系数大于1，则意味着向存储介质写入数据时，不止发生一次写入操作。

一种技术叫做写合并，控制器将多个写操作收集到一起，然后一次性将这些数据写入到SSD的块上。合并的目标是将多个小的写操作合并成一个大的写操作，大多数时候，相邻页面的数据会同时发生变化，这些页面很可能属于同一个文件。通过写合并技术，写放大系数大大减小了，SSD的性能也显著提高了，但这也与发送数据的方式，以及数据块是否同属于同一个文件，或是否在同一时间发生变化有关。

当你在电脑里删除一个文件的时候，操作系统并不会真正的去删除它。操作系统只是把这个文件的地址标记为“空”，让它可以被再次使用，这表示这个文件所占的地址已经“无效”。

对于linux的文件系统，可能仅仅把inode节点释放掉。也可能只是仅仅标记为可回收的inode。

对于块设备的使用者有两种情况，直接操作块设备，另一种是通过文件系统间接来操作。

对于块设备，可以通过ioctl的方式，发送trim。

对于ext4文件系统通过mount时加入discard参数，当用户删除文件时，会自动触发trim操作。

另外文件系统格式化时也会trim。

那么对于trim操作，flash firmware真的就是立即去擦除吗？这个不一定，和其实现的机制有关系。

另外一个问题是，trim一次的大小是什么？

这设计到nand操作的块大小，和擦除块大小的不同。

SSD:一个page为4K或8K或16K，将多个page作为一个block来使用。一个block一般为512K到1M。一些block构成一个plane。一些plane构成die。

读写以page为单位。擦除以block为单位，把所有的cell都变为1.

对于scsi块设备，sg3_utils工具可以发送trim

scsi trim:

dd if=./sg_requests.c of=/dev/sdb //表示写入一些数据

hexdump -C -n 512 /dev/sdb //表示已16进制的方式读取写入的数据，读取512byte

./sg_unmap --lba=0x0 --num=1 /dev/sdb //从lba 0开始擦除一个sector，当然nand是没有扇区的概念的，完全是为传统磁盘里的概念

hexdump -C -n 512 /dev/sdb //查看刚才写入的数据，这里可能为全0，也可能不是，有的实现机制是重启os，flash擦除。

关于hexdump的说明

使用hexdump以16进制查看内容

有时候需要查看一些二进制文件的内容，比如二进制文件中包含的某些字符串。这个时候可以用hexdump工具看查看。
常用参数： hexdump -C -n length -s skip file_name
-C 定义了导出的格式，-s skip 指定了从文件头跳过多少字节，或者说是偏移量，默认是十进制。如果是0x开头，则是十六进制。-n 指定了导出多少长度

那些用户态工具可以发trim： fstrim发送文件系统的trim， blkdiscard发送块设备的trim， sg3_utils可以发送SG_IO。

那么我们来看一下trim在linux内核里是怎么实现的呢？

看一下sg3 sg_unmap是如何发送trim cmd的。

ioctl(fd, SG_IO, &ptp->io_hdr)

Hdparm 可以使用下面的参数发送trim给ssd

--trim-sector-ranges        Tell SSD firmware to discard unneeded data sectors: lba:count ..

--trim-sector-ranges-stdin  Same as above, but reads lba:count pairs from stdin

看一下FIO是如何发送trim的。

通过ioengine发送trim do_io_u_trim(td, io_u)

static inline int os_trim(int fd, unsigned long long start,unsigned long long len)
{
uint64_t range[2];
range[0] = start;
range[1] = len;
if (!ioctl(fd, BLKDISCARD, range))
return 0;
return errno;
}

通过block ioctl发送到dev中。然后调用到blkdev_ioctl中。

case 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)
{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);
}

文件系统发送Trim的ioctl

#define BMAP_IOCTL 1        /* obsolete - kept for compatibility */
#define FIBMAP     _IO(0x00,1)  /* bmap access */
#define FIGETBSZ   _IO(0x00,2)  /* get the block size used for bmap */
#define FIFREEZE    _IOWR('X', 119, int)  /* Freeze */
#define FITHAW      _IOWR('X', 120, int)  /* Thaw */
#define FITRIM      _IOWR('X', 121, struct fstrim_range)  /* Trim */

FITRIM        

ext4 如何处理trim的

include/uapi/linux/fs.h userspace api 目前放到了uapi下面了struct fstrim_range {__u64 start;__u64 len;__u64 minlen;
};ext4/ioctl.cconst struct file_operations ext4_file_operations = {.llseek     = ext4_llseek,.read        = do_sync_read,.write      = do_sync_write,.aio_read  = generic_file_aio_read,.aio_write = ext4_file_write,.unlocked_ioctl = ext4_ioctl,
#ifdef CONFIG_COMPAT.compat_ioctl   = ext4_compat_ioctl,
#endif.mmap     = ext4_file_mmap,.open     = ext4_file_open,.release  = ext4_release_file,.fsync     = ext4_sync_file,.splice_read  = generic_file_splice_read,.splice_write   = generic_file_splice_write,.fallocate = ext4_fallocate,
};long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)在这里处理ioctl。case FITRIM:{struct request_queue *q = bdev_get_queue(sb->s_bdev);struct fstrim_range range;int ret = 0;if (!capable(CAP_SYS_ADMIN))return -EPERM;if (!blk_queue_discard(q))return -EOPNOTSUPP;if (copy_from_user(&range, (struct fstrim_range __user *)arg,sizeof(range)))return -EFAULT;range.minlen = max((unsigned int)range.minlen,q->limits.discard_granularity);ret = ext4_trim_fs(sb, &range); //trim ioctl handle functionif (ret < 0)return ret;if (copy_to_user((struct fstrim_range __user *)arg, &range,sizeof(range)))return -EFAULT;return 0;}ext4_trim_fs -->ext4_trim_all_free-->ext4_trim_extent->ext4_issue_discard(sb, group, start, count);-->sb_issue_discard-->//block layer给出API， sb_issue_discard 或 blkdev_issue_discard；ext4_issue_discard->sb_issue_discardstatic inline int sb_issue_discard(struct super_block *sb, sector_t block,sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
{return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),nr_blocks << (sb->s_blocksize_bits - 9),gfp_mask, flags);
}

在blkdev_issue_discard中封装一个bio，send到块设备上。submit_bio(type, bio);这里把discard flag打到bio结构体里。

bio这里加入了type REQ_DISCARD类型，告诉bio这是一个trim的io。

驱动有两种处理方法，一种是处理request，一种是直接处理bio。

struct bio {unsigned long      bi_rw;      /* bottom bits READ/WRITE,* top bits priority*/struct request {union {struct list_head queuelist;struct llist_node ll_list;};union {struct call_single_data csd;struct work_struct mq_flush_work;};struct request_queue *q;struct blk_mq_ctx *mq_ctx;u64 cmd_flags;                  req->cmd_flags & REQ_DISCARD)               

/** Called with local interrupts disabled and the q_lock held.  May not sleep.*/
static int nvme_submit_bio_queue(struct nvme_queue *nvmeq, struct nvme_ns *ns,struct bio *bio)if (bio->bi_rw & REQ_DISCARD) {result = nvme_submit_discard(nvmeq, ns, bio, iod, cmdid);if (result)goto free_cmdid;return result;}/** We reuse the small pool to allocate the 16-byte range here as it is not* worth having a special pool for these or additional cases to handle freeing* the iod.*/
static int nvme_submit_discard(struct nvme_queue *nvmeq, struct nvme_ns *ns,struct bio *bio, struct nvme_iod *iod, int cmdid)
{struct nvme_dsm_range *range;struct nvme_command *cmnd = &nvmeq->sq_cmds[nvmeq->sq_tail];range = dma_pool_alloc(nvmeq->dev->prp_small_pool, GFP_ATOMIC,&iod->first_dma);if (!range)return -ENOMEM;iod_list(iod)[0] = (__le64 *)range;iod->npages = 0;range->cattr = cpu_to_le32(0);range->nlb = cpu_to_le32(bio->bi_size >> ns->lba_shift);range->slba = cpu_to_le64(nvme_block_nr(ns, bio->bi_sector));memset(cmnd, 0, sizeof(*cmnd));cmnd->dsm.opcode = nvme_cmd_dsm;cmnd->dsm.command_id = cmdid;cmnd->dsm.nsid = cpu_to_le32(ns->ns_id);cmnd->dsm.prp1 = cpu_to_le64(iod->first_dma);cmnd->dsm.nr = 0;cmnd->dsm.attributes = cpu_to_le32(NVME_DSMGMT_AD);if (++nvmeq->sq_tail == nvmeq->q_depth)nvmeq->sq_tail = 0;writel(nvmeq->sq_tail, nvmeq->q_db);return 0;
}/* I/O commands */enum nvme_opcode {nvme_cmd_flush     = 0x00,nvme_cmd_write      = 0x01,nvme_cmd_read       = 0x02,nvme_cmd_write_uncor    = 0x04,nvme_cmd_compare    = 0x05,nvme_cmd_dsm        = 0x09, //  data set management command
};

看一下nvme driver是如何处理这个ioctl的。