Hello,
here's Lukas's series with a few minor fixes in error handling in the first
patch and updated changelog of the second patch. I have these patches in my
tree so please speak up if you disagree (otherwise they'll go to Linus in the
next merge window).
Honza
From: Lukas Czerner <[email protected]>
The ioctl takes fstrim_range structure (defined in include/linux/fs.h) as an
argument specifying a range of filesystem to trim and the minimum size of an
continguous extent to trim. After the FITRIM is done, the number of bytes
passed from the filesystem down the block stack to the device for potential
discard is stored in fstrim_range.len. This number is a maximum discard amount
from the storage device's perspective, because FITRIM called repeatedly will
keep sending the same sectors for discard. fstrim_range.len will report the
same potential discard bytes each time, but only sectors which had been written
to between the discards would actually be discarded by the storage device.
Further, the kernel block layer reserves the right to adjust the discard ranges
to fit raid stripe geometry, non-trim capable devices in a LVM setup, etc.
These reductions would not be reflected in fstrim_range.len.
Thus fstrim_range.len can give the user better insight on how much storage
space has potentially been released for wear-leveling, but it needs to be one
of only one criteria the userspace tools take into account when trying to
optimize calls to FITRIM.
Thanks to Greg Freemyer <[email protected]> for better commit message.
Signed-off-by: Lukas Czerner <[email protected]>
Signed-off-by: Jan Kara <[email protected]>
---
fs/ext3/ioctl.c | 22 ++++++++++++++++++++++
1 files changed, 22 insertions(+), 0 deletions(-)
diff --git a/fs/ext3/ioctl.c b/fs/ext3/ioctl.c
index 8897481..fc080dd 100644
--- a/fs/ext3/ioctl.c
+++ b/fs/ext3/ioctl.c
@@ -276,7 +276,29 @@ group_add_out:
mnt_drop_write(filp->f_path.mnt);
return err;
}
+ case FITRIM: {
+ struct super_block *sb = inode->i_sb;
+ struct fstrim_range range;
+ int ret = 0;
+
+ if (!capable(CAP_SYS_ADMIN))
+ return -EPERM;
+
+ if (copy_from_user(&range, (struct fstrim_range *)arg,
+ sizeof(range)))
+ return -EFAULT;
+
+ ret = ext3_trim_fs(sb, &range);
+ if (ret < 0)
+ return ret;
+
+ if (copy_to_user((struct fstrim_range *)arg, &range,
+ sizeof(range)))
+ return -EFAULT;
+
+ return 0;
+ }
default:
return -ENOTTY;
--
1.7.1
From: Lukas Czerner <[email protected]>
Walk 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.
[JK: Fixed up error handling]
Signed-off-by: Lukas Czerner <[email protected]>
Reviewed-by: Jan Kara <[email protected]>
Reviewed-by: Dmitry Monakhov <[email protected]>
Signed-off-by: Jan Kara <[email protected]>
---
fs/ext3/balloc.c | 257 +++++++++++++++++++++++++++++++++++++++++++++++
include/linux/ext3_fs.h | 1 +
2 files changed, 258 insertions(+), 0 deletions(-)
diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index b3db226..ae88960 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -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
@@ -39,6 +40,23 @@
#define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
+/*
+ * Calculate the block group number and offset, given a block number
+ */
+void ext3_get_group_no_and_offset(struct super_block *sb, ext3_fsblk_t blocknr,
+ unsigned long *blockgrpp, ext3_grpblk_t *offsetp)
+{
+ struct ext3_super_block *es = EXT3_SB(sb)->s_es;
+ ext3_grpblk_t offset;
+
+ blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
+ offset = do_div(blocknr, EXT3_BLOCKS_PER_GROUP(sb));
+ if (offsetp)
+ *offsetp = offset;
+ if (blockgrpp)
+ *blockgrpp = blocknr;
+}
+
/**
* ext3_get_group_desc() -- load group descriptor from disk
* @sb: super block
@@ -1885,3 +1903,242 @@ 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, free_blocks, bit, freed, count = 0;
+ ext3_fsblk_t discard_block;
+ struct ext3_sb_info *sbi;
+ struct buffer_head *gdp_bh, *bitmap_bh = NULL;
+ struct ext3_group_desc *gdp;
+ int err = 0, ret = 0;
+
+ /*
+ * We will update one block bitmap, and one group descriptor
+ */
+ handle = ext3_journal_start_sb(sb, 2);
+ if (IS_ERR(handle))
+ return PTR_ERR(handle);
+
+ bitmap_bh = read_block_bitmap(sb, group);
+ if (!bitmap_bh) {
+ err = -EIO;
+ 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) {
+ err = -EIO;
+ 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 */
+ err = sb_issue_discard(sb, discard_block, next - start,
+ GFP_NOFS, 0);
+ 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, freed);
+
+ start = next;
+ if (err < 0) {
+ if (err != -EOPNOTSUPP)
+ ext3_warning(sb, __func__, "Discard command "
+ "returned error %d\n", err);
+ break;
+ }
+
+ if (fatal_signal_pending(current)) {
+ err = -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)
+ 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, struct fstrim_range *range)
+{
+ ext3_grpblk_t last_block, first_block, free_blocks;
+ unsigned long first_group, last_group;
+ unsigned long group, ngroups;
+ struct ext3_group_desc *gdp;
+ struct ext3_super_block *es;
+ uint64_t start, len, minlen, trimmed;
+ int ret = 0;
+
+ start = range->start >> sb->s_blocksize_bits;
+ len = range->len >> sb->s_blocksize_bits;
+ minlen = range->minlen >> sb->s_blocksize_bits;
+ trimmed = 0;
+
+ 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 */
+ ext3_get_group_no_and_offset(sb, (ext3_fsblk_t) start,
+ &first_group, &first_block);
+ ext3_get_group_no_and_offset(sb, (ext3_fsblk_t) (start + len),
+ &last_group, &last_block);
+ last_group = (last_group > ngroups - 1) ? ngroups - 1 : last_group;
+ last_block = EXT3_BLOCKS_PER_GROUP(sb);
+
+ if (first_group > last_group)
+ return -EINVAL;
+
+ 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;
+
+ trimmed += ret;
+ first_block = 0;
+ }
+
+ if (ret >= 0)
+ ret = 0;
+
+ range->len = trimmed * sb->s_blocksize;
+
+ return ret;
+}
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 6ce1bca..a443965 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -856,6 +856,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 *sb, struct fstrim_range *range);
/* dir.c */
extern int ext3_check_dir_entry(const char *, struct inode *,
--
1.7.1
On Wed, 24 Nov 2010, Jan Kara wrote:
> From: Lukas Czerner <[email protected]>
>
> Walk 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.
>
> [JK: Fixed up error handling]
>
> Signed-off-by: Lukas Czerner <[email protected]>
> Reviewed-by: Jan Kara <[email protected]>
> Reviewed-by: Dmitry Monakhov <[email protected]>
> Signed-off-by: Jan Kara <[email protected]>
> ---
> fs/ext3/balloc.c | 257 +++++++++++++++++++++++++++++++++++++++++++++++
> include/linux/ext3_fs.h | 1 +
> 2 files changed, 258 insertions(+), 0 deletions(-)
>
> diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
> index b3db226..ae88960 100644
> --- a/fs/ext3/balloc.c
> +++ b/fs/ext3/balloc.c
> @@ -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
> @@ -39,6 +40,23 @@
>
> #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
>
> +/*
> + * Calculate the block group number and offset, given a block number
> + */
> +void ext3_get_group_no_and_offset(struct super_block *sb, ext3_fsblk_t blocknr,
> + unsigned long *blockgrpp, ext3_grpblk_t *offsetp)
> +{
> + struct ext3_super_block *es = EXT3_SB(sb)->s_es;
> + ext3_grpblk_t offset;
> +
> + blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
> + offset = do_div(blocknr, EXT3_BLOCKS_PER_GROUP(sb));
> + if (offsetp)
> + *offsetp = offset;
> + if (blockgrpp)
> + *blockgrpp = blocknr;
> +}
> +
> /**
> * ext3_get_group_desc() -- load group descriptor from disk
> * @sb: super block
> @@ -1885,3 +1903,242 @@ 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, free_blocks, bit, freed, count = 0;
> + ext3_fsblk_t discard_block;
> + struct ext3_sb_info *sbi;
> + struct buffer_head *gdp_bh, *bitmap_bh = NULL;
> + struct ext3_group_desc *gdp;
> + int err = 0, ret = 0;
> +
> + /*
> + * We will update one block bitmap, and one group descriptor
> + */
> + handle = ext3_journal_start_sb(sb, 2);
> + if (IS_ERR(handle))
> + return PTR_ERR(handle);
> +
> + bitmap_bh = read_block_bitmap(sb, group);
> + if (!bitmap_bh) {
> + err = -EIO;
> + 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) {
> + err = -EIO;
> + 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 */
> + err = sb_issue_discard(sb, discard_block, next - start,
> + GFP_NOFS, 0);
> + 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, freed);
> +
> + start = next;
> + if (err < 0) {
> + if (err != -EOPNOTSUPP)
> + ext3_warning(sb, __func__, "Discard command "
> + "returned error %d\n", err);
Maybe we can remove this warning completely and let use-space utility
handle and print out error message ?
> + break;
> + }
> +
> + if (fatal_signal_pending(current)) {
> + err = -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)
> + 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, struct fstrim_range *range)
> +{
> + ext3_grpblk_t last_block, first_block, free_blocks;
> + unsigned long first_group, last_group;
> + unsigned long group, ngroups;
> + struct ext3_group_desc *gdp;
> + struct ext3_super_block *es;
> + uint64_t start, len, minlen, trimmed;
> + int ret = 0;
> +
> + start = range->start >> sb->s_blocksize_bits;
> + len = range->len >> sb->s_blocksize_bits;
> + minlen = range->minlen >> sb->s_blocksize_bits;
> + trimmed = 0;
> +
> + 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 */
> + ext3_get_group_no_and_offset(sb, (ext3_fsblk_t) start,
> + &first_group, &first_block);
> + ext3_get_group_no_and_offset(sb, (ext3_fsblk_t) (start + len),
> + &last_group, &last_block);
> + last_group = (last_group > ngroups - 1) ? ngroups - 1 : last_group;
> + last_block = EXT3_BLOCKS_PER_GROUP(sb);
> +
> + if (first_group > last_group)
> + return -EINVAL;
> +
> + 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;
> +
> + trimmed += ret;
> + first_block = 0;
> + }
> +
> + if (ret >= 0)
> + ret = 0;
> +
> + range->len = trimmed * sb->s_blocksize;
> +
> + return ret;
> +}
> diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
> index 6ce1bca..a443965 100644
> --- a/include/linux/ext3_fs.h
> +++ b/include/linux/ext3_fs.h
> @@ -856,6 +856,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 *sb, struct fstrim_range *range);
>
> /* dir.c */
> extern int ext3_check_dir_entry(const char *, struct inode *,
>
--
On Wed 24-11-10 15:56:33, Lukas Czerner wrote:
> On Wed, 24 Nov 2010, Jan Kara wrote:
> > + if (err < 0) {
> > + if (err != -EOPNOTSUPP)
> > + ext3_warning(sb, __func__, "Discard command "
> > + "returned error %d\n", err);
>
> Maybe we can remove this warning completely and let use-space utility
> handle and print out error message ?
We could but at this point something strange is happening (ENOMEM, EIO,
or something like that) so issuing a warning makes some sense. So I'd be
maybe slightly in favor of keeping the warning.
Honza
--
Jan Kara <[email protected]>
SUSE Labs, CR
On Wed, 24 Nov 2010, Jan Kara wrote:
> From: Lukas Czerner <[email protected]>
>
> Walk 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.
>
> [JK: Fixed up error handling]
>
> Signed-off-by: Lukas Czerner <[email protected]>
> Reviewed-by: Jan Kara <[email protected]>
> Reviewed-by: Dmitry Monakhov <[email protected]>
> Signed-off-by: Jan Kara <[email protected]>
> ---
> fs/ext3/balloc.c | 257 +++++++++++++++++++++++++++++++++++++++++++++++
> include/linux/ext3_fs.h | 1 +
> 2 files changed, 258 insertions(+), 0 deletions(-)
>
> diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
> index b3db226..ae88960 100644
> --- a/fs/ext3/balloc.c
> +++ b/fs/ext3/balloc.c
> @@ -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
> @@ -39,6 +40,23 @@
>
> #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
>
> +/*
> + * Calculate the block group number and offset, given a block number
> + */
> +void ext3_get_group_no_and_offset(struct super_block *sb, ext3_fsblk_t blocknr,
> + unsigned long *blockgrpp, ext3_grpblk_t *offsetp)
> +{
> + struct ext3_super_block *es = EXT3_SB(sb)->s_es;
> + ext3_grpblk_t offset;
> +
> + blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
> + offset = do_div(blocknr, EXT3_BLOCKS_PER_GROUP(sb));
> + if (offsetp)
> + *offsetp = offset;
> + if (blockgrpp)
> + *blockgrpp = blocknr;
> +}
> +
> /**
> * ext3_get_group_desc() -- load group descriptor from disk
> * @sb: super block
> @@ -1885,3 +1903,242 @@ 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, free_blocks, bit, freed, count = 0;
> + ext3_fsblk_t discard_block;
> + struct ext3_sb_info *sbi;
> + struct buffer_head *gdp_bh, *bitmap_bh = NULL;
> + struct ext3_group_desc *gdp;
> + int err = 0, ret = 0;
> +
> + /*
> + * We will update one block bitmap, and one group descriptor
> + */
> + handle = ext3_journal_start_sb(sb, 2);
> + if (IS_ERR(handle))
> + return PTR_ERR(handle);
> +
> + bitmap_bh = read_block_bitmap(sb, group);
> + if (!bitmap_bh) {
> + err = -EIO;
> + 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) {
> + err = -EIO;
> + 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 */
> + err = sb_issue_discard(sb, discard_block, next - start,
> + GFP_NOFS, 0);
> + 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, freed);
> +
> + start = next;
> + if (err < 0) {
> + if (err != -EOPNOTSUPP)
> + ext3_warning(sb, __func__, "Discard command "
> + "returned error %d\n", err);
> + break;
> + }
> +
> + if (fatal_signal_pending(current)) {
> + err = -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)
> + 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, struct fstrim_range *range)
> +{
> + ext3_grpblk_t last_block, first_block, free_blocks;
> + unsigned long first_group, last_group;
> + unsigned long group, ngroups;
> + struct ext3_group_desc *gdp;
> + struct ext3_super_block *es;
> + uint64_t start, len, minlen, trimmed;
> + int ret = 0;
We probably need to add this:
ext3_fsblk_t blocks_count = le32_to_cpu(EXT3_SB(sb)->s_es->s_blocks_count);
> +
> + start = range->start >> sb->s_blocksize_bits;
> + len = range->len >> sb->s_blocksize_bits;
> + minlen = range->minlen >> sb->s_blocksize_bits;
> + trimmed = 0;
and this:
if (len > blocks_count)
len = blocks_count - start;
Because when determining last group through ext3_get_group_no_and_offset()
the result may be wrong in cases when range->start and range-len are too
big, because it may overflow when summing up those two numbers.
> +
> + 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 */
> + ext3_get_group_no_and_offset(sb, (ext3_fsblk_t) start,
> + &first_group, &first_block);
> + ext3_get_group_no_and_offset(sb, (ext3_fsblk_t) (start + len),
^^^^^^^^^^^^^
here
overflow may occur.
> + &last_group, &last_block);
> + last_group = (last_group > ngroups - 1) ? ngroups - 1 : last_group;
> + last_block = EXT3_BLOCKS_PER_GROUP(sb);
> +
> + if (first_group > last_group)
> + return -EINVAL;
> +
> + 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;
> +
> + trimmed += ret;
> + first_block = 0;
> + }
> +
> + if (ret >= 0)
> + ret = 0;
> +
> + range->len = trimmed * sb->s_blocksize;
> +
> + return ret;
> +}
> diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
> index 6ce1bca..a443965 100644
> --- a/include/linux/ext3_fs.h
> +++ b/include/linux/ext3_fs.h
> @@ -856,6 +856,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 *sb, struct fstrim_range *range);
>
> /* dir.c */
> extern int ext3_check_dir_entry(const char *, struct inode *,
>
--
On 2010-11-25, at 07:27, Lukas Czerner wrote:
>> Walk 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!).
One question I have is why a major change like this is being done in ext3 instead of only in ext4? There are a lot of ext4 features that _could_ be included in ext3 (basically all of them), but the request from the rest of the kernel developers was to leave ext3 with minimal changes (for continued stability), and put all of the major changes into ext4.
With the current ext4 code's performance and feature advantages, and widespread use in newer distros, I don't think there is a good reason to make major modifications to ext3. It should remain as the stable legacy filesystem for some number of releases, and then possibly we should just remove one or both of ext2 and ext3 and use the ext4 code for both.
Given that Google is running ext4 in no-journal mode (i.e. ext2-like) on many thousands of machines, and getting _much_ better performance than the old ext2 code, it doesn't make sense to continue investing so much maintenance effort into ext2 and ext3.
Cheers, Andreas
On Thu, 25 Nov 2010, Andreas Dilger wrote:
> On 2010-11-25, at 07:27, Lukas Czerner wrote:
> >> Walk 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!).
>
> One question I have is why a major change like this is being done in ext3 instead of only in ext4? There are a lot of ext4 features that _could_ be included in ext3 (basically all of them), but the request from the rest of the kernel developers was to leave ext3 with minimal changes (for continued stability), and put all of the major changes into ext4.
You're right that ext3 should be "closed" for major (intrusive) changes,
however this is not a major change at all. It interacts with ext3 code
just very little and it is very well separated. Basically, it is dead
code until FITRIM ioctl is done.
Given that there are still a lot of people using ext3, and SSD's are
here right now, we should consider providing that feature to ext3 as
well. When you comprehend this features intrusiveness (well separated)
and it's usefulness into consideration, I think that the ratio is well
in favour of including this into ext3.
>
> With the current ext4 code's performance and feature advantages, and widespread use in newer distros, I don't think there is a good reason to make major modifications to ext3. It should remain as the stable legacy filesystem for some number of releases, and then possibly we should just remove one or both of ext2 and ext3 and use the ext4 code for both.
>
> Given that Google is running ext4 in no-journal mode (i.e. ext2-like) on many thousands of machines, and getting _much_ better performance than the old ext2 code, it doesn't make sense to continue investing so much maintenance effort into ext2 and ext3.
>
> Cheers, Andreas
Thanks!
-Lukas
On 2010-11-26, at 01:01, Lukas Czerner wrote:
> On Thu, 25 Nov 2010, Andreas Dilger wrote:
>> One question I have is why a change like this is being done in ext3 instead of only in ext4? There are a lot of ext4 features that _could_ be included in ext3 (basically all of them), but the request from the rest of the kernel developers was to leave ext3 with minimal changes (for continued stability), and put all of the major changes into ext4.
>
> You're right that ext3 should be "closed" for major (intrusive) changes,
> however this is not a major change at all. It interacts with ext3 code
> just very little and it is very well separated. Basically, it is dead
> code until FITRIM ioctl is done.
I don't want to pick on this patch, per se, but if someone is installing a new filesystem on an SSD with a new kernel, they could just as easily use ext4 for that instead of ext3, and they likely should use ext4 because of performance. Either they are using ext3 because they don't want any changes (in which case they also don't want this one), or if it is a new filesystem on a new device they can as easily use ext4.
Since this code is only going to end up in new kernels, this isn't about what users are using for legacy systems where only ext3 is available.
Cheers, Andreas
Hi,
On Thu 25-11-10 15:27:09, Lukas Czerner wrote:
> > +/**
> > + * 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, struct fstrim_range *range)
> > +{
> > + ext3_grpblk_t last_block, first_block, free_blocks;
> > + unsigned long first_group, last_group;
> > + unsigned long group, ngroups;
> > + struct ext3_group_desc *gdp;
> > + struct ext3_super_block *es;
> > + uint64_t start, len, minlen, trimmed;
> > + int ret = 0;
> We probably need to add this:
>
> ext3_fsblk_t blocks_count = le32_to_cpu(EXT3_SB(sb)->s_es->s_blocks_count);
>
> > +
> > + start = range->start >> sb->s_blocksize_bits;
> > + len = range->len >> sb->s_blocksize_bits;
> > + minlen = range->minlen >> sb->s_blocksize_bits;
> > + trimmed = 0;
> and this:
>
> if (len > blocks_count)
> len = blocks_count - start;
Thanks for letting me know. The above could go negative if start is too
big. So I've ended up with checks:
+ if (start >= max_blks)
+ goto out;
+ if (start + len > max_blks)
+ len = max_blks - start;
Honza
--
Jan Kara <[email protected]>
SUSE Labs, CR