* Re: [PATCH] jbd2: Remove special jbd2 slabs
From: Tal Zussman @ 2026-05-27 20:33 UTC (permalink / raw)
To: Matthew Wilcox (Oracle), Theodore Ts'o
Cc: Jan Kara, linux-ext4, linux-fsdevel, Mike Rapoport (Microsoft),
Vlastimil Babka
In-Reply-To: <20260525201321.21717-1-willy@infradead.org>
On 5/25/26 4:13 PM, Matthew Wilcox (Oracle) wrote:
Hi,
One small comment below.
> When jbd2 was originally written, kmalloc() would not guarantee alignment
> for the requested memory. Since commit 59bb47985c1d in 2019, kmalloc
> has guaranteed natural alignment for power-of-two allocations. We can
> now remove the jbd2 special slabs and just use kmalloc() directly.
>
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> ---
> fs/jbd2/commit.c | 8 ++-
> fs/jbd2/journal.c | 121 ++----------------------------------------
> fs/jbd2/transaction.c | 8 +--
> include/linux/jbd2.h | 3 --
> 4 files changed, 11 insertions(+), 129 deletions(-)
>
> diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
> index 38f318bb4279..2e8dbc4547bb 100644
> --- a/fs/jbd2/commit.c
> +++ b/fs/jbd2/commit.c
> @@ -514,10 +514,8 @@ void jbd2_journal_commit_transaction(journal_t *journal)
> * leave undo-committed data.
> */
> if (jh->b_committed_data) {
> - struct buffer_head *bh = jh2bh(jh);
> -
> spin_lock(&jh->b_state_lock);
> - jbd2_free(jh->b_committed_data, bh->b_size);
> + kfree(jh->b_committed_data);
> jh->b_committed_data = NULL;
> spin_unlock(&jh->b_state_lock);
> }
> @@ -978,7 +976,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
> * its triggers if they exist, so we can clear that too.
> */
> if (jh->b_committed_data) {
> - jbd2_free(jh->b_committed_data, bh->b_size);
> + kfree(jh->b_committed_data);
> jh->b_committed_data = NULL;
> if (jh->b_frozen_data) {
> jh->b_committed_data = jh->b_frozen_data;
> @@ -986,7 +984,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
> jh->b_frozen_triggers = NULL;
> }
> } else if (jh->b_frozen_data) {
> - jbd2_free(jh->b_frozen_data, bh->b_size);
> + kfree(jh->b_frozen_data);
> jh->b_frozen_data = NULL;
> jh->b_frozen_triggers = NULL;
> }
> diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
> index a6616380ce38..ad10c8a92fa0 100644
> --- a/fs/jbd2/journal.c
> +++ b/fs/jbd2/journal.c
> @@ -95,8 +95,6 @@ EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
> EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
> EXPORT_SYMBOL(jbd2_inode_cache);
>
> -static int jbd2_journal_create_slab(size_t slab_size);
> -
> #ifdef CONFIG_JBD2_DEBUG
> void __jbd2_debug(int level, const char *file, const char *func,
> unsigned int line, const char *fmt, ...)
> @@ -385,10 +383,10 @@ int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
> goto escape_done;
>
> spin_unlock(&jh_in->b_state_lock);
> - tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS | __GFP_NOFAIL);
> + tmp = kmalloc(bh_in->b_size, GFP_NOFS | __GFP_NOFAIL);
> spin_lock(&jh_in->b_state_lock);
> if (jh_in->b_frozen_data) {
> - jbd2_free(tmp, bh_in->b_size);
> + kfree(tmp);
> goto copy_done;
> }
>
> @@ -2063,14 +2061,6 @@ EXPORT_SYMBOL(jbd2_journal_update_sb_errno);
> int jbd2_journal_load(journal_t *journal)
> {
> int err;
> - journal_superblock_t *sb = journal->j_superblock;
> -
> - /*
> - * Create a slab for this blocksize
> - */
> - err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize));
> - if (err)
> - return err;
>
> /* Let the recovery code check whether it needs to recover any
> * data from the journal. */
> @@ -2698,108 +2688,6 @@ size_t journal_tag_bytes(journal_t *journal)
> return sz - sizeof(__u32);
> }
>
> -/*
> - * JBD memory management
> - *
> - * These functions are used to allocate block-sized chunks of memory
> - * used for making copies of buffer_head data. Very often it will be
> - * page-sized chunks of data, but sometimes it will be in
> - * sub-page-size chunks. (For example, 16k pages on Power systems
> - * with a 4k block file system.) For blocks smaller than a page, we
> - * use a SLAB allocator. There are slab caches for each block size,
> - * which are allocated at mount time, if necessary, and we only free
> - * (all of) the slab caches when/if the jbd2 module is unloaded. For
> - * this reason we don't need to a mutex to protect access to
> - * jbd2_slab[] allocating or releasing memory; only in
> - * jbd2_journal_create_slab().
> - */
> -#define JBD2_MAX_SLABS 8
> -static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS];
> -
> -static const char *jbd2_slab_names[JBD2_MAX_SLABS] = {
> - "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k",
> - "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k"
> -};
> -
> -
> -static void jbd2_journal_destroy_slabs(void)
> -{
> - int i;
> -
> - for (i = 0; i < JBD2_MAX_SLABS; i++) {
> - kmem_cache_destroy(jbd2_slab[i]);
> - jbd2_slab[i] = NULL;
> - }
> -}
> -
> -static int jbd2_journal_create_slab(size_t size)
> -{
> - static DEFINE_MUTEX(jbd2_slab_create_mutex);
> - int i = order_base_2(size) - 10;
> - size_t slab_size;
> -
> - if (size == PAGE_SIZE)
> - return 0;
> -
> - if (i >= JBD2_MAX_SLABS)
> - return -EINVAL;
> -
> - if (unlikely(i < 0))
> - i = 0;
> - mutex_lock(&jbd2_slab_create_mutex);
> - if (jbd2_slab[i]) {
> - mutex_unlock(&jbd2_slab_create_mutex);
> - return 0; /* Already created */
> - }
> -
> - slab_size = 1 << (i+10);
> - jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size,
> - slab_size, 0, NULL);
> - mutex_unlock(&jbd2_slab_create_mutex);
> - if (!jbd2_slab[i]) {
> - printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n");
> - return -ENOMEM;
> - }
> - return 0;
> -}
> -
> -static struct kmem_cache *get_slab(size_t size)
> -{
> - int i = order_base_2(size) - 10;
> -
> - BUG_ON(i >= JBD2_MAX_SLABS);
> - if (unlikely(i < 0))
> - i = 0;
> - BUG_ON(jbd2_slab[i] == NULL);
> - return jbd2_slab[i];
> -}
> -
> -void *jbd2_alloc(size_t size, gfp_t flags)
> -{
> - void *ptr;
> -
> - BUG_ON(size & (size-1)); /* Must be a power of 2 */
> -
> - if (size < PAGE_SIZE)
> - ptr = kmem_cache_alloc(get_slab(size), flags);
> - else
> - ptr = (void *)__get_free_pages(flags, get_order(size));
> -
> - /* Check alignment; SLUB has gotten this wrong in the past,
> - * and this can lead to user data corruption! */
> - BUG_ON(((unsigned long) ptr) & (size-1));
> -
> - return ptr;
> -}
> -
> -void jbd2_free(void *ptr, size_t size)
> -{
> - if (size < PAGE_SIZE)
> - kmem_cache_free(get_slab(size), ptr);
> - else
> - free_pages((unsigned long)ptr, get_order(size));
> -};
> -
> /*
> * Journal_head storage management
> */
> @@ -2977,11 +2865,11 @@ static void journal_release_journal_head(struct journal_head *jh, size_t b_size)
I think the b_size parameter can be removed from journal_release_journal_head()
and its single caller now.
> {
> if (jh->b_frozen_data) {
> printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
> - jbd2_free(jh->b_frozen_data, b_size);
> + kfree(jh->b_frozen_data);
> }
> if (jh->b_committed_data) {
> printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
> - jbd2_free(jh->b_committed_data, b_size);
> + kfree(jh->b_committed_data);
> }
> journal_free_journal_head(jh);
> }
> @@ -3142,7 +3030,6 @@ static void jbd2_journal_destroy_caches(void)
> jbd2_journal_destroy_handle_cache();
> jbd2_journal_destroy_inode_cache();
> jbd2_journal_destroy_transaction_cache();
> - jbd2_journal_destroy_slabs();
> }
>
> static int __init journal_init(void)
> diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
> index 4885903bbd10..48ddb566d12d 100644
> --- a/fs/jbd2/transaction.c
> +++ b/fs/jbd2/transaction.c
> @@ -1131,7 +1131,7 @@ do_get_write_access(handle_t *handle, struct journal_head *jh,
> if (!frozen_buffer) {
> JBUFFER_TRACE(jh, "allocate memory for buffer");
> spin_unlock(&jh->b_state_lock);
> - frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size,
> + frozen_buffer = kmalloc(jh2bh(jh)->b_size,
> GFP_NOFS | __GFP_NOFAIL);
> goto repeat;
> }
> @@ -1159,7 +1159,7 @@ do_get_write_access(handle_t *handle, struct journal_head *jh,
>
> out:
> if (unlikely(frozen_buffer)) /* It's usually NULL */
> - jbd2_free(frozen_buffer, bh->b_size);
> + kfree(frozen_buffer);
>
> JBUFFER_TRACE(jh, "exit");
> return error;
> @@ -1424,7 +1424,7 @@ int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
>
> repeat:
> if (!jh->b_committed_data)
> - committed_data = jbd2_alloc(jh2bh(jh)->b_size,
> + committed_data = kmalloc(jh2bh(jh)->b_size,
> GFP_NOFS|__GFP_NOFAIL);
>
> spin_lock(&jh->b_state_lock);
> @@ -1445,7 +1445,7 @@ int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
> out:
> jbd2_journal_put_journal_head(jh);
> if (unlikely(committed_data))
> - jbd2_free(committed_data, bh->b_size);
> + kfree(committed_data);
> return err;
> }
>
> diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
> index 7e785aa6d35d..b68561187e90 100644
> --- a/include/linux/jbd2.h
> +++ b/include/linux/jbd2.h
> @@ -63,9 +63,6 @@ void __jbd2_debug(int level, const char *file, const char *func,
> #define jbd2_debug(n, fmt, a...) no_printk(fmt, ##a)
> #endif
>
> -extern void *jbd2_alloc(size_t size, gfp_t flags);
> -extern void jbd2_free(void *ptr, size_t size);
> -
> #define JBD2_MIN_JOURNAL_BLOCKS 1024
> #define JBD2_DEFAULT_FAST_COMMIT_BLOCKS 256
>
^ permalink raw reply
* Re: [PATCH] ext4: add ext4_dir_entry_is_tail()
From: Andreas Dilger @ 2026-05-27 22:26 UTC (permalink / raw)
To: Artem Blagodarenko; +Cc: linux-ext4
In-Reply-To: <20260526233816.7654-1-ablagodarenko@thelustrecollective.com>
On May 26, 2026, at 17:38, Artem Blagodarenko <artem.blagodarenko@gmail.com> wrote:
>
> From: Artem Blagodarenko <artem.blagodarenko@gmail.com>
>
> Replace open-coded checks for directory tail entries with a call
> to ext4_dir_entry_is_tail(). This helper will also be used by
> upcoming changes.
>
> Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca <mailto:adilger@dilger.ca>>
> ---
> fs/ext4/ext4.h | 16 ++++++++++++++++
> fs/ext4/namei.c | 7 +------
> 2 files changed, 17 insertions(+), 6 deletions(-)
>
> diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
> index 94283a991e5c..01b1222b1454 100644
> --- a/fs/ext4/ext4.h
> +++ b/fs/ext4/ext4.h
> @@ -3917,6 +3917,22 @@ static inline void ext4_clear_io_unwritten_flag(ext4_io_end_t *io_end)
> io_end->flag &= ~EXT4_IO_END_UNWRITTEN;
> }
>
> +/*
> + * ext4_dir_entry_is_tail() - Check if a directory entry is a tail entry.
> + * @de: directory entry to check
> + *
> + * Returns true if @de is a directory block tail entry (checksum record).
> + */
> +static inline bool ext4_dir_entry_is_tail(struct ext4_dir_entry_2 *de)
> +{
> + struct ext4_dir_entry_tail *t = (struct ext4_dir_entry_tail *)de;
> +
> + return !t->det_reserved_zero1 &&
> + le16_to_cpu(t->det_rec_len) == sizeof(*t) &&
> + !t->det_reserved_zero2 &&
> + t->det_reserved_ft == EXT4_FT_DIR_CSUM;
> +}
> +
> extern const struct iomap_ops ext4_iomap_ops;
> extern const struct iomap_ops ext4_iomap_report_ops;
>
> diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
> index 4a47fbd8dd30..accf63fbbc79 100644
> --- a/fs/ext4/namei.c
> +++ b/fs/ext4/namei.c
> @@ -314,7 +314,6 @@ static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
> struct buffer_head *bh)
> {
> struct ext4_dir_entry_tail *t;
> - int blocksize = EXT4_BLOCK_SIZE(inode->i_sb);
>
> #ifdef PARANOID
> struct ext4_dir_entry *d, *top;
> @@ -334,11 +333,7 @@ static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
> t = EXT4_DIRENT_TAIL(bh->b_data, EXT4_BLOCK_SIZE(inode->i_sb));
> #endif
>
> - if (t->det_reserved_zero1 ||
> - (ext4_rec_len_from_disk(t->det_rec_len, blocksize) !=
> - sizeof(struct ext4_dir_entry_tail)) ||
> - t->det_reserved_zero2 ||
> - t->det_reserved_ft != EXT4_FT_DIR_CSUM)
> + if (!ext4_dir_entry_is_tail((struct ext4_dir_entry_2 *)t))
> return NULL;
>
> return t;
> --
> 2.43.7
>
Cheers, Andreas
^ permalink raw reply
* Re: [PATCH] ext4: replace ext4_dir_entry with ext4_dir_entry_2
From: Andreas Dilger @ 2026-05-27 22:28 UTC (permalink / raw)
To: Artem Blagodarenko; +Cc: Theodore Ts'o, linux-ext4
In-Reply-To: <20260526233608.7600-1-ablagodarenko@thelustrecollective.com>
On May 26, 2026, at 17:36, Artem Blagodarenko <artem.blagodarenko@gmail.com> wrote:
>
> From: Artem Blagodarenko <artem.blagodarenko@gmail.com>
>
> Replace remaining uses of struct ext4_dir_entry in namei.c
> with struct ext4_dir_entry_2.
>
> The code paths affected by this change already depend on the
> filetype feature, so using struct ext4_dir_entry_2 is
> appropriate and avoids mixing the two directory entry types
> unnecessarily.
>
> This change does not affect support for 16-bit rec_len.
>
> Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca <mailto:adilger@dilger.ca>>
> ---
> fs/ext4/namei.c | 36 ++++++++++++++++++------------------
> 1 file changed, 18 insertions(+), 18 deletions(-)
>
> diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
> index 4a47fbd8dd30..a316fc2ac41b 100644
> --- a/fs/ext4/namei.c
> +++ b/fs/ext4/namei.c
> @@ -102,7 +102,7 @@ static struct buffer_head *ext4_append(handle_t *handle,
> }
>
> static int ext4_dx_csum_verify(struct inode *inode,
> - struct ext4_dir_entry *dirent);
> + struct ext4_dir_entry_2 *dirent);
>
> /*
> * Hints to ext4_read_dirblock regarding whether we expect a directory
> @@ -128,7 +128,7 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
> unsigned int line)
> {
> struct buffer_head *bh;
> - struct ext4_dir_entry *dirent;
> + struct ext4_dir_entry_2 *dirent;
> int is_dx_block = 0;
>
> if (block >= inode->i_size >> inode->i_blkbits) {
> @@ -160,7 +160,7 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
> }
> if (!bh)
> return NULL;
> - dirent = (struct ext4_dir_entry *) bh->b_data;
> + dirent = (struct ext4_dir_entry_2 *) bh->b_data;
> /* Determine whether or not we have an index block */
> if (is_dx(inode)) {
> if (block == 0)
> @@ -317,13 +317,13 @@ static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
> int blocksize = EXT4_BLOCK_SIZE(inode->i_sb);
>
> #ifdef PARANOID
> - struct ext4_dir_entry *d, *top;
> + struct ext4_dir_entry_2 *d, *top;
>
> - d = (struct ext4_dir_entry *)bh->b_data;
> - top = (struct ext4_dir_entry *)(bh->b_data +
> + d = (struct ext4_dir_entry_2 *)bh->b_data;
> + top = (struct ext4_dir_entry_2 *)(bh->b_data +
> (blocksize - sizeof(struct ext4_dir_entry_tail)));
> while (d < top && ext4_rec_len_from_disk(d->rec_len, blocksize))
> - d = (struct ext4_dir_entry *)(((void *)d) +
> + d = (struct ext4_dir_entry_2 *)(((void *)d) +
> ext4_rec_len_from_disk(d->rec_len, blocksize));
>
> if (d != top)
> @@ -410,10 +410,10 @@ int ext4_handle_dirty_dirblock(handle_t *handle,
> }
>
> static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
> - struct ext4_dir_entry *dirent,
> + struct ext4_dir_entry_2 *dirent,
> int *offset)
> {
> - struct ext4_dir_entry *dp;
> + struct ext4_dir_entry_2 *de;
> struct dx_root_info *root;
> int count_offset;
> int blocksize = EXT4_BLOCK_SIZE(inode->i_sb);
> @@ -422,10 +422,10 @@ static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
> if (rlen == blocksize)
> count_offset = 8;
> else if (rlen == 12) {
> - dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
> - if (ext4_rec_len_from_disk(dp->rec_len, blocksize) != blocksize - 12)
> + de = (struct ext4_dir_entry_2 *)(((void *)dirent) + 12);
> + if (ext4_rec_len_from_disk(de->rec_len, blocksize) != blocksize - 12)
> return NULL;
> - root = (struct dx_root_info *)(((void *)dp + 12));
> + root = (struct dx_root_info *)(((void *)de + 12));
> if (root->reserved_zero ||
> root->info_length != sizeof(struct dx_root_info))
> return NULL;
> @@ -438,7 +438,7 @@ static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
> return (struct dx_countlimit *)(((void *)dirent) + count_offset);
> }
>
> -static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent,
> +static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry_2 *dirent,
> int count_offset, int count, struct dx_tail *t)
> {
> struct ext4_inode_info *ei = EXT4_I(inode);
> @@ -456,7 +456,7 @@ static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent,
> }
>
> static int ext4_dx_csum_verify(struct inode *inode,
> - struct ext4_dir_entry *dirent)
> + struct ext4_dir_entry_2 *dirent)
> {
> struct dx_countlimit *c;
> struct dx_tail *t;
> @@ -485,7 +485,7 @@ static int ext4_dx_csum_verify(struct inode *inode,
> return 1;
> }
>
> -static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
> +static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry_2 *dirent)
> {
> struct dx_countlimit *c;
> struct dx_tail *t;
> @@ -515,7 +515,7 @@ static inline int ext4_handle_dirty_dx_node(handle_t *handle,
> struct inode *inode,
> struct buffer_head *bh)
> {
> - ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
> + ext4_dx_csum_set(inode, (struct ext4_dir_entry_2 *)bh->b_data);
> return ext4_handle_dirty_metadata(handle, inode, bh);
> }
>
> @@ -1488,7 +1488,7 @@ int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
> }
>
> static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
> - struct ext4_dir_entry *de)
> + struct ext4_dir_entry_2 *de)
> {
> struct super_block *sb = dir->i_sb;
>
> @@ -1619,7 +1619,7 @@ static struct buffer_head *__ext4_find_entry(struct inode *dir,
> }
> if (!buffer_verified(bh) &&
> !is_dx_internal_node(dir, block,
> - (struct ext4_dir_entry *)bh->b_data) &&
> + (struct ext4_dir_entry_2 *)bh->b_data) &&
> !ext4_dirblock_csum_verify(dir, bh)) {
> EXT4_ERROR_INODE_ERR(dir, EFSBADCRC,
> "checksumming directory "
> --
> 2.43.7
>
Cheers, Andreas
^ permalink raw reply
* Re: [PATCH v5 05/10] fstests: verify f_fsid for cloned filesystems
From: Anand Jain @ 2026-05-27 22:41 UTC (permalink / raw)
To: Christoph Hellwig, Anand Jain
Cc: fstests, linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel,
amir73il, zlang
In-Reply-To: <ahP2hjv9zl_WL1kg@infradead.org>
On 25/5/26 15:13, Christoph Hellwig wrote:
> On Thu, May 21, 2026 at 08:54:55PM +0800, Anand Jain wrote:
>> +[ "$FSTYP" = "btrfs" ] && _fixed_by_kernel_commit xxxxxxxxxxxx \
>> + "btrfs: use on-disk uuid for s_uuid in temp_fsid mounts"
>> +[ "$FSTYP" = "btrfs" ] && _fixed_by_kernel_commit xxxxxxxxxxxx \
>> + "btrfs: derive f_fsid from on-disk fsuuid and dev_t"
>
> Seems like these are stuck on the btrfs list. Any progress on that?
They are in the `for-next` branch of the Btrfs Linux repository:
https://github.com/btrfs/linux.git
^ permalink raw reply
* [PATCH v6 0/11] fstests: add test coverage for cloned filesystem ids
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
v6:
. Renamed `pre_clone_tune_uuid()` to `_change_metadata_uuid()`.
. Created the `_require_unique_f_fsid()` helper instead of handling it inside the test case (patch 5/11).
. Separated `FSNOTIFYWAIT_PROG` into its own patch.
. Dropped the `inotify` test case in favor of `fsnotify`.
. Added comments throughout, especially for helper functions.
v5:
https://lore.kernel.org/fstests/cover.1779367627.git.asj@kernel.org
v4:
https://lore.kernel.org/fstests/cover.1777357320.git.asj@kernel.org
v3:
https://lore.kernel.org/fstests/cover.1777281778.git.asj@kernel.org
v2:
https://lore.kernel.org/fstests/cover.1774090817.git.asj@kernel.org
v1:
https://lore.kernel.org/fstests/cover.1772095513.git.asj@kernel.org
This series adds fstests infrastructure and test cases to verify correct
filesystem identity when a filesystem is cloned (block-level copy).
Test covers inotify, fanotify, f_fsid, libblkid, IMA, exportfs file handles
and libblkid tools verify with metadata_uuid.
New helpers:
_loop_image_create_clone() and _loop_image_destroy() to help create fs and clone
_clone_mount_option() helper to apply per-filesystem clone mount options
_change_metadata_uuid() changes the UUID before the clone
New tests:
- fanotify events are isolated between cloned filesystems
- f_fsid is unique across cloned filesystem instances
- libblkid correctly resolves duplicate UUIDs to distinct devices
with and without metadata_uuid
- IMA distinct identity for each cloned filesystem
- exportfs file handles resolve correctly on cloned filesystems
Kernel Patches:
Requires Btrfs kernel patches for all tests to pass.
[1] https://lore.kernel.org/linux-btrfs/cover.1777281686.git.asj@kernel.org
Anand Jain (11):
fstests: add _loop_image_create_clone() helper
fstests: add _clone_mount_option() helper
fstests: add FSNOTIFYWAIT_PROG
fstests: add _require_unique_f_fsid() helper
fstests: verify fanotify isolation on cloned filesystems
fstests: verify f_fsid for cloned filesystems
fstests: verify libblkid resolution of duplicate UUIDs
fstests: verify IMA isolation on cloned filesystems
fstests: verify exportfs file handles on cloned filesystems
fstests: add _change_metadata_uuid helper
fstests: test UUID consistency for clones with metadata_uuid
common/config | 1 +
common/rc | 124 ++++++++++++++++++++++++++++++++++++++
tests/generic/801 | 135 ++++++++++++++++++++++++++++++++++++++++++
tests/generic/801.out | 7 +++
tests/generic/802 | 67 +++++++++++++++++++++
tests/generic/802.out | 7 +++
tests/generic/803 | 84 ++++++++++++++++++++++++++
tests/generic/803.out | 19 ++++++
tests/generic/804 | 108 +++++++++++++++++++++++++++++++++
tests/generic/804.out | 10 ++++
tests/generic/805 | 80 +++++++++++++++++++++++++
tests/generic/805.out | 2 +
tests/generic/806 | 84 ++++++++++++++++++++++++++
tests/generic/806.out | 19 ++++++
14 files changed, 747 insertions(+)
create mode 100644 tests/generic/801
create mode 100644 tests/generic/801.out
create mode 100644 tests/generic/802
create mode 100644 tests/generic/802.out
create mode 100644 tests/generic/803
create mode 100644 tests/generic/803.out
create mode 100644 tests/generic/804
create mode 100644 tests/generic/804.out
create mode 100644 tests/generic/805
create mode 100644 tests/generic/805.out
create mode 100644 tests/generic/806
create mode 100644 tests/generic/806.out
--
2.43.0
^ permalink raw reply
* [PATCH v6 01/11] fstests: add _loop_image_create_clone() helper
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Introduce _loop_image_create_clone() and _loop_image_destroy() to mkfs an
image file and clone it to another image file, and attach a loop device to
them. And its destroy part.
Signed-off-by: Anand Jain <asj@kernel.org>
---
common/rc | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 63 insertions(+)
diff --git a/common/rc b/common/rc
index 79189e7e6e94..d7e3e0bdfb1e 100644
--- a/common/rc
+++ b/common/rc
@@ -1520,6 +1520,69 @@ _scratch_resvblks()
esac
}
+# Create a small loop image, run an optional tuning function ($2) on it,
+# clone it, and attach both to loop devices, returned in ($1).
+# Args:
+# $1: Nameref to return the array of allocated loop devices [base, clone].
+# $2: Optional callback function to tune the base filesystem before cloning.
+_loop_image_create_clone()
+{
+ local -n _ret=$1
+ local pre_clone_tune_func="$2"
+ local img_file=$TEST_DIR/${seq}.img
+ local img_file_clone=$TEST_DIR/${seq}_clone.img
+ local size=$(_small_fs_size_mb 128) # Smallest possible
+ local loop_devs
+
+ # Since we copy the block device image, we keep its size small.
+ _require_fs_space $TEST_DIR $((size * 1024))
+
+ _create_file_sized $((size * 1024 * 1024)) $img_file ||
+ _fail "Failed: Create $img_file $size"
+
+ loop_devs=$(_create_loop_device $img_file)
+ _ret=($loop_devs)
+
+ case $FSTYP in
+ xfs)
+ _mkfs_dev "-s size=4096" ${loop_devs[0]}
+ ;;
+ btrfs)
+ _mkfs_dev ${loop_devs[0]}
+ ;;
+ *)
+ _mkfs_dev ${loop_devs[0]}
+ ;;
+ esac
+
+ # Only execute if the function argument is not empty
+ if [ -n "$pre_clone_tune_func" ]; then
+ $pre_clone_tune_func ${loop_devs[0]}
+ fi
+
+ sync ${loop_devs[0]}
+ cp $img_file $img_file_clone
+
+ loop_devs="$loop_devs $(_create_loop_device $img_file_clone)"
+
+ _ret=($loop_devs)
+}
+
+# Teardown loop devices and delete their underlying backing image files.
+# Accepts a list of loop device paths (e.g., /dev/loop0 /dev/loop1).
+_loop_image_destroy()
+{
+ for d in "$@"; do
+ # Retrieve the path of the backing file
+ local f=$(losetup --noheadings --output BACK-FILE $d)
+
+ # Detach the loop device from the backing file
+ _destroy_loop_device "$d"
+
+ # Clean up the backing disk image file
+ [ -n "$f" ] && rm -f "$f"
+ done
+}
# Repair scratch filesystem. Returns 0 if the FS is good to go (either no
# errors found or errors were fixed) and nonzero otherwise; also spits out
--
2.43.0
^ permalink raw reply related
* [PATCH v6 02/11] fstests: add _clone_mount_option() helper
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Adds _clone_mount_option() helper function to handle filesystem-specific
requirements for mounting cloned devices. Abstract the need for -o nouuid
on XFS.
Signed-off-by: Anand Jain <asj@kernel.org>
---
common/rc | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/common/rc b/common/rc
index d7e3e0bdfb1e..937f478963b4 100644
--- a/common/rc
+++ b/common/rc
@@ -414,6 +414,23 @@ _scratch_mount_options()
$SCRATCH_DEV $SCRATCH_MNT
}
+# Return filesystem-specific mount options required for mounting clone/snapshot
+# devices.
+_clone_mount_option()
+{
+ local mount_opts=""
+
+ case "$FSTYP" in
+ xfs)
+ # Allow mounting a duplicate filesystem on the same host
+ mount_opts="-o nouuid"
+ ;;
+ *)
+ esac
+
+ echo $mount_opts
+}
+
_supports_filetype()
{
local dir=$1
--
2.43.0
^ permalink raw reply related
* [PATCH v6 03/11] fstests: add FSNOTIFYWAIT_PROG
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Define `FSNOTIFYWAIT_PROG` for an upcoming test case that uses `fsnotifywait`.
Signed-off-by: Anand Jain <asj@kernel.org>
---
common/config | 1 +
1 file changed, 1 insertion(+)
diff --git a/common/config b/common/config
index d5299d5b926f..5661fa0ec310 100644
--- a/common/config
+++ b/common/config
@@ -242,6 +242,7 @@ export BTRFS_MAP_LOGICAL_PROG=$(type -P btrfs-map-logical)
export PARTED_PROG="$(type -P parted)"
export XFS_PROPERTY_PROG="$(type -P xfs_property)"
export FSCRYPTCTL_PROG="$(type -P fscryptctl)"
+export FSNOTIFYWAIT_PROG="$(type -P fsnotifywait)"
# udev wait functions.
#
--
2.43.0
^ permalink raw reply related
* [PATCH v6 04/11] fstests: add _require_unique_f_fsid() helper
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Add a helper to check if the target filesystem supports unique f_fsid
tracking across cloned or snapshot instances.
Certain filesystems like XFS, Btrfs, and F2FS ensure unique f_fsid
identifiers per filesystem instance. However, Ext4 derives its f_fsid
directly from its superblock UUID, which leads to identical f_fsid
values on cloned images until the UUID is manually modified by userspace.
Introduce _require_unique_f_fsid() to allow test cases requiring strict
f_fsid uniqueness to skip gracefully on unsupported filesystems.
Signed-off-by: Anand Jain <asj@kernel.org>
---
common/rc | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/common/rc b/common/rc
index 937f478963b4..5446552aed92 100644
--- a/common/rc
+++ b/common/rc
@@ -6314,6 +6314,27 @@ _require_fanotify_ioerrors()
_notrun "$FSTYP does not support fanotify ioerrors"
}
+# Ext4 derives f_fsid from the superblock UUID, meaning clones share the
+# same f_fsid until their UUIDs diverge. Conversely, XFS, Btrfs,
+# and F2FS ensure f_fsid remains unique per filesystem instance (often by
+# deriving it from the UUID and underlying block device.)
+#
+# Across all filesystems, a UUID collision causes libblkid tools to return
+# non-deterministic device mappings. It is ultimately the responsibility
+# of the userspace utility or use-case to enforce uniqueness when a clone
+# diverges. For details, see mailing list thread discussions titled:
+# "ext4: derive f_fsid from block device to avoid collisions".
+_require_unique_f_fsid()
+{
+ # Skip the test if the filesystem does not enforce unique f_fsids
+ # natively. Checking this dynamically requires recreating a clone
+ # layout, so we use a static lookup based on FSTYP.
+ if [ "$FSTYP" == "ext4" ]; then
+ _notrun "Target filesystem ($FSTYP) does not guarantee unique f_fsid on clones."
+ fi
+}
+
+
# Computes a percentage of the available space in a filesystem and
# returns that quantity in MB. The percentage must not contain a percent
# sign ("%").
--
2.43.0
^ permalink raw reply related
* [PATCH v6 05/11] fstests: verify fanotify isolation on cloned filesystems
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Verify that fanotify events are correctly routed to the appropriate
watcher when cloned filesystems are mounted.
Helps verify kernel's event notification distinguishes between devices
sharing the same FSID/UUID.
Signed-off-by: Anand Jain <asj@kernel.org>
---
tests/generic/801 | 135 ++++++++++++++++++++++++++++++++++++++++++
tests/generic/801.out | 7 +++
2 files changed, 142 insertions(+)
create mode 100644 tests/generic/801
create mode 100644 tests/generic/801.out
diff --git a/tests/generic/801 b/tests/generic/801
new file mode 100644
index 000000000000..3bfb87d41922
--- /dev/null
+++ b/tests/generic/801
@@ -0,0 +1,135 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2026 Anand Jain <asj@kernel.org>. All Rights Reserved.
+#
+# FS QA Test 801
+# Verify fanotify FID functionality on cloned filesystems by setting up
+# watchers and making sure notifications are in the correct logs files.
+
+. ./common/preamble
+
+_begin_fstest auto quick mount clone
+
+_require_test
+_require_block_device $TEST_DEV
+_require_loop
+_require_command "$FSNOTIFYWAIT_PROG" fsnotifywait
+_require_unique_f_fsid
+
+_cleanup()
+{
+ cd /
+ [[ -n $pid1 ]] && { kill -TERM "$pid1" 2> /dev/null; wait $pid1; }
+ [[ -n $pid2 ]] && { kill -TERM "$pid2" 2> /dev/null; wait $pid2; }
+
+ if [ "$semanage_added" = "yes" ]; then
+ semanage permissive -d unconfined_t >/dev/null 2>&1 || true
+ fi
+
+ umount $mnt1 $mnt2 2>/dev/null
+ _loop_image_destroy "${devs[@]}" 2> /dev/null
+ rm -r -f $tmp.*
+}
+
+# Run fsnotifywait in unbuffered mode to watch filesystem-wide create events
+monitor_fanotify()
+{
+ local mmnt=$1
+ exec stdbuf -oL $FSNOTIFYWAIT_PROG -m -F -S -e create "$mmnt" 2>&1
+}
+
+# Transform f_fsid into the hi.lo format used in fanotify FID logs
+fsid_to_fid_parts()
+{
+ local fsid=$1
+ # Pad to 16 hex chars (64-bit), then split into two 32-bit halves
+ local padded=$(printf '%016x' "0x${fsid}")
+ local hi=$(printf '%x' "0x${padded:0:8}") # strips leading zeros
+ local lo=$(printf '%x' "0x${padded:8:8}") # strips leading zeros
+ echo "${hi}.${lo}"
+}
+
+# Create base loop device and its clone
+devs=()
+_loop_image_create_clone devs
+mkdir -p $TEST_DIR/$seq
+mnt1=$TEST_DIR/$seq/mnt1
+mnt2=$TEST_DIR/$seq/mnt2
+mkdir -p $mnt1
+mkdir -p $mnt2
+
+# Mount both base and clone filesystems using required clone mount options
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+
+# Fetch filesystem IDs to verify the kernel can differentiate between them
+fsid1=$(stat -f -c "%i" $mnt1)
+fsid2=$(stat -f -c "%i" $mnt2)
+
+log1=$tmp.fanotify1
+log2=$tmp.fanotify2
+
+pid1=""
+pid2=""
+echo "Setup FID fanotify watchers on both mnt1 and mnt2"
+
+# Permit unconfined_t domains when SELinux is enforcing to prevent fanotify
+# blockages
+semanage_added="no"
+if [ "$(getenforce 2>/dev/null)" = "Enforcing" ]; then
+ if ! semanage permissive -l | grep -q "unconfined_t"; then
+ semanage permissive -a unconfined_t >/dev/null 2>&1 && semanage_added="yes"
+ fi
+fi
+
+# Start asynchronous fanotify monitors
+( monitor_fanotify "$mnt1" > "$log1" ) &
+pid1=$!
+( monitor_fanotify "$mnt2" > "$log2" ) &
+pid2=$!
+sleep 2
+
+echo "Trigger file creation on mnt1"
+touch $mnt1/file_on_mnt1
+sync
+sleep 1
+
+echo "Trigger file creation on mnt2"
+touch $mnt2/file_on_mnt2
+sync
+sleep 1
+
+echo "Verify fsid in the fanotify"
+kill $pid1 $pid2
+wait $pid1 $pid2 2>/dev/null
+pid1=""
+pid2=""
+
+e_fsid1=$(fsid_to_fid_parts "$fsid1")
+e_fsid2=$(fsid_to_fid_parts "$fsid2")
+
+# Dump debug details to the full log
+echo $fsid1 $e_fsid1 $fsid2 $e_fsid2 >> $seqres.full
+cat $log1 >> $seqres.full
+cat $log2 >> $seqres.full
+
+# Ensure monitor 1 only captured events belonging to mnt 1 and fsid 1
+if grep -qF "$e_fsid1" "$log1" && ! grep -qF "$e_fsid2" "$log1"; then
+ echo "SUCCESS: mnt1 events found"
+else
+ [ ! -s "$log1" ] && echo " - mnt1 received no events."
+ grep -qF "$e_fsid2" "$log1" && echo " - mnt1 received event from mnt2."
+fi
+
+# Ensure monitor 2 only captured events belonging to mnt 2 and fsid 2
+if grep -qF "$e_fsid2" "$log2" && ! grep -qF "$e_fsid1" "$log2"; then
+ echo "SUCCESS: mnt2 events found"
+else
+ [ ! -s "$log2" ] && echo " - mnt2 received no events."
+ grep -qF "$e_fsid1" "$log2" && echo " - mnt2 received event from mnt1."
+fi
+
+status=0
+exit
diff --git a/tests/generic/801.out b/tests/generic/801.out
new file mode 100644
index 000000000000..d7b318d9f27c
--- /dev/null
+++ b/tests/generic/801.out
@@ -0,0 +1,7 @@
+QA output created by 801
+Setup FID fanotify watchers on both mnt1 and mnt2
+Trigger file creation on mnt1
+Trigger file creation on mnt2
+Verify fsid in the fanotify
+SUCCESS: mnt1 events found
+SUCCESS: mnt2 events found
--
2.43.0
^ permalink raw reply related
* [PATCH v6 06/11] fstests: verify f_fsid for cloned filesystems
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Verify that the cloned filesystem provides an f_fsid that is persistent
across mount cycles, yet unique from the original filesystem's f_fsid.
Signed-off-by: Anand Jain <asj@kernel.org>
---
tests/generic/802 | 67 +++++++++++++++++++++++++++++++++++++++++++
tests/generic/802.out | 7 +++++
2 files changed, 74 insertions(+)
create mode 100644 tests/generic/802
create mode 100644 tests/generic/802.out
diff --git a/tests/generic/802 b/tests/generic/802
new file mode 100644
index 000000000000..653e74e11b53
--- /dev/null
+++ b/tests/generic/802
@@ -0,0 +1,67 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2026 Anand Jain <asj@kernel.org>. All Rights Reserved.
+#
+# FS QA Test 802
+# Verify f_fsid and s_uuid of cloned filesystems across mount cycle.
+
+. ./common/preamble
+
+_begin_fstest auto quick mount clone
+
+_require_test
+_require_block_device $TEST_DEV
+_require_loop
+
+[ "$FSTYP" = "btrfs" ] && _fixed_by_kernel_commit xxxxxxxxxxxx \
+ "btrfs: use on-disk uuid for s_uuid in temp_fsid mounts"
+[ "$FSTYP" = "btrfs" ] && _fixed_by_kernel_commit xxxxxxxxxxxx \
+ "btrfs: derive f_fsid from on-disk fsuuid and dev_t"
+
+_cleanup()
+{
+ cd /
+ rm -r -f $tmp.*
+ umount $mnt1 $mnt2 2>/dev/null
+ _loop_image_destroy "${devs[@]}" 2> /dev/null
+}
+
+# Setup base loop device and its clone
+devs=()
+_loop_image_create_clone devs
+mkdir -p $TEST_DIR/$seq
+mnt1=$TEST_DIR/$seq/mnt1
+mnt2=$TEST_DIR/$seq/mnt2
+mkdir -p $mnt1
+mkdir -p $mnt2
+
+# Mount both filesystems simultaneously using mandatory clone mount options
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+
+# Capture baseline filesystem IDs for comparison
+fsid_scratch=$(stat -f -c "%i" $mnt1)
+fsid_clone=$(stat -f -c "%i" $mnt2)
+
+echo "**** fsid initially ****"
+echo $fsid_scratch | sed -e "s/$fsid_scratch/FSID_SCRATCH/g"
+echo $fsid_clone | sed -e "s/$fsid_clone/FSID_CLONE/g"
+
+# Verify that the fsids remain stable after a mount cycle, even when the
+# mount order is reversed.
+echo "**** fsid after mount cycle ****"
+_unmount $mnt1
+_unmount $mnt2
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+
+# Compare post mount-cycle values against the baseline
+stat -f -c "%i" $mnt1 | sed -e "s/$fsid_scratch/FSID_SCRATCH/g"
+stat -f -c "%i" $mnt2 | sed -e "s/$fsid_clone/FSID_CLONE/g"
+
+status=0
+exit
diff --git a/tests/generic/802.out b/tests/generic/802.out
new file mode 100644
index 000000000000..d1e008f122bb
--- /dev/null
+++ b/tests/generic/802.out
@@ -0,0 +1,7 @@
+QA output created by 802
+**** fsid initially ****
+FSID_SCRATCH
+FSID_CLONE
+**** fsid after mount cycle ****
+FSID_SCRATCH
+FSID_CLONE
--
2.43.0
^ permalink raw reply related
* [PATCH v6 07/11] fstests: verify libblkid resolution of duplicate UUIDs
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Verify how findmnt, df (libblkid) resolve device paths when multiple
block devices share the same FSUUID.
Signed-off-by: Anand Jain <asj@kernel.org>
---
tests/generic/803 | 84 +++++++++++++++++++++++++++++++++++++++++++
tests/generic/803.out | 19 ++++++++++
2 files changed, 103 insertions(+)
create mode 100644 tests/generic/803
create mode 100644 tests/generic/803.out
diff --git a/tests/generic/803 b/tests/generic/803
new file mode 100644
index 000000000000..b304a2743604
--- /dev/null
+++ b/tests/generic/803
@@ -0,0 +1,84 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2026 Anand Jain <asj@kernel.org>. All Rights Reserved.
+#
+# FS QA Test 803
+# Verify how libblkid resolve devices when multiple devices sharing the
+# same FSUUID.
+
+. ./common/preamble
+. ./common/filter
+
+_begin_fstest auto quick mount clone
+
+_require_test
+_require_block_device $TEST_DEV
+_require_loop
+
+_cleanup()
+{
+ cd /
+ rm -r -f $tmp.*
+ umount $mnt1 $mnt2 2>/dev/null
+ _loop_image_destroy "${devs[@]}" 2> /dev/null
+}
+
+# Normalize pool devices and mount points names
+filter_pool()
+{
+ sed -e "s|${devs[0]}|DEV1|g" -e "s|${mnt1}|MNT1|g" \
+ -e "s|${devs[1]}|DEV2|g" -e "s|${mnt2}|MNT2|g" | _filter_spaces
+}
+
+# Collect and print device tracking info from findmnt, /proc/mounts, and df.
+# This checks whether user-space tools get confused or remain accurate when
+# resolving a duplicate/cloned filesystem UUID.
+print_info()
+{
+ local mntpt=$1
+ local tgt=$(findmnt -no SOURCE $mntpt)
+ local fsuuid=$(blkid -s UUID -o value $tgt)
+
+ echo "mntpt=$mntpt tgt=$tgt fsuuid=$fsuuid" >> $seqres.full
+ echo
+ findmnt -o SOURCE,TARGET,UUID "$tgt" | tail -n +2 | \
+ sed -e "s/${fsuuid}/FSUUID/g" | filter_pool
+ awk -v dev="$tgt" '$1 == dev { print $1, $2 }' /proc/self/mounts | \
+ filter_pool
+ df --all --output=source,target "$tgt" | tail -n +2 | filter_pool
+}
+
+# Setup base loop device and its clone
+devs=()
+_loop_image_create_clone devs
+mkdir -p $TEST_DIR/$seq
+mnt1=$TEST_DIR/$seq/mnt1
+mnt2=$TEST_DIR/$seq/mnt2
+mkdir -p $mnt1
+mkdir -p $mnt2
+
+# Mount both identical UUID filesystems simultaneously
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+
+print_info $mnt1
+print_info $mnt2
+
+# Cycle mounts and reverse the initialization order to see if libblkid / findmnt
+# resolution changes based on mount order.
+echo
+echo "**** mount cycle ****"
+_unmount $mnt1
+_unmount $mnt2
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+
+print_info $mnt1
+print_info $mnt2
+
+status=0
+exit
diff --git a/tests/generic/803.out b/tests/generic/803.out
new file mode 100644
index 000000000000..20a1cb36a213
--- /dev/null
+++ b/tests/generic/803.out
@@ -0,0 +1,19 @@
+QA output created by 803
+
+DEV1 MNT1 FSUUID
+DEV1 MNT1
+DEV1 MNT1
+
+DEV2 MNT2 FSUUID
+DEV2 MNT2
+DEV2 MNT2
+
+**** mount cycle ****
+
+DEV1 MNT1 FSUUID
+DEV1 MNT1
+DEV1 MNT1
+
+DEV2 MNT2 FSUUID
+DEV2 MNT2
+DEV2 MNT2
--
2.43.0
^ permalink raw reply related
* [PATCH v6 08/11] fstests: verify IMA isolation on cloned filesystems
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Add testcase to verify IMA measurement isolation when multiple devices
share the same FSUUID.
Signed-off-by: Anand Jain <asj@kernel.org>
---
tests/generic/804 | 108 ++++++++++++++++++++++++++++++++++++++++++
tests/generic/804.out | 10 ++++
2 files changed, 118 insertions(+)
create mode 100644 tests/generic/804
create mode 100644 tests/generic/804.out
diff --git a/tests/generic/804 b/tests/generic/804
new file mode 100644
index 000000000000..31ae77a2f461
--- /dev/null
+++ b/tests/generic/804
@@ -0,0 +1,108 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2026 Anand Jain <asj@kernel.org>. All Rights Reserved.
+#
+# FS QA Test 804
+# Verify IMA isolation on cloned filesystems:
+# . Mount two devices sharing the same FSUUID (cloned).
+# . Apply an IMA policy to measure files based on that FSUUID.
+# . Create unique files on each mount point to trigger measurements.
+# . Confirm the IMA log correctly attributes events to the respective mounts.
+
+. ./common/preamble
+. ./common/filter
+
+_begin_fstest auto quick clone
+
+_require_test
+_require_block_device $TEST_DEV
+_require_loop
+
+[ "$FSTYP" = "btrfs" ] && _fixed_by_kernel_commit xxxxxxxxxxxx \
+ "btrfs: use on-disk uuid for s_uuid in temp_fsid mounts"
+[ "$FSTYP" = "btrfs" ] && _fixed_by_kernel_commit xxxxxxxxxxxx \
+ "btrfs: derive f_fsid from on-disk fsuuid and dev_t"
+
+_cleanup()
+{
+ cd /
+ rm -r -f $tmp.*
+ _unmount $mnt1 2>/dev/null
+ _unmount $mnt2 2>/dev/null
+ _loop_image_destroy "${devs[@]}" 2> /dev/null
+}
+
+# Normalize device names and mount points
+filter_pool()
+{
+ sed -e "s|${devs[0]}|DEV1|g" -e "s|$mnt1|MNT1|g" \
+ -e "s|${devs[1]}|DEV2|g" -e "s|$mnt2|MNT2|g" | _filter_spaces
+}
+
+# Core helper to set IMA policy and check measurement logs
+do_ima()
+{
+ local ima_policy="/sys/kernel/security/ima/policy"
+ local ima_log="/sys/kernel/security/ima/ascii_runtime_measurements"
+ local fsuuid
+ local mnt=$1
+ local enable=$2
+
+ # Since the in-memory IMA audit log is only cleared upon reboot,
+ # use unique random filenames to avoid log collisions.
+ local foofile=$(mktemp --dry-run foobar_XXXXX)
+
+ echo $mnt $enable | filter_pool
+
+ [ -w "$ima_policy" ] || _notrun "IMA policy not writable"
+
+ fsuuid=$(blkid -s UUID -o value ${devs[0]})
+
+ # Load IMA policy to measure file access specifically for this
+ # filesystem UUID.
+ if [[ $enable -eq 1 ]]; then
+ echo "measure func=FILE_CHECK fsuuid=$fsuuid" > "$ima_policy" || \
+ _notrun "Policy rejected"
+ fi
+
+ # Create a file to trigger measurement and verify its entry in
+ # the IMA log.
+ echo "test_data" > $mnt/$foofile
+
+ # IMA log extract
+ grep $foofile "$ima_log" | awk '{ print $5 }' | filter_pool | \
+ sed "s/$foofile/FOOBAR_FILE/"
+
+ echo "dbg: $mnt $fsuuid $foofile" >> $seqres.full
+ cat $ima_log | tail -1 >> $seqres.full
+ echo >> $seqres.full
+}
+
+# Initialize loop base and cloned instances
+devs=()
+_loop_image_create_clone devs
+mnt1=$TEST_DIR/$seq/mnt1
+mnt2=$TEST_DIR/$seq/mnt2
+mkdir -p $mnt1
+mkdir -p $mnt2
+
+# Concurrently mount both clones
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+
+# IMA response on baseline and clone configuration
+do_ima $mnt1 1
+do_ima $mnt2 0
+
+# Cycle mount on the second device.
+echo mount cycle
+_unmount $mnt2
+_mount $mount_opts ${devs[1]} $mnt2 || _fail "Failed to mount dev2"
+
+do_ima $mnt1 0
+do_ima $mnt2 0
+
+status=0
+exit
diff --git a/tests/generic/804.out b/tests/generic/804.out
new file mode 100644
index 000000000000..9804181d6c17
--- /dev/null
+++ b/tests/generic/804.out
@@ -0,0 +1,10 @@
+QA output created by 804
+MNT1 1
+MNT1/FOOBAR_FILE
+MNT2 0
+MNT2/FOOBAR_FILE
+mount cycle
+MNT1 0
+MNT1/FOOBAR_FILE
+MNT2 0
+MNT2/FOOBAR_FILE
--
2.43.0
^ permalink raw reply related
* [PATCH v6 09/11] fstests: verify exportfs file handles on cloned filesystems
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Ensure that exportfs can correctly decode file handles on a cloned
filesystem across a mount cycle, by file handles generated on a
cloned device remain valid after mount cycle.
Signed-off-by: Anand Jain <asj@kernel.org>
---
tests/generic/805 | 80 +++++++++++++++++++++++++++++++++++++++++++
tests/generic/805.out | 2 ++
2 files changed, 82 insertions(+)
create mode 100644 tests/generic/805
create mode 100644 tests/generic/805.out
diff --git a/tests/generic/805 b/tests/generic/805
new file mode 100644
index 000000000000..5827eee039df
--- /dev/null
+++ b/tests/generic/805
@@ -0,0 +1,80 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2026 Anand Jain <asj@kernel.org>. All Rights Reserved.
+#
+# FS QA Test No. 805
+# Verify that file handles encoded on a cloned filesystem remain valid and
+# resolvable via open_by_handle across a mount cycle and mount order swap.
+
+. ./common/preamble
+
+_begin_fstest auto quick exportfs clone
+
+_require_test
+_require_block_device $TEST_DEV
+_require_exportfs
+_require_loop
+_require_test_program "open_by_handle"
+
+_cleanup()
+{
+ cd /
+ rm -r -f $tmp.*
+ _unmount $mnt1 2>/dev/null
+ _unmount $mnt2 2>/dev/null
+ _loop_image_destroy "${devs[@]}" 2> /dev/null
+}
+
+# Create test dir and test files, encode file handles and store to tmp file
+create_test_files()
+{
+ rm -rf $testdir
+ mkdir -p $testdir
+ $here/src/open_by_handle -cwp -o $tmp.handles_file $testdir $NUMFILES
+}
+
+# Attempt to read and decode the saved file handles on the targeted mount point.
+test_file_handles()
+{
+ local opt=$1
+ local when=$2
+
+ echo test_file_handles after $when
+ $here/src/open_by_handle $opt -i $tmp.handles_file $mnt2 $NUMFILES
+}
+
+# Setup base loop device and its clone
+devs=()
+_loop_image_create_clone devs
+mkdir -p $TEST_DIR/$seq
+mnt1=$TEST_DIR/$seq/mnt1
+mnt2=$TEST_DIR/$seq/mnt2
+mkdir -p $mnt1
+mkdir -p $mnt2
+
+# Mount both identical UUID filesystems simultaneously
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+
+NUMFILES=1
+testdir=$mnt2/testdir
+
+# Decode file handles of files/dir after cycle mount
+create_test_files
+
+# Cycle mounts and reverse initialization sequence to check if
+# file handle lookups are okay
+_unmount $mnt1
+_unmount $mnt2
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+
+# Verify file handles can still be resolved post-mount-cycle
+test_file_handles -rp "cycle mount"
+
+status=0
+exit
diff --git a/tests/generic/805.out b/tests/generic/805.out
new file mode 100644
index 000000000000..29b11ec77ffb
--- /dev/null
+++ b/tests/generic/805.out
@@ -0,0 +1,2 @@
+QA output created by 805
+test_file_handles after cycle mount
--
2.43.0
^ permalink raw reply related
* [PATCH v6 10/11] fstests: add _change_metadata_uuid helper
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
_change_metadata_uuid changes the UUID of the golden filesystem before it
is cloned.
Signed-off-by: Anand Jain <asj@kernel.org>
---
common/rc | 23 +++++++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git a/common/rc b/common/rc
index 5446552aed92..79be51e4da31 100644
--- a/common/rc
+++ b/common/rc
@@ -1537,6 +1537,29 @@ _scratch_resvblks()
esac
}
+# Change the metadata UUID of the given device to a newly generated one.
+# Args:
+# $1: Block device path to modify.
+_change_metadata_uuid()
+{
+ local temp_mnt=$TEST_DIR/${seq}_mnt
+ local dev=$1
+
+ case $FSTYP in
+ xfs)
+ _require_command "$XFS_ADMIN_PROG" "xfs_admin"
+ $XFS_ADMIN_PROG -U generate $dev >> $seqres.full
+ ;;
+ btrfs)
+ _require_command "$BTRFS_TUNE_PROG" "btrfstune"
+ $BTRFS_TUNE_PROG -m $dev
+ ;;
+ *)
+ _notrun "Require filesystem with metadata_uuid feature"
+ ;;
+ esac
+}
+
# Create a small loop image, run an optional tuning function ($2) on it,
# clone it, and attach both to loop devices, returned in ($1).
# Args:
--
2.43.0
^ permalink raw reply related
* [PATCH v6 11/11] fstests: test UUID consistency for clones with metadata_uuid
From: Anand Jain @ 2026-05-28 4:05 UTC (permalink / raw)
To: fstests; +Cc: linux-btrfs, linux-ext4, linux-xfs, linux-f2fs-devel, zlang, hch
In-Reply-To: <cover.1779939330.git.asj@kernel.org>
Btrfs and xfs uses the metadata_uuid superblock feature to change the
on-disk UUID without rewriting every block header. This patch adds a
sanity check to ensure UUID consistency when a filesystem with
metadata_uuid enabled is cloned.
Signed-off-by: Anand Jain <asj@kernel.org>
---
tests/generic/806 | 84 +++++++++++++++++++++++++++++++++++++++++++
tests/generic/806.out | 19 ++++++++++
2 files changed, 103 insertions(+)
create mode 100644 tests/generic/806
create mode 100644 tests/generic/806.out
diff --git a/tests/generic/806 b/tests/generic/806
new file mode 100644
index 000000000000..801671fb9ce9
--- /dev/null
+++ b/tests/generic/806
@@ -0,0 +1,84 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2026 Anand Jain <asj@kernel.org>. All Rights Reserved.
+#
+# FS QA Test 806
+#
+# Verify that the cloned filesystem UUID remains consistent, even when the
+# `metadata_uuid` feature is enabled.
+#
+
+. ./common/preamble
+. ./common/filter
+
+_begin_fstest auto quick mount clone
+
+_require_test
+_require_block_device $TEST_DEV
+_require_loop
+
+_cleanup()
+{
+ cd /
+ rm -r -f $tmp.*
+ umount $mnt1 $mnt2 2>/dev/null
+ _loop_image_destroy "${devs[@]}" 2> /dev/null
+}
+
+filter_pool()
+{
+ sed -e "s|${devs[0]}|DEV1|g" -e "s|${mnt1}|MNT1|g" \
+ -e "s|${devs[1]}|DEV2|g" -e "s|${mnt2}|MNT2|g" | _filter_spaces
+}
+
+# Collect and print device resolution properties across user-space tools
+print_info()
+{
+ local mntpt=$1
+ local tgt=$(findmnt -no SOURCE $mntpt)
+ local fsuuid=$(blkid -s UUID -o value $tgt)
+
+ echo "mntpt=$mntpt tgt=$tgt fsuuid=$fsuuid" >> $seqres.full
+ echo
+ findmnt -o SOURCE,TARGET,UUID "$tgt" | tail -n +2 | \
+ sed -e "s/${fsuuid}/FSUUID/g" | filter_pool
+ awk -v dev="$tgt" '$1 == dev { print $1, $2 }' /proc/self/mounts | \
+ filter_pool
+ df --all --output=source,target "$tgt" | tail -n +2 | filter_pool
+}
+
+# Create base loop device and its clone, applying the metadata_uuid tuning
+# callback to the base filesystem before the copy occurs.
+devs=()
+_loop_image_create_clone devs _change_metadata_uuid
+mkdir -p $TEST_DIR/$seq
+mnt1=$TEST_DIR/$seq/mnt1
+mnt2=$TEST_DIR/$seq/mnt2
+mkdir -p $mnt1
+mkdir -p $mnt2
+
+# Mount both clone and baseline
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+
+print_info $mnt1
+print_info $mnt2
+
+# Cycle mounts and reverse the initialization order to ensure UUID tracking
+# doesn't mismatch or flip when metadata_uuid optimization is active.
+echo
+echo "**** mount cycle ****"
+_unmount $mnt1
+_unmount $mnt2
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[1]} $mnt2 || \
+ _fail "Failed to mount dev2"
+_mount $(_common_dev_mount_options) $(_clone_mount_option) ${devs[0]} $mnt1 || \
+ _fail "Failed to mount dev1"
+
+print_info $mnt1
+print_info $mnt2
+
+status=0
+exit
diff --git a/tests/generic/806.out b/tests/generic/806.out
new file mode 100644
index 000000000000..7315e791ba51
--- /dev/null
+++ b/tests/generic/806.out
@@ -0,0 +1,19 @@
+QA output created by 806
+
+DEV1 MNT1 FSUUID
+DEV1 MNT1
+DEV1 MNT1
+
+DEV2 MNT2 FSUUID
+DEV2 MNT2
+DEV2 MNT2
+
+**** mount cycle ****
+
+DEV1 MNT1 FSUUID
+DEV1 MNT1
+DEV1 MNT1
+
+DEV2 MNT2 FSUUID
+DEV2 MNT2
+DEV2 MNT2
--
2.43.0
^ permalink raw reply related
* Re: [PATCH v4] ext2: Remove deprecated DAX support
From: kernel test robot @ 2026-05-28 4:16 UTC (permalink / raw)
To: Ashwin Gundarapu, jack; +Cc: oe-kbuild-all, linux-ext4, linux-kernel
In-Reply-To: <19e5aa07c9b.3a2e576d130187.5289857983023045470@zohomail.in>
Hi Ashwin,
kernel test robot noticed the following build warnings:
[auto build test WARNING on jack-fs/for_next]
[also build test WARNING on linus/master v7.1-rc5 next-20260527]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Ashwin-Gundarapu/ext2-Remove-deprecated-DAX-support/20260524-233631
base: https://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git for_next
patch link: https://lore.kernel.org/r/19e5aa07c9b.3a2e576d130187.5289857983023045470%40zohomail.in
patch subject: [PATCH v4] ext2: Remove deprecated DAX support
config: arm-randconfig-r071-20260528 (https://download.01.org/0day-ci/archive/20260528/202605281203.e91xvDyr-lkp@intel.com/config)
compiler: clang version 20.1.8 (https://github.com/llvm/llvm-project 87f0227cb60147a26a1eeb4fb06e3b505e9c7261)
smatch: v0.5.0-9185-gbcc58b9c
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202605281203.e91xvDyr-lkp@intel.com/
smatch warnings:
fs/ext2/inode.c:1251 ext2_setsize() warn: inconsistent indenting
vim +1251 fs/ext2/inode.c
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1236
2c27c65ed0696f0 Christoph Hellwig 2010-06-04 1237 static int ext2_setsize(struct inode *inode, loff_t newsize)
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1238 {
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1239 int error;
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1240
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1241 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1242 S_ISLNK(inode->i_mode)))
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1243 return -EINVAL;
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1244 if (ext2_inode_is_fast_symlink(inode))
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1245 return -EINVAL;
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1246 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1247 return -EPERM;
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1248
562c72aa57c36b1 Christoph Hellwig 2011-06-24 1249 inode_dio_wait(inode);
562c72aa57c36b1 Christoph Hellwig 2011-06-24 1250
737f2e93b9724a3 Nicholas Piggin 2010-05-27 @1251 error = block_truncate_page(inode->i_mapping,
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1252 newsize, ext2_get_block);
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1253 if (error)
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1254 return error;
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1255
70f3bad8c3154ba Jan Kara 2021-04-12 1256 filemap_invalidate_lock(inode->i_mapping);
2c27c65ed0696f0 Christoph Hellwig 2010-06-04 1257 truncate_setsize(inode, newsize);
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1258 __ext2_truncate_blocks(inode, newsize);
70f3bad8c3154ba Jan Kara 2021-04-12 1259 filemap_invalidate_unlock(inode->i_mapping);
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1260
5cdc59fce617a2e Jeff Layton 2023-10-04 1261 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
^1da177e4c3f415 Linus Torvalds 2005-04-16 1262 if (inode_needs_sync(inode)) {
b0439bbc29f0201 Jan Kara 2026-03-26 1263 mmb_sync(&EXT2_I(inode)->i_metadata_bhs);
c37650161a53c01 Christoph Hellwig 2010-10-06 1264 sync_inode_metadata(inode, 1);
^1da177e4c3f415 Linus Torvalds 2005-04-16 1265 } else {
^1da177e4c3f415 Linus Torvalds 2005-04-16 1266 mark_inode_dirty(inode);
^1da177e4c3f415 Linus Torvalds 2005-04-16 1267 }
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1268
737f2e93b9724a3 Nicholas Piggin 2010-05-27 1269 return 0;
^1da177e4c3f415 Linus Torvalds 2005-04-16 1270 }
^1da177e4c3f415 Linus Torvalds 2005-04-16 1271
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply
* Re: [PATCH v4] ext2: Remove deprecated DAX support
From: Ashwin Gundarapu @ 2026-05-28 8:26 UTC (permalink / raw)
To: kernel test robot; +Cc: jack, oe-kbuild-all, linux-ext4, linux-kernel
In-Reply-To: <202605281203.e91xvDyr-lkp@intel.com>
This indentation warning is from pre-existing code (originally written in 2010) that my patch did not touch. I prefer to keep this patch focused solely on removing deprecated DAX support. A separate cleanup patch can be submitted later if desired.
Regards,
Ashwin Gundarapu
From: kernel test robot <lkp@intel.com>
To: "Ashwin Gundarapu"<linuxuser509@zohomail.in>, "jack"<jack@suse.com>
Cc: <oe-kbuild-all@lists.linux.dev>, "linux-ext4"<linux-ext4@vger.kernel.org>, "linux-kernel"<linux-kernel@vger.kernel.org>
Date: Thu, 28 May 2026 09:46:32 +0530
Subject: Re: [PATCH v4] ext2: Remove deprecated DAX support
> Hi Ashwin,
>
> kernel test robot noticed the following build warnings:
>
> [auto build test WARNING on jack-fs/for_next]
> [also build test WARNING on linus/master v7.1-rc5 next-20260527]
> [If your patch is applied to the wrong git tree, kindly drop us a note.
> And when submitting patch, we suggest to use '--base' as documented in
> https://git-scm.com/docs/git-format-patch#_base_tree_information]
>
> url: https://github.com/intel-lab-lkp/linux/commits/Ashwin-Gundarapu/ext2-Remove-deprecated-DAX-support/20260524-233631
> base: https://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git for_next
> patch link: https://lore.kernel.org/r/19e5aa07c9b.3a2e576d130187.5289857983023045470%40zohomail.in
> patch subject: [PATCH v4] ext2: Remove deprecated DAX support
> config: arm-randconfig-r071-20260528 (https://download.01.org/0day-ci/archive/20260528/202605281203.e91xvDyr-lkp@intel.com/config)
> compiler: clang version 20.1.8 (https://github.com/llvm/llvm-project 87f0227cb60147a26a1eeb4fb06e3b505e9c7261)
> smatch: v0.5.0-9185-gbcc58b9c
>
> If you fix the issue in a separate patch/commit (i.e. not just a new version of
> the same patch/commit), kindly add following tags
> | Reported-by: kernel test robot <lkp@intel.com>
> | Closes: https://lore.kernel.org/oe-kbuild-all/202605281203.e91xvDyr-lkp@intel.com/
>
> smatch warnings:
> fs/ext2/inode.c:1251 ext2_setsize() warn: inconsistent indenting
>
> vim +1251 fs/ext2/inode.c
>
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1236
> 2c27c65ed0696f0 Christoph Hellwig 2010-06-04 1237 static int ext2_setsize(struct inode *inode, loff_t newsize)
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1238 {
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1239 int error;
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1240
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1241 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1242 S_ISLNK(inode->i_mode)))
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1243 return -EINVAL;
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1244 if (ext2_inode_is_fast_symlink(inode))
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1245 return -EINVAL;
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1246 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1247 return -EPERM;
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1248
> 562c72aa57c36b1 Christoph Hellwig 2011-06-24 1249 inode_dio_wait(inode);
> 562c72aa57c36b1 Christoph Hellwig 2011-06-24 1250
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 @1251 error = block_truncate_page(inode->i_mapping,
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1252 newsize, ext2_get_block);
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1253 if (error)
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1254 return error;
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1255
> 70f3bad8c3154ba Jan Kara 2021-04-12 1256 filemap_invalidate_lock(inode->i_mapping);
> 2c27c65ed0696f0 Christoph Hellwig 2010-06-04 1257 truncate_setsize(inode, newsize);
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1258 __ext2_truncate_blocks(inode, newsize);
> 70f3bad8c3154ba Jan Kara 2021-04-12 1259 filemap_invalidate_unlock(inode->i_mapping);
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1260
> 5cdc59fce617a2e Jeff Layton 2023-10-04 1261 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
> ^1da177e4c3f415 Linus Torvalds 2005-04-16 1262 if (inode_needs_sync(inode)) {
> b0439bbc29f0201 Jan Kara 2026-03-26 1263 mmb_sync(&EXT2_I(inode)->i_metadata_bhs);
> c37650161a53c01 Christoph Hellwig 2010-10-06 1264 sync_inode_metadata(inode, 1);
> ^1da177e4c3f415 Linus Torvalds 2005-04-16 1265 } else {
> ^1da177e4c3f415 Linus Torvalds 2005-04-16 1266 mark_inode_dirty(inode);
> ^1da177e4c3f415 Linus Torvalds 2005-04-16 1267 }
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1268
> 737f2e93b9724a3 Nicholas Piggin 2010-05-27 1269 return 0;
> ^1da177e4c3f415 Linus Torvalds 2005-04-16 1270 }
> ^1da177e4c3f415 Linus Torvalds 2005-04-16 1271
>
> --
> 0-DAY CI Kernel Test Service
> https://github.com/intel/lkp-tests/wiki
>
>
^ permalink raw reply
* [PATCH] ext4: fix quota accounting WARN in bigalloc punch hole
From: Qiliang Yuan @ 2026-05-28 10:21 UTC (permalink / raw)
To: Theodore Ts'o, Andreas Dilger, Baokun Li, Jan Kara,
Ojaswin Mujoo, Ritesh Harjani (IBM), Zhang Yi
Cc: linux-ext4, linux-kernel, Zijing Yin, Qiliang Yuan
When doing direct I/O write on a bigalloc filesystem, the allocated
extent might not cover entire clusters at its boundaries, leaving
delayed blocks in those boundary clusters. In ext4_es_insert_extent(),
__revise_pending() inserts new pending reservations for those boundary
clusters, and the return value (pending=true) was added to resv_used,
causing ext4_da_update_reserve_space() to incorrectly release the
quota reservations for those boundary clusters.
Later when PUNCH_HOLE removes the DIO-allocated blocks, the
extent removal path detects the pending reservation via
ext4_is_pending() and calls ext4_rereserve_cluster(). This tries
to reclaim quota from dq_dqb.dqb_curspace back to dqb_rsvspace,
but since the quota was already incorrectly released, dqb_curspace
is insufficient, triggering:
WARNING at dquot_reclaim_space_nodirty+0x77c/0x8c0
The subsequent delalloc writeback then fires a second WARN from
dquot_claim_space_nodirty() for the same reason: dqb_rsvspace was
depleted by the earlier incorrect release.
__es_remove_extent() -> get_rsvd() already correctly excludes
boundary clusters that still contain delayed blocks from resv_used.
Adding pending to resv_used double-counts those boundary clusters,
erroneously releasing reservations that are still needed.
Remove the pending variable and the resv_used += pending addition.
Fixes: c543e2429640 ("ext4: update delalloc data reserve spcae in ext4_es_insert_extent()")
Reported-by: Zijing Yin <yzjaurora@gmail.com>
Closes: https://bugzilla.kernel.org/show_bug.cgi?id=221570
Signed-off-by: Qiliang Yuan <realwujing@gmail.com>
---
fs/ext4/extents_status.c | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/fs/ext4/extents_status.c b/fs/ext4/extents_status.c
index 6e4a191e82191..fefe0bb8ac4d1 100644
--- a/fs/ext4/extents_status.c
+++ b/fs/ext4/extents_status.c
@@ -909,7 +909,7 @@ void ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk,
struct extent_status newes;
ext4_lblk_t end = lblk + len - 1;
int err1 = 0, err2 = 0, err3 = 0;
- int resv_used = 0, pending = 0;
+ int resv_used = 0;
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
struct extent_status *es1 = NULL;
struct extent_status *es2 = NULL;
@@ -977,7 +977,6 @@ void ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk,
__free_pending(pr);
pr = NULL;
}
- pending = err3;
}
ext4_es_inc_seq(inode);
error:
@@ -998,7 +997,6 @@ void ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk,
* any previously delayed allocated clusters instead of claim them
* again.
*/
- resv_used += pending;
if (resv_used)
ext4_da_update_reserve_space(inode, resv_used,
delalloc_reserve_used);
---
base-commit: eb3f4b7426cfd2b79d65b7d37155480b32259a11
change-id: 20260528-fix-ext4-bigalloc-punch-hole-quota-v2-2adca315d1ba
Best regards,
--
Qiliang Yuan <realwujing@gmail.com>
^ permalink raw reply related
* Re: [PATCH 0/8] super: retire sget(), convert iterators to RCU
From: Jan Kara @ 2026-05-28 11:18 UTC (permalink / raw)
To: Christian Brauner
Cc: linux-fsdevel, Theodore Ts'o, Andreas Dilger, Jan Kara,
Ritesh Harjani (IBM), linux-ext4, linux-cifs, Alexander Viro
In-Reply-To: <20260526-work-sget-v1-0-263f7025cedd@kernel.org>
On Tue 26-05-26 17:09:02, Christian Brauner wrote:
> * retire sget(): CIFS plus the two ext4 KUnit tests (extents-test,
> mballoc-test) were the last in-tree callers, and all three convert
> cleanly to sget_fc(). That lets sget() and its prototype come out,
> taking ~60 lines that only existed to be kept in lockstep with
> sget_fc() on every publish-path change.
This is definitely a good cleanup!
> * Walk @super_blocks and @type->fs_supers under RCU, pinned by
> refcount_inc_not_zero(&sb->s_count). iterate_supers(),
> iterate_supers_type(), user_get_super(), do_emergency_remount(),
> filesystems_freeze() and filesystems_thaw() no longer hold sb_lock
> across the cursor advance.
>
> The conversion goes in four small steps. Drop sb_lock from
> setup_bdev_super(): the {s_bdev_file, s_bdev, s_bdi,
> SB_I_STABLE_WRITES} tuple is publication of immutable state, and
> SB_BORN already gates every reader via super_wake()'s
> smp_store_release paired with super_flags()'s smp_load_acquire. Then
> convert sb->s_count to refcount_t -- mechanical, every increment is
> still under sb_lock. Then switch the write-side list/hlist ops to
> their _rcu variants; @super_blocks gets list_bidir_del_rcu() so the
> reverse-walking iterators (filesystems_freeze, do_emergency_remount)
> keep a valid ->prev on the unlinked entry, matching the canonical
> pattern in kernel/nstree.c. Finally, convert the iterators themselves:
> cursor advance via READ_ONCE / rcu_dereference, with the previous
> entry kept pinned via its s_count across the rcu_read_unlock ->
> callback -> rcu_read_lock cycle.
So I guess the motivation for getting rid of sb_lock is some contention on
it you can observe? When exactly? It would be nice to mention the
motivation as a justification for the additional complexity...
Honza
>
> Signed-off-by: Christian Brauner (Amutable) <brauner@kernel.org>
> ---
> Christian Brauner (8):
> ext4: convert extents KUnit test to sget_fc()
> ext4: convert mballoc KUnit test to sget_fc()
> smb: client: convert cifs_smb3_do_mount() to sget_fc()
> fs: retire sget()
> super: drop sb_lock from setup_bdev_super() tuple publication
> super: convert sb->s_count to refcount_t
> super: switch list manipulation to _rcu primitives
> super: convert iterators to RCU readers + refcount_inc_not_zero
>
> fs/btrfs/super.c | 2 +-
> fs/ext4/extents-test.c | 22 +++++-
> fs/ext4/mballoc-test.c | 17 ++++-
> fs/smb/client/cifsfs.c | 43 ++++++-----
> fs/smb/client/cifsfs.h | 3 +-
> fs/smb/client/cifsproto.h | 3 +-
> fs/smb/client/connect.c | 5 +-
> fs/smb/client/fs_context.c | 2 +-
> fs/super.c | 167 ++++++++++++++---------------------------
> include/linux/fs.h | 4 -
> include/linux/fs/super_types.h | 3 +-
> 11 files changed, 127 insertions(+), 144 deletions(-)
> ---
> base-commit: 254f49634ee16a731174d2ae34bc50bd5f45e731
> change-id: 20260526-work-sget-6bc80b96cba5
>
--
Jan Kara <jack@suse.com>
SUSE Labs, CR
^ permalink raw reply
* Re: [PATCH] ext4: Remove mention of PageWriteback
From: Jan Kara @ 2026-05-28 11:41 UTC (permalink / raw)
To: Matthew Wilcox (Oracle)
Cc: Theodore Ts'o, Andreas Dilger, Baokun Li, Jan Kara,
Ojaswin Mujoo, Ritesh Harjani (IBM), Zhang Yi, linux-ext4,
linux-kernel
In-Reply-To: <20260526190805.341676-1-willy@infradead.org>
On Tue 26-05-26 20:08:02, Matthew Wilcox (Oracle) wrote:
> Update a comment to refer to the concept of writeback instead of the
> (now obsolete) detail of how it's implemented.
>
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Looks good. Feel free to add:
Reviewed-by: Jan Kara <jack@suse.cz>
Honza
> ---
> fs/ext4/page-io.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
> index dc82e7b57e75..bc674aa4a656 100644
> --- a/fs/ext4/page-io.c
> +++ b/fs/ext4/page-io.c
> @@ -168,7 +168,7 @@ static void ext4_release_io_end(ext4_io_end_t *io_end)
> * written. On IO failure, check if journal abort is needed. Note that
> * we are protected from truncate touching same part of extent tree by the
> * fact that truncate code waits for all DIO to finish (thus exclusion from
> - * direct IO is achieved) and also waits for PageWriteback bits. Thus we
> + * direct IO is achieved) and also waits for writeback to complete. Thus we
> * cannot get to ext4_ext_truncate() before all IOs overlapping that range are
> * completed (happens from ext4_free_ioend()).
> */
> --
> 2.47.3
>
--
Jan Kara <jack@suse.com>
SUSE Labs, CR
^ permalink raw reply
* Re: [PATCH 14/17] fs/namespace: use __getname() to allocate mntpath buffer
From: Christian Brauner @ 2026-05-28 11:54 UTC (permalink / raw)
To: Mike Rapoport
Cc: Jan Kara, Jan Kara, Mark Fasheh, Joel Becker, Joseph Qi,
Ryusuke Konishi, Viacheslav Dubeyko, Trond Myklebust,
Anna Schumaker, Chuck Lever, Jeff Layton, NeilBrown,
Olga Kornievskaia, Dai Ngo, Tom Talpey, Alexander Viro,
Dave Kleikamp, Theodore Ts'o, Miklos Szeredi,
Andreas Hindborg, Breno Leitao, Kees Cook, Tigran A. Aivazian,
linux-kernel, linux-fsdevel, ocfs2-devel, linux-nilfs, linux-nfs,
jfs-discussion, linux-ext4, linux-mm
In-Reply-To: <ahVisehwQGXEoM0g@kernel.org>
On Tue, May 26, 2026 at 12:06:57PM +0300, Mike Rapoport wrote:
> On Mon, May 25, 2026 at 06:22:13PM +0200, Jan Kara wrote:
> > On Sat 23-05-26 20:54:26, Mike Rapoport (Microsoft) wrote:
> > > mnt_warn_timestamp_expiry() allocates memory for a path with
> > > __get_free_page() although there is a dedicated helper for allocation of
> > > file paths: __getname().
> > >
> > > Replace __get_free_page() for allocation of a path buffer with __getname().
> > >
> > > Signed-off-by: Mike Rapoport (Microsoft) <rppt@kernel.org>
> > > ---
> > > fs/namespace.c | 4 ++--
> > > 1 file changed, 2 insertions(+), 2 deletions(-)
> > >
> > > diff --git a/fs/namespace.c b/fs/namespace.c
> > > index fe919abd2f01..2ed9cd846a81 100644
> > > --- a/fs/namespace.c
> > > +++ b/fs/namespace.c
> > > @@ -3303,7 +3303,7 @@ static void mnt_warn_timestamp_expiry(const struct path *mountpoint,
> > > (ktime_get_real_seconds() + TIME_UPTIME_SEC_MAX > sb->s_time_max)) {
> > > char *buf, *mntpath;
> > >
> > > - buf = (char *)__get_free_page(GFP_KERNEL);
> > > + buf = __getname();
> >
> > Fair but d_path() below should then get PATH_MAX and not PAGE_SIZE.
>
> Ack.
>
> > > if (buf)
> > > mntpath = d_path(mountpoint, buf, PAGE_SIZE);
> > > else
> > > @@ -3319,7 +3319,7 @@ static void mnt_warn_timestamp_expiry(const struct path *mountpoint,
> > >
> > > sb->s_iflags |= SB_I_TS_EXPIRY_WARNED;
> > > if (buf)
> > > - free_page((unsigned long)buf);
> > > + __putname(buf);
> >
> > And __putname() is fine with NULL so no need for the if (buf) check here.
>
> Will fix.
I've folded this myself.
^ permalink raw reply
* Re: [PATCH 2/8] ext4: convert mballoc KUnit test to sget_fc()
From: Christian Brauner @ 2026-05-28 12:02 UTC (permalink / raw)
To: Theodore Tso
Cc: linux-fsdevel, Andreas Dilger, Jan Kara, Ritesh Harjani (IBM),
linux-ext4, linux-cifs, Alexander Viro
In-Reply-To: <ny6ggedljk3celsnnaaczpehmgll6hqrglqc44ku53cmxrclx5@w4qby54x6mff>
On Tue, May 26, 2026 at 07:47:27PM -0500, Theodore Ts'o wrote:
> On Tue, May 26, 2026 at 05:09:04PM +0200, Christian Brauner wrote:
> > Add a no-op mbt_init_fs_context() so fs_context_for_mount() has
> > something to call on the fake fs_type....
>
> I was trying to figure out what needed to be in an init_fs_context()
> functrion, and I came accross this in
> Documentation/filesystems/mount_api.rst:
>
> const struct fs_context_operations *ops
>
> These are operations that can be done on a filesystem context (see
> below). This must be set by the ->init_fs_context() file_system_type
> operation. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>
> So is it safe to just have an init_fs_context() function which doesn't
> do this?
>
> > +static int mbt_init_fs_context(struct fs_context *fc)
> > +{
> > + return 0;
> > +}
> > +
>
> I see in fs/fs_context.c that in some places the code protects against
> a NULL ops pointer:
>
> if (fc->need_free && fc->ops && fc->ops->free)
> fc->ops->free(fc);
>
> But in other places, it doesn't and we'll end up derefrencing a null
> pointer:
>
> if (fc->ops->parse_param) {
> ret = fc->ops->parse_param(fc, param);
>
> ....
>
> So it's unclear to me --- when is it safe (and not safe) to not bother
> to fill in the ops pointer?
Hey Ted!
In these two cases it's fine. Because you're just using the allocation
and deallocation functions to get a fs_context that's basically just an
empty vessel to get at a superblock via sget_fc() but you're not really
doing anything with it.
IOW, you can never end up in callchains that cause issues.
^ permalink raw reply
* Re: [PATCH v10 00/22] fs-verity support for XFS with post EOF merkle tree
From: Christian Brauner @ 2026-05-28 12:20 UTC (permalink / raw)
To: Carlos Maiolino
Cc: Christoph Hellwig, Andrey Albershteyn, Andrey Albershteyn,
linux-xfs, fsverity, linux-fsdevel, ebiggers, linux-ext4,
linux-f2fs-devel, linux-btrfs, linux-unionfs, djwong, david
In-Reply-To: <ahVzkf8JoKP-kSC2@nidhogg.toxiclabs.cc>
On Tue, May 26, 2026 at 12:19:43PM +0200, Carlos Maiolino wrote:
> On Fri, May 22, 2026 at 02:07:57PM +0200, Christoph Hellwig wrote:
> > On Fri, May 22, 2026 at 12:03:20PM +0200, Christian Brauner wrote:
> > > > I was expecting this to come through xfs tree too if Eric and Christian
> > > > agree.
> > >
> > > You may take it through the xfs tree if there are no conflicts with
> > > vfs-7.2.iomap. If there are I want to add the iomap changes into
> > > vfs-7.2.iomap that you can pull in.
> >
> > Merging the iomap bits through the iomap branch might make sense, given
> > that iomap usually tends to see quite a bit of activity.
> >
>
> That sounds good to me. If you want to go ahead and pull in the iomap
> bits, do so, and give me a heads up when you do it so I'll pull your
> branch locally.
Great, can the series please be resent based on current vfs-7.2.iomap
then please? Because the iomap changes in this series don't apply
cleanly on vfs-7.2.iomap so we already have merge conflicts...
^ permalink raw reply
* Re: [PATCH 0/4] fs: mark selected blocking waits as freezable
From: Christian Brauner @ 2026-05-28 12:51 UTC (permalink / raw)
To: linux-fsdevel, viro, tytso, jack, linux-ext4, Dai Junbing
Cc: jack, linux-kernel
In-Reply-To: <20260527064912.1038-1-daijunbing@vivo.com>
On Wed, 27 May 2026 14:49:08 +0800, Dai Junbing wrote:
> fs: mark selected blocking waits as freezable
>
> Hi,
>
> During suspend and resume, tasks blocked in some interruptible wait
> paths may be unnecessarily woken due to freezer state transitions. This
> can introduce avoidable activity in the suspend/resume path.
>
> [...]
Applied to the vfs-7.2.misc branch of the vfs/vfs.git tree.
Patches in the vfs-7.2.misc branch should appear in linux-next soon.
Please report any outstanding bugs that were missed during review in a
new review to the original patch series allowing us to drop it.
It's encouraged to provide Acked-bys and Reviewed-bys even though the
patch has now been applied. If possible patch trailers will be updated.
Note that commit hashes shown below are subject to change due to rebase,
trailer updates or similar. If in doubt, please check the listed branch.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git
branch: vfs-7.2.misc
[1/4] eventpoll: mark ep_poll() sleep as freezable
https://git.kernel.org/vfs/vfs/c/f5437433c37d
[2/4] jbd2: make kjournald2 commit wait freezable
https://git.kernel.org/vfs/vfs/c/10c6b259fb56
[3/4] pipe: mark blocking pipe read and FIFO open sleeps as freezable
https://git.kernel.org/vfs/vfs/c/6e5e03a76bee
[4/4] select: make select() and poll() waits freezable
https://git.kernel.org/vfs/vfs/c/f837c1dbd121
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox