Trim or Discard or Unmap
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.c
const 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 function
if (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_discard
static 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的。