Ext3/Ext4 Batched discard support
Subsystems (3)
cover Ext3/Ext4 Batched discard support
Hi all,
this is "hopefully" the final version of the patch set, since it looks like everyone agree with this. Since the last version some simple fixes was done.
- As Jan noticed it should subtract the s_first_data_block before modulo when computing the group starting block.
- As Dimitry proposed cond_reshed() is really useless in the ext4_trim_extent and rescheduling should be done in the ext4_trim_all_free.
Also from previous version it supports "partial" fs discard see [PATCH 1/3].
The patch set consist of these three patches. Second and third patch are independent on each other and dependent on the first patch.
[PATCH 1/3] Add ioctl FITRIM.
[PATCH 2/3] Add batched discard support for ext3
[PATCH 3/3] Add batched discard support for ext4
Regards
-Lukas
--- fs/ext3/balloc.c | 250 +++++++++++++++++++++++++++++++++++++++++++++++ fs/ext3/super.c | 1 + fs/ext4/ext4.h | 2 + fs/ext4/mballoc.c | 200 +++++++++++++++++++++++++++++++++++++ fs/ext4/super.c | 1 + fs/ioctl.c | 34 +++++++ include/linux/ext3_fs.h | 1 + include/linux/fs.h | 2 + 8 files changed, 491 insertions(+), 0 deletions(-)
PATCH 1/3 Add ioctl FITRIM.
Adds an filesystem independent ioctl to allow implementation of file system batched discard support. It takes an array of three uint64_t as an argument, the meaning of each item is as follows:
array[0] - (start) first Byte to trim
array[1] - (len) number of Bytes to trim from start
array[2] - (minlen) minimum extent length to trim, free extents shorter than this number of Bytes will be ignored. This number will be rounded up to the block size.
It is also possible to specify NULL as an argument. In this case the arguments will set itself as follows:
args[0] = 0;
args[1] = ULLONG_MAX;
args[2] = 0;
So it will trim the whole file system at one run.
--- fs/ioctl.c | 34 ++++++++++++++++++++++++++++++++++ include/linux/fs.h | 2 ++ 2 files changed, 36 insertions(+), 0 deletions(-)
fs/ioctl.c +34 -0
@@ -540,6 +540,36 @@ static int ioctl_fsthaw(struct file *filp)return thaw_super (sb); } +static int ioctl_fstrim (struct file *filp,void __user *argp) +{ +struct super_block *sb = filp->f_path.dentry->d_inode->i_sb; +uint64_t args[3 ]; +int err; + +if (!capable (CAP_SYS_ADMIN )) +return -EPERM ; + +/* If filesystem doesn't support trim feature, return. */ +if (sb->s_op->trim_fs ==NULL ) +return -EOPNOTSUPP ; + +/* If a blockdevice-backed filesystem isn't specified, return EINVAL. */ +if (sb->s_bdev ==NULL ) +return -EINVAL ; + +if (argp ==NULL ) { + args[0 ] =0 ; + args[1 ] =ULLONG_MAX ; + args[2 ] =0 ; + }else if (copy_from_user (args, argp,sizeof (args))) +return -EFAULT ; + + err = sb->s_op->trim_fs (sb, args[0 ], args[1 ], args[2 ]); +if (err) +return err; +return 0 ; +} +/* * When you add any new common ioctls to the switches above and below * please update compat_sys_ioctl() too.
@@ -590,6 +620,10 @@ int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, error =ioctl_fsthaw (filp);break ; +case FITRIM : + error =ioctl_fstrim (filp, argp); +break ; +case FS_IOC_FIEMAP :return ioctl_fiemap (filp, arg);
include/linux/fs.h +2 -0
@@ -316,6 +316,7 @@ struct inodes_stat_t {#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 _IOW('X', 121, uint64_t)/* Trim */ #define FS_IOC_GETFLAGS _IOR('f', 1, long)#define FS_IOC_SETFLAGS _IOW('f', 2, long)
@@ -1582,6 +1583,7 @@ struct super_operations {ssize_t (*quota_write)(struct super_block *,int ,const char *,size_t ,loff_t );#endif int (*bdev_try_to_free_page)(struct super_block *,struct page *,gfp_t ); +int (*trim_fs) (struct super_block *,uint64_t ,uint64_t ,uint64_t ); };/*
Signature · 1 line
1.7.2.1
PATCH 2/3 Add batched discard support for ext3
In reply to Lukas CzernerWalk through allocation groups and trim all free extents. It can be invoked through FITRIM ioctl on the file system. The main idea is to provide a way to trim the whole file system if needed, since some SSD's may suffer from performance loss after the whole device was filled (it does not mean that fs is full!).
It search for free extents in allocation groups specified by Byte range start -> start+len. When the free extent is within this range, blocks are marked as used and then trimmed. Afterwards these blocks are marked as free in per-group bitmap.
--- fs/ext3/balloc.c | 250 +++++++++++++++++++++++++++++++++++++++++++++++ fs/ext3/super.c | 1 + include/linux/ext3_fs.h | 1 + 3 files changed, 252 insertions(+), 0 deletions(-)
fs/ext3/balloc.c +250 -0
@@ -20,6 +20,7 @@#include <linux/ext3_jbd.h> #include <linux/quotaops.h> #include <linux/buffer_head.h> +#include <linux/blkdev.h> /* * balloc.c contains the blocks allocation and deallocation routines
@@ -1882,3 +1883,252 @@ unsigned long ext3_bg_num_gdb(struct super_block *sb, int group)return ext3_bg_num_gdb_meta (sb,group); } + +/** +* ext3_trim_all_free -- function to trim all free space in alloc. group +* @sb: super block for file system +* @group: allocation group to trim +* @start: first group block to examine +* @max: last group block to examine +* @gdp: allocation group description structure +* @minblocks: minimum extent block count +* +* ext3_trim_all_free walks through group's block bitmap searching for free +* blocks. When the free block is found, it tries to allocate this block and +* consequent free block to get the biggest free extent possible, until it +* reaches any used block. Then issue a TRIM command on this extent and free +* the extent in the block bitmap. This is done until whole group is scanned. +*/ +ext3_grpblk_t ext3_trim_all_free (struct super_block *sb,unsigned int group, +ext3_grpblk_t start,ext3_grpblk_t max, +ext3_grpblk_t minblocks) +{ +handle_t *handle; +ext3_grpblk_t next, count =0 , bit; +struct ext3_sb_info *sbi; +ext3_fsblk_t discard_block; +struct buffer_head *bitmap_bh =NULL ; +struct buffer_head *gdp_bh; +ext3_grpblk_t free_blocks; +struct ext3_group_desc *gdp; +int err =0 , ret =0 ; +ext3_grpblk_t freed; + +/* +* We will update one block bitmap, and one group descriptor +*/ + handle =ext3_journal_start_sb (sb,2 ); +if (IS_ERR (handle)) { + err =PTR_ERR (handle); +return err; + } + + bitmap_bh =read_block_bitmap (sb, group); +if (!bitmap_bh) + goto err_out; + +BUFFER_TRACE (bitmap_bh,"getting undo access" ); + err =ext3_journal_get_undo_access (handle, bitmap_bh); +if (err) + goto err_out; + + gdp =ext3_get_group_desc (sb, group, &gdp_bh); +if (!gdp) + goto err_out; + +BUFFER_TRACE (gdp_bh,"get_write_access" ); + err =ext3_journal_get_write_access (handle, gdp_bh); +if (err) + goto err_out; + + free_blocks =le16_to_cpu (gdp->bg_free_blocks_count); + sbi =EXT3_SB (sb); + +/* Walk through the whole group */ +while (start < max) { + + start =bitmap_search_next_usable_block (start, bitmap_bh, max); +if (start <0 ) +break ; + next = start; + +/* +* Allocate contiguous free extents by setting bits in the +* block bitmap +*/ +while (next < max + &&claim_block (sb_bgl_lock (sbi, group), + next, bitmap_bh)) { + next++; + } + +/* We did not claim any blocks */ +if (next == start) +continue ; + + discard_block = (ext3_fsblk_t )start + +ext3_group_first_block_no (sb, group); + +/* Update counters */ +spin_lock (sb_bgl_lock (sbi, group)); +le16_add_cpu (&gdp->bg_free_blocks_count, start - next); +spin_unlock (sb_bgl_lock (sbi, group)); +percpu_counter_sub (&sbi->s_freeblocks_counter, next - start); + +/* Do not issue a TRIM on extents smaller than minblocks */ +if ((next - start) < minblocks) + goto free_extent; + +/* Send the TRIM command down to the device */ + ret =sb_issue_discard (sb, discard_block, next - start); + count += (next - start); + +free_extent: + freed =0 ; + +/* +* Clear bits in the bitmap +*/ +for (bit = start; bit < next; bit++) { +BUFFER_TRACE (bitmap_bh,"clear bit" ); +if (!ext3_clear_bit_atomic (sb_bgl_lock (sbi, group), + bit, bitmap_bh->b_data)) { +ext3_error (sb, __func__, +"bit already cleared for block " E3FSBLK , + (unsigned long )bit); +BUFFER_TRACE (bitmap_bh,"bit already cleared" ); + }else { + freed++; + } + } + +/* Update couters */ +spin_lock (sb_bgl_lock (sbi, group)); +le16_add_cpu (&gdp->bg_free_blocks_count, freed); +spin_unlock (sb_bgl_lock (sbi, group)); +percpu_counter_add (&sbi->s_freeblocks_counter, next - start); + + start = next; + +if (ret <0 ) { +if (ret == -EOPNOTSUPP ) { +ext3_warning (sb, __func__, +"discard not supported!" ); + count = ret; +break ; + } + err = ret; +break ; + } + +if (signal_pending (current)) { + count = -ERESTARTSYS ; +break ; + } + +cond_resched (); + +/* No more suitable extents */ +if ((free_blocks - count) < minblocks) +break ; + } + +/* We dirtied the bitmap block */ +BUFFER_TRACE (bitmap_bh,"dirtied bitmap block" ); + err =ext3_journal_dirty_metadata (handle, bitmap_bh); + +/* And the group descriptor block */ +BUFFER_TRACE (gdp_bh,"dirtied group descriptor block" ); + ret =ext3_journal_dirty_metadata (handle, gdp_bh); +if (!err) + err = ret; + +ext3_debug ("trimmed %d blocks in the group %d\n" , + count, group); + +err_out: +if (err) { +ext3_std_error (sb, err); + count = err; + } + +ext3_journal_stop (handle); +brelse (bitmap_bh); + +return count; +} + +/** +* ext3_trim_fs() -- trim ioctl handle function +* @sb: superblock for filesystem +* @start: First Byte to trim +* @len: number of Bytes to trim from start +* @minlen: minimum extent length in Bytes +* +* ext3_trim_fs goes through all allocation groups containing Bytes from +* start to start+len. For each such a group ext3_trim_all_free function +* is invoked to trim all free space. +*/ +int ext3_trim_fs (struct super_block *sb,uint64_t start,uint64_t len, +uint64_t minlen) +{ +ext3_grpblk_t last_block, first_block, free_blocks; +unsigned long long first_group, last_group; +unsigned long group, ngroups; +struct ext3_group_desc *gdp; +struct ext3_super_block *es; +int ret =0 ; + + start >>= sb->s_blocksize_bits; + len >>= sb->s_blocksize_bits; + minlen >>= sb->s_blocksize_bits; + +if (unlikely (minlen >EXT3_BLOCKS_PER_GROUP (sb))) +return -EINVAL ; + + es =EXT3_SB (sb)->s_es; + ngroups =EXT3_SB (sb)->s_groups_count; +smp_rmb (); + +/* Determine first and last group to examine based on start and len */ + first_group = (start -le32_to_cpu (es->s_first_data_block)) / +EXT3_BLOCKS_PER_GROUP (sb); + last_group = (start + len -le32_to_cpu (es->s_first_data_block)) / +EXT3_BLOCKS_PER_GROUP (sb); + last_group = (last_group > ngroups -1 ) ? ngroups -1 : last_group; + +if (first_group > last_group) +return -EINVAL ; + + first_block = (start -le32_to_cpu (es->s_first_data_block)) % +EXT3_BLOCKS_PER_GROUP (sb); + last_block =EXT3_BLOCKS_PER_GROUP (sb); + +for (group = first_group; group <= last_group; group++) { + + gdp =ext3_get_group_desc (sb, group,NULL ); +if (!gdp) +break ; + + free_blocks =le16_to_cpu (gdp->bg_free_blocks_count); +if (free_blocks < minlen) +continue ; + +if (len >=EXT3_BLOCKS_PER_GROUP (sb)) + len -= (EXT3_BLOCKS_PER_GROUP (sb) - first_block); +else + last_block = len; + + ret =ext3_trim_all_free (sb, group, first_block, + last_block, minlen); +if (ret <0 ) +break ; + + first_block =0 ; + } + +if (ret >=0 ) + ret =0 ; + +return ret; +}
fs/ext3/super.c +1 -0
@@ -797,6 +797,7 @@ static const struct super_operations ext3_sops = { .quota_write = ext3_quota_write, #endif .bdev_try_to_free_page = bdev_try_to_free_page, + .trim_fs = ext3_trim_fs, }; static const struct export_operations ext3_export_ops = {
include/linux/ext3_fs.h +1 -0
@@ -857,6 +857,7 @@ extern struct ext3_group_desc * ext3_get_group_desc(struct super_block * sb,extern int ext3_should_retry_alloc (struct super_block *sb,int *retries);extern void ext3_init_block_alloc_info (struct inode *);extern void ext3_rsv_window_add (struct super_block *sb,struct ext3_reserve_window_node *rsv); +extern int ext3_trim_fs (struct super_block *,uint64_t ,uint64_t ,uint64_t );/* dir.c */ extern int ext3_check_dir_entry(const char *, struct inode *,
Signature · 1 line
1.7.2.1
PATCH 3/3 Add batched discard support for ext4
In reply to Lukas CzernerWalk through allocation groups and trim all free extents. It can be invoked through FITRIM ioctl on the file system. The main idea is to provide a way to trim the whole file system if needed, since some SSD's may suffer from performance loss after the whole device was filled (it does not mean that fs is full!).
It search for free extents in allocation groups specified by Byte range start -> start+len. When the free extent is within this range, blocks are marked as used and then trimmed. Afterwards these blocks are marked as free in per-group bitmap.
Since fstrim is a long operation it is good to have an ability to interrupt it by a signal. This was added by Dmitry Monakhov. Thanks Dimitry.
--- fs/ext4/ext4.h | 2 + fs/ext4/mballoc.c | 200 +++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/ext4/super.c | 1 + 3 files changed, 203 insertions(+), 0 deletions(-)
fs/ext4/ext4.h +2 -0
@@ -1558,6 +1558,8 @@ extern int ext4_mb_add_groupinfo(struct super_block *sb,extern int ext4_mb_get_buddy_cache_lock (struct super_block *,ext4_group_t );extern void ext4_mb_put_buddy_cache_lock (struct super_block *,ext4_group_t ,int ); +extern int ext4_trim_fs (struct super_block *,uint64_t ,uint64_t ,uint64_t ); +/* inode.c */ struct buffer_head *ext4_getblk (handle_t *,struct inode *,ext4_lblk_t ,int ,int *);
fs/ext4/mballoc.c +200 -0
203 lines not on this page · raw message
fs/ext4/super.c +1 -0
@@ -1114,6 +1114,7 @@ static const struct super_operations ext4_sops = { .quota_write = ext4_quota_write, #endif .bdev_try_to_free_page = bdev_try_to_free_page, + .trim_fs = ext4_trim_fs }; static const struct super_operations ext4_nojournal_sops = {
Signature · 1 line
1.7.2.1