Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
filesystems
lustre_2_15
0018-0004-LU-16843-ldiskfs-merge-extent-blocks....
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File 0018-0004-LU-16843-ldiskfs-merge-extent-blocks.patch of Package lustre_2_15
From 0f7e6c02a9ea5b85d8d97f724bed318268cea60f Mon Sep 17 00:00:00 2001 From: Alex Zhuravlev <bzzz@whamcloud.com> Date: Tue, 23 May 2023 16:30:58 +0300 Subject: [PATCH] LU-16843 ldiskfs: merge extent blocks There are cases (e.g. file written synchronously with discontiguous blocks that are later filled in) when a lot of extents are created initially, then the extents get merged over time, but there is no way to merge the index blocks. This can cause a very deep extent index tree (above 5 levels) and cause problems like: inode has invalid extent depth: 6 Merge leave/index blocks (one at each level at most) to right/left when extents are removed from the index. submitted to ext4@ maillist: https://lore.kernel.org/linux-ext4/7A2B8861-96AA-4815-BB58-180F63F62436@whamcloud.com/ Signed-off-by: Alex Zhuravlev <bzzz@whamcloud.com> Change-Id: I746c0917e746eb442d3c69a23f591d9cdade76fa Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/51096 Tested-by: jenkins <devops@whamcloud.com> Tested-by: Maloo <maloo@whamcloud.com> Reviewed-by: Artem Blagodarenko <ablagodarenko@ddn.com> Reviewed-by: Andreas Dilger <adilger@whamcloud.com> Reviewed-by: Oleg Drokin <green@whamcloud.com> --- .../patches/rhel7.9/ext4-ext-merge.patch | 220 ++++++++++++++++++ .../patches/rhel8/ext4-ext-merge.patch | 220 ++++++++++++++++++ .../series/ldiskfs-3.10-rhel7.9.series | 1 + .../series/ldiskfs-4.12-sles15sp1-7.series | 1 + .../series/ldiskfs-4.12-sles15sp1.series | 1 + .../series/ldiskfs-4.18-rhel8.7.series | 1 + .../series/ldiskfs-4.18-rhel8.8.series | 1 + .../series/ldiskfs-5.14-rhel9.1.series | 1 + .../series/ldiskfs-5.14-rhel9.2.series | 1 + .../series/ldiskfs-5.14.21-sles15sp4.series | 1 + .../series/ldiskfs-5.14.21-sles15sp5.series | 1 + .../series/ldiskfs-5.3.18-sles15sp3.series | 1 + 12 files changed, 450 insertions(+) create mode 100644 ldiskfs/kernel_patches/patches/rhel7.9/ext4-ext-merge.patch create mode 100644 ldiskfs/kernel_patches/patches/rhel8/ext4-ext-merge.patch diff --git a/ldiskfs/kernel_patches/patches/rhel7.9/ext4-ext-merge.patch b/ldiskfs/kernel_patches/patches/rhel7.9/ext4-ext-merge.patch new file mode 100644 index 000000000000..40d0b1e7145a --- /dev/null +++ b/ldiskfs/kernel_patches/patches/rhel7.9/ext4-ext-merge.patch @@ -0,0 +1,220 @@ +Index: linux-4.18.0-80.1.2.el8_0/fs/ext4/extents.c +=================================================================== +--- linux-4.18.0-80.1.2.el8_0.orig/fs/ext4/extents.c ++++ linux-4.18.0-80.1.2.el8_0/fs/ext4/extents.c +@@ -1888,7 +1944,7 @@ static void ext4_ext_try_to_merge_up( + * This function tries to merge the @ex extent to neighbours in the tree, then + * tries to collapse the extent tree into the inode. + */ +-static void ext4_ext_try_to_merge(handle_t *handle, ++static int ext4_ext_try_to_merge(handle_t *handle, + struct inode *inode, + struct ext4_ext_path *path, + struct ext4_extent *ex) +@@ -1905,9 +1961,178 @@ static void ext4_ext_try_to_merge(han + merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1); + + if (!merge_done) +- (void) ext4_ext_try_to_merge_right(inode, path, ex); ++ merge_done = ext4_ext_try_to_merge_right(inode, path, ex); + + ext4_ext_try_to_merge_up(handle, inode, path); ++ ++ return merge_done; ++} ++ ++/* ++ * This function tries to merge blocks from @path into @npath ++ */ ++static int ext4_ext_merge_blocks(handle_t *handle, ++ struct inode *inode, ++ struct ext4_ext_path *path, ++ struct ext4_ext_path *npath) ++{ ++ unsigned int depth = ext_depth(inode); ++ int used, nused, free, i, k, err; ++ ext4_lblk_t next; ++ ++ if (path[depth].p_hdr == npath[depth].p_hdr) ++ return 0; ++ ++ used = le16_to_cpu(path[depth].p_hdr->eh_entries); ++ free = le16_to_cpu(npath[depth].p_hdr->eh_max) - ++ le16_to_cpu(npath[depth].p_hdr->eh_entries); ++ if (free < used) ++ return 0; ++ ++ err = ext4_ext_get_access(handle, inode, path + depth); ++ if (err) ++ return err; ++ err = ext4_ext_get_access(handle, inode, npath + depth); ++ if (err) ++ return err; ++ ++ /* move entries from the current leave to the next one */ ++ nused = le16_to_cpu(npath[depth].p_hdr->eh_entries); ++ memmove(EXT_FIRST_EXTENT(npath[depth].p_hdr) + used, ++ EXT_FIRST_EXTENT(npath[depth].p_hdr), ++ nused * sizeof(struct ext4_extent)); ++ memcpy(EXT_FIRST_EXTENT(npath[depth].p_hdr), ++ EXT_FIRST_EXTENT(path[depth].p_hdr), ++ used * sizeof(struct ext4_extent)); ++ le16_add_cpu(&npath[depth].p_hdr->eh_entries, used); ++ le16_add_cpu(&path[depth].p_hdr->eh_entries, -used); ++ ext4_ext_try_to_merge_right(inode, npath, ++ EXT_FIRST_EXTENT(npath[depth].p_hdr)); ++ ++ err = ext4_ext_dirty(handle, inode, path + depth); ++ if (err) ++ return err; ++ err = ext4_ext_dirty(handle, inode, npath + depth); ++ if (err) ++ return err; ++ ++ /* otherwise the index won't get corrected */ ++ npath[depth].p_ext = EXT_FIRST_EXTENT(npath[depth].p_hdr); ++ err = ext4_ext_correct_indexes(handle, inode, npath); ++ if (err) ++ return err; ++ ++ for (i = depth - 1; i >= 0; i--) { ++ ++ next = ext4_idx_pblock(path[i].p_idx); ++ ext4_free_blocks(handle, inode, NULL, next, 1, ++ EXT4_FREE_BLOCKS_METADATA | ++ EXT4_FREE_BLOCKS_FORGET); ++ err = ext4_ext_get_access(handle, inode, path + i); ++ if (err) ++ return err; ++ le16_add_cpu(&path[i].p_hdr->eh_entries, -1); ++ if (le16_to_cpu(path[i].p_hdr->eh_entries) == 0) { ++ /* whole index block collapsed, go up */ ++ continue; ++ } ++ /* remove index pointer */ ++ used = EXT_LAST_INDEX(path[i].p_hdr) - path[i].p_idx + 1; ++ memmove(path[i].p_idx, path[i].p_idx + 1, ++ used * sizeof(struct ext4_extent_idx)); ++ ++ err = ext4_ext_dirty(handle, inode, path + i); ++ if (err) ++ return err; ++ ++ if (path[i].p_hdr == npath[i].p_hdr) ++ break; ++ ++ /* try to move index pointers */ ++ used = le16_to_cpu(path[i].p_hdr->eh_entries); ++ free = le16_to_cpu(npath[i].p_hdr->eh_max) - ++ le16_to_cpu(npath[i].p_hdr->eh_entries); ++ if (used > free) ++ break; ++ err = ext4_ext_get_access(handle, inode, npath + i); ++ if (err) ++ return err; ++ memmove(EXT_FIRST_INDEX(npath[i].p_hdr) + used, ++ EXT_FIRST_INDEX(npath[i].p_hdr), ++ npath[i].p_hdr->eh_entries * sizeof(struct ext4_extent_idx)); ++ memcpy(EXT_FIRST_INDEX(npath[i].p_hdr), EXT_FIRST_INDEX(path[i].p_hdr), ++ used * sizeof(struct ext4_extent_idx)); ++ le16_add_cpu(&path[i].p_hdr->eh_entries, -used); ++ le16_add_cpu(&npath[i].p_hdr->eh_entries, used); ++ err = ext4_ext_dirty(handle, inode, path + i); ++ if (err) ++ return err; ++ err = ext4_ext_dirty(handle, inode, npath + i); ++ if (err) ++ return err; ++ ++ /* correct index above */ ++ for (k = i; k > 0; k--) { ++ err = ext4_ext_get_access(handle, inode, npath + k - 1); ++ if (err) ++ return err; ++ npath[k-1].p_idx->ei_block = ++ EXT_FIRST_INDEX(npath[k].p_hdr)->ei_block; ++ err = ext4_ext_dirty(handle, inode, npath + k - 1); ++ if (err) ++ return err; ++ } ++ } ++ ++ /* ++ * TODO: given we've got two paths, it should be possible to ++ * collapse those two blocks into the root one in some cases ++ */ ++ return 1; ++} ++ ++static int ext4_ext_try_to_merge_blocks(handle_t *handle, ++ struct inode *inode, ++ struct ext4_ext_path *path) ++{ ++ struct ext4_ext_path *npath = NULL; ++ unsigned int depth = ext_depth(inode); ++ ext4_lblk_t next; ++ int used, rc = 0; ++ ++ if (depth == 0) ++ return 0; ++ ++ used = le16_to_cpu(path[depth].p_hdr->eh_entries); ++ /* don't be too agressive as checking space in ++ * the next block is not free */ ++ if (used > ext4_ext_space_block(inode, 0) / 4) ++ return 0; ++ ++ /* try to merge to the next block */ ++ next = ext4_ext_next_leaf_block(path); ++ if (next == EXT_MAX_BLOCKS) ++ return 0; ++ npath = ext4_ext_find_extent(inode, next, NULL, 0); ++ if (IS_ERR(npath)) ++ return 0; ++ rc = ext4_ext_merge_blocks(handle, inode, path, npath); ++ ext4_ext_drop_refs(npath); ++ kfree(npath); ++ if (rc) ++ return rc > 0 ? 0 : rc; ++ ++ /* try to merge with the previous block */ ++ if (EXT_FIRST_EXTENT(path[depth].p_hdr)->ee_block == 0) ++ return 0; ++ next = EXT_FIRST_EXTENT(path[depth].p_hdr)->ee_block - 1; ++ npath = ext4_ext_find_extent(inode, next, NULL, 0); ++ if (IS_ERR(npath)) ++ return 0; ++ rc = ext4_ext_merge_blocks(handle, inode, npath, path); ++ ext4_ext_drop_refs(npath); ++ kfree(npath); ++ return rc > 0 ? 0 : rc; + } + + /* +@@ -1979,6 +2205,7 @@ int ext4_ext_insert_extent(handle_t * + int depth, len, err; + ext4_lblk_t next; + int mb_flags = 0, unwritten; ++ int merged = 0; + + if (gb_flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) + mb_flags |= EXT4_MB_DELALLOC_RESERVED; +@@ -2172,8 +2399,7 @@ has_space: + merge: + /* try to merge extents */ + if (!(gb_flags & EXT4_GET_BLOCKS_PRE_IO)) +- ext4_ext_try_to_merge(handle, inode, path, nearex); +- ++ merged = ext4_ext_try_to_merge(handle, inode, path, nearex); + + /* time to correct all indexes above */ + err = ext4_ext_correct_indexes(handle, inode, path); +@@ -2181,6 +2407,8 @@ merge: + goto cleanup; + + err = ext4_ext_dirty(handle, inode, path + path->p_depth); ++ if (!err && merged) ++ err = ext4_ext_try_to_merge_blocks(handle, inode, path); + + cleanup: + ext4_ext_drop_refs(npath); diff --git a/ldiskfs/kernel_patches/patches/rhel8/ext4-ext-merge.patch b/ldiskfs/kernel_patches/patches/rhel8/ext4-ext-merge.patch new file mode 100644 index 000000000000..cc2142e4dd35 --- /dev/null +++ b/ldiskfs/kernel_patches/patches/rhel8/ext4-ext-merge.patch @@ -0,0 +1,220 @@ +Index: linux-4.18.0-80.1.2.el8_0/fs/ext4/extents.c +=================================================================== +--- linux-4.18.0-80.1.2.el8_0.orig/fs/ext4/extents.c ++++ linux-4.18.0-80.1.2.el8_0/fs/ext4/extents.c +@@ -1888,7 +1944,7 @@ static void ext4_ext_try_to_merge_up( + * This function tries to merge the @ex extent to neighbours in the tree, then + * tries to collapse the extent tree into the inode. + */ +-static void ext4_ext_try_to_merge(handle_t *handle, ++static int ext4_ext_try_to_merge(handle_t *handle, + struct inode *inode, + struct ext4_ext_path *path, + struct ext4_extent *ex) +@@ -1905,9 +1961,178 @@ static void ext4_ext_try_to_merge(han + merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1); + + if (!merge_done) +- (void) ext4_ext_try_to_merge_right(inode, path, ex); ++ merge_done = ext4_ext_try_to_merge_right(inode, path, ex); + + ext4_ext_try_to_merge_up(handle, inode, path); ++ ++ return merge_done; ++} ++ ++/* ++ * This function tries to merge blocks from @path into @npath ++ */ ++static int ext4_ext_merge_blocks(handle_t *handle, ++ struct inode *inode, ++ struct ext4_ext_path *path, ++ struct ext4_ext_path *npath) ++{ ++ unsigned int depth = ext_depth(inode); ++ int used, nused, free, i, k, err; ++ ext4_lblk_t next; ++ ++ if (path[depth].p_hdr == npath[depth].p_hdr) ++ return 0; ++ ++ used = le16_to_cpu(path[depth].p_hdr->eh_entries); ++ free = le16_to_cpu(npath[depth].p_hdr->eh_max) - ++ le16_to_cpu(npath[depth].p_hdr->eh_entries); ++ if (free < used) ++ return 0; ++ ++ err = ext4_ext_get_access(handle, inode, path + depth); ++ if (err) ++ return err; ++ err = ext4_ext_get_access(handle, inode, npath + depth); ++ if (err) ++ return err; ++ ++ /* move entries from the current leave to the next one */ ++ nused = le16_to_cpu(npath[depth].p_hdr->eh_entries); ++ memmove(EXT_FIRST_EXTENT(npath[depth].p_hdr) + used, ++ EXT_FIRST_EXTENT(npath[depth].p_hdr), ++ nused * sizeof(struct ext4_extent)); ++ memcpy(EXT_FIRST_EXTENT(npath[depth].p_hdr), ++ EXT_FIRST_EXTENT(path[depth].p_hdr), ++ used * sizeof(struct ext4_extent)); ++ le16_add_cpu(&npath[depth].p_hdr->eh_entries, used); ++ le16_add_cpu(&path[depth].p_hdr->eh_entries, -used); ++ ext4_ext_try_to_merge_right(inode, npath, ++ EXT_FIRST_EXTENT(npath[depth].p_hdr)); ++ ++ err = ext4_ext_dirty(handle, inode, path + depth); ++ if (err) ++ return err; ++ err = ext4_ext_dirty(handle, inode, npath + depth); ++ if (err) ++ return err; ++ ++ /* otherwise the index won't get corrected */ ++ npath[depth].p_ext = EXT_FIRST_EXTENT(npath[depth].p_hdr); ++ err = ext4_ext_correct_indexes(handle, inode, npath); ++ if (err) ++ return err; ++ ++ for (i = depth - 1; i >= 0; i--) { ++ ++ next = ext4_idx_pblock(path[i].p_idx); ++ ext4_free_blocks(handle, inode, NULL, next, 1, ++ EXT4_FREE_BLOCKS_METADATA | ++ EXT4_FREE_BLOCKS_FORGET); ++ err = ext4_ext_get_access(handle, inode, path + i); ++ if (err) ++ return err; ++ le16_add_cpu(&path[i].p_hdr->eh_entries, -1); ++ if (le16_to_cpu(path[i].p_hdr->eh_entries) == 0) { ++ /* whole index block collapsed, go up */ ++ continue; ++ } ++ /* remove index pointer */ ++ used = EXT_LAST_INDEX(path[i].p_hdr) - path[i].p_idx + 1; ++ memmove(path[i].p_idx, path[i].p_idx + 1, ++ used * sizeof(struct ext4_extent_idx)); ++ ++ err = ext4_ext_dirty(handle, inode, path + i); ++ if (err) ++ return err; ++ ++ if (path[i].p_hdr == npath[i].p_hdr) ++ break; ++ ++ /* try to move index pointers */ ++ used = le16_to_cpu(path[i].p_hdr->eh_entries); ++ free = le16_to_cpu(npath[i].p_hdr->eh_max) - ++ le16_to_cpu(npath[i].p_hdr->eh_entries); ++ if (used > free) ++ break; ++ err = ext4_ext_get_access(handle, inode, npath + i); ++ if (err) ++ return err; ++ memmove(EXT_FIRST_INDEX(npath[i].p_hdr) + used, ++ EXT_FIRST_INDEX(npath[i].p_hdr), ++ npath[i].p_hdr->eh_entries * sizeof(struct ext4_extent_idx)); ++ memcpy(EXT_FIRST_INDEX(npath[i].p_hdr), EXT_FIRST_INDEX(path[i].p_hdr), ++ used * sizeof(struct ext4_extent_idx)); ++ le16_add_cpu(&path[i].p_hdr->eh_entries, -used); ++ le16_add_cpu(&npath[i].p_hdr->eh_entries, used); ++ err = ext4_ext_dirty(handle, inode, path + i); ++ if (err) ++ return err; ++ err = ext4_ext_dirty(handle, inode, npath + i); ++ if (err) ++ return err; ++ ++ /* correct index above */ ++ for (k = i; k > 0; k--) { ++ err = ext4_ext_get_access(handle, inode, npath + k - 1); ++ if (err) ++ return err; ++ npath[k-1].p_idx->ei_block = ++ EXT_FIRST_INDEX(npath[k].p_hdr)->ei_block; ++ err = ext4_ext_dirty(handle, inode, npath + k - 1); ++ if (err) ++ return err; ++ } ++ } ++ ++ /* ++ * TODO: given we've got two paths, it should be possible to ++ * collapse those two blocks into the root one in some cases ++ */ ++ return 1; ++} ++ ++static int ext4_ext_try_to_merge_blocks(handle_t *handle, ++ struct inode *inode, ++ struct ext4_ext_path *path) ++{ ++ struct ext4_ext_path *npath = NULL; ++ unsigned int depth = ext_depth(inode); ++ ext4_lblk_t next; ++ int used, rc = 0; ++ ++ if (depth == 0) ++ return 0; ++ ++ used = le16_to_cpu(path[depth].p_hdr->eh_entries); ++ /* don't be too agressive as checking space in ++ * the next block is not free */ ++ if (used > ext4_ext_space_block(inode, 0) / 4) ++ return 0; ++ ++ /* try to merge to the next block */ ++ next = ext4_ext_next_leaf_block(path); ++ if (next == EXT_MAX_BLOCKS) ++ return 0; ++ npath = ext4_find_extent(inode, next, NULL, 0); ++ if (IS_ERR(npath)) ++ return 0; ++ rc = ext4_ext_merge_blocks(handle, inode, path, npath); ++ ext4_ext_drop_refs(npath); ++ kfree(npath); ++ if (rc) ++ return rc > 0 ? 0 : rc; ++ ++ /* try to merge with the previous block */ ++ if (EXT_FIRST_EXTENT(path[depth].p_hdr)->ee_block == 0) ++ return 0; ++ next = EXT_FIRST_EXTENT(path[depth].p_hdr)->ee_block - 1; ++ npath = ext4_find_extent(inode, next, NULL, 0); ++ if (IS_ERR(npath)) ++ return 0; ++ rc = ext4_ext_merge_blocks(handle, inode, npath, path); ++ ext4_ext_drop_refs(npath); ++ kfree(npath); ++ return rc > 0 ? 0 : rc; + } + + /* +@@ -1979,6 +2205,7 @@ int ext4_ext_insert_extent(handle_t * + int depth, len, err; + ext4_lblk_t next; + int mb_flags = 0, unwritten; ++ int merged = 0; + + if (gb_flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) + mb_flags |= EXT4_MB_DELALLOC_RESERVED; +@@ -2172,8 +2399,7 @@ has_space: + merge: + /* try to merge extents */ + if (!(gb_flags & EXT4_GET_BLOCKS_PRE_IO)) +- ext4_ext_try_to_merge(handle, inode, path, nearex); +- ++ merged = ext4_ext_try_to_merge(handle, inode, path, nearex); + + /* time to correct all indexes above */ + err = ext4_ext_correct_indexes(handle, inode, path); +@@ -2181,6 +2407,8 @@ merge: + goto cleanup; + + err = ext4_ext_dirty(handle, inode, path + path->p_depth); ++ if (!err && merged) ++ err = ext4_ext_try_to_merge_blocks(handle, inode, path); + + cleanup: + ext4_ext_drop_refs(npath); diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.12-sles15sp1-7.series b/ldiskfs/kernel_patches/series/ldiskfs-4.12-sles15sp1-7.series index e8a84209436b..a497b848a590 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.12-sles15sp1-7.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.12-sles15sp1-7.series @@ -24,6 +24,7 @@ suse15/ext4-dont-check-before-replay.patch rhel7.6/ext4-use-GFP_NOFS-in-ext4_inode_attach_jinode.patch rhel7.6/ext4-optimize-ext4_find_delalloc_range-in-nodelalloc.patch rhel7.6/ext4-export-orphan-add.patch +rhel8/ext4-ext-merge.patch suse15/ext4-export-mb-stream-allocator-variables.patch base/ext4-no-max-dir-size-limit-for-iam-objects.patch rhel7.7/ext4-ialloc-uid-gid-and-pass-owner-down.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.12-sles15sp1.series b/ldiskfs/kernel_patches/series/ldiskfs-4.12-sles15sp1.series index a51161a740f2..124d2ccabe12 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.12-sles15sp1.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.12-sles15sp1.series @@ -24,6 +24,7 @@ suse15/ext4-dont-check-before-replay.patch rhel7.6/ext4-use-GFP_NOFS-in-ext4_inode_attach_jinode.patch rhel7.6/ext4-optimize-ext4_find_delalloc_range-in-nodelalloc.patch rhel7.6/ext4-export-orphan-add.patch +rhel8/ext4-ext-merge.patch suse15/ext4-export-mb-stream-allocator-variables.patch base/ext4-no-max-dir-size-limit-for-iam-objects.patch rhel7.7/ext4-ialloc-uid-gid-and-pass-owner-down.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp4.series b/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp4.series index d9ade0491663..e07353da9d42 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp4.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp4.series @@ -27,6 +27,7 @@ linux-5.8/ext4-no-max-dir-size-limit-for-iam-objects.patch linux-5.14/ext4-ialloc-uid-gid-and-pass-owner-down.patch linux-5.14/ext4-projid-xattrs.patch base/ext4-delayed-iput.patch +rhel8/ext4-ext-merge.patch linux-5.14/ext4-xattr-disable-credits-check.patch linux-5.10/ext4-fiemap-kernel-data.patch rhel8/ext4-old_ea_inodes_handling_fix.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-5.3.18-sles15sp3.series b/ldiskfs/kernel_patches/series/ldiskfs-5.3.18-sles15sp3.series index 7c650b04ad9b..8eae8ad05868 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-5.3.18-sles15sp3.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-5.3.18-sles15sp3.series @@ -28,6 +28,7 @@ rhel8/ext4-simple-blockalloc.patch rhel8/ext4-xattr-disable-credits-check.patch base/ext4-no-max-dir-size-limit-for-iam-objects.patch rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch +rhel8/ext4-ext-merge.patch base/ext4-projid-xattrs.patch linux-5.8/ext4-enc-flag.patch rhel8/ext4-old_ea_inodes_handling_fix.patch -- 2.40.1
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
