* Re: [PATCH v2] ext4: clear extent index structure after file delete
2025-07-18 12:26 [PATCH v2] ext4: clear extent index structure after file delete Nicolas Bretz
@ 2025-07-20 22:41 ` kernel test robot
0 siblings, 0 replies; 2+ messages in thread
From: kernel test robot @ 2025-07-20 22:41 UTC (permalink / raw)
To: Nicolas Bretz, tytso, adilger.kernel
Cc: oe-kbuild-all, linux-ext4, Nicolas Bretz, kernel test robot
Hi Nicolas,
kernel test robot noticed the following build warnings:
[auto build test WARNING on tytso-ext4/dev]
[also build test WARNING on linus/master v6.16-rc6 next-20250718]
[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/Nicolas-Bretz/ext4-clear-extent-index-structure-after-file-delete/20250718-202802
base: https://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4.git dev
patch link: https://lore.kernel.org/r/20250718122654.1431747-1-bretznic%40gmail.com
patch subject: [PATCH v2] ext4: clear extent index structure after file delete
config: csky-randconfig-r121-20250720 (https://download.01.org/0day-ci/archive/20250721/202507210558.sazSHcm1-lkp@intel.com/config)
compiler: csky-linux-gcc (GCC) 11.5.0
reproduce: (https://download.01.org/0day-ci/archive/20250721/202507210558.sazSHcm1-lkp@intel.com/reproduce)
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/202507210558.sazSHcm1-lkp@intel.com/
sparse warnings: (new ones prefixed by >>)
>> fs/ext4/extents.c:3065:55: sparse: sparse: restricted __le16 degrades to integer
vim +3065 fs/ext4/extents.c
2818
2819 int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
2820 ext4_lblk_t end)
2821 {
2822 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2823 int depth = ext_depth(inode);
2824 struct ext4_ext_path *path = NULL;
2825 struct ext4_extent_idx *ix = NULL;
2826 struct partial_cluster partial;
2827 handle_t *handle;
2828 int i = 0, err = 0;
2829 int flags = EXT4_EX_NOCACHE | EXT4_EX_NOFAIL;
2830
2831 partial.pclu = 0;
2832 partial.lblk = 0;
2833 partial.state = initial;
2834
2835 ext_debug(inode, "truncate since %u to %u\n", start, end);
2836
2837 /* probably first extent we're gonna free will be last in block */
2838 handle = ext4_journal_start_with_revoke(inode, EXT4_HT_TRUNCATE,
2839 depth + 1,
2840 ext4_free_metadata_revoke_credits(inode->i_sb, depth));
2841 if (IS_ERR(handle))
2842 return PTR_ERR(handle);
2843
2844 again:
2845 trace_ext4_ext_remove_space(inode, start, end, depth);
2846
2847 /*
2848 * Check if we are removing extents inside the extent tree. If that
2849 * is the case, we are going to punch a hole inside the extent tree
2850 * so we have to check whether we need to split the extent covering
2851 * the last block to remove so we can easily remove the part of it
2852 * in ext4_ext_rm_leaf().
2853 */
2854 if (end < EXT_MAX_BLOCKS - 1) {
2855 struct ext4_extent *ex;
2856 ext4_lblk_t ee_block, ex_end, lblk;
2857 ext4_fsblk_t pblk;
2858
2859 /* find extent for or closest extent to this block */
2860 path = ext4_find_extent(inode, end, NULL, flags);
2861 if (IS_ERR(path)) {
2862 ext4_journal_stop(handle);
2863 return PTR_ERR(path);
2864 }
2865 depth = ext_depth(inode);
2866 /* Leaf not may not exist only if inode has no blocks at all */
2867 ex = path[depth].p_ext;
2868 if (!ex) {
2869 if (depth) {
2870 EXT4_ERROR_INODE(inode,
2871 "path[%d].p_hdr == NULL",
2872 depth);
2873 err = -EFSCORRUPTED;
2874 }
2875 goto out;
2876 }
2877
2878 ee_block = le32_to_cpu(ex->ee_block);
2879 ex_end = ee_block + ext4_ext_get_actual_len(ex) - 1;
2880
2881 /*
2882 * See if the last block is inside the extent, if so split
2883 * the extent at 'end' block so we can easily remove the
2884 * tail of the first part of the split extent in
2885 * ext4_ext_rm_leaf().
2886 */
2887 if (end >= ee_block && end < ex_end) {
2888
2889 /*
2890 * If we're going to split the extent, note that
2891 * the cluster containing the block after 'end' is
2892 * in use to avoid freeing it when removing blocks.
2893 */
2894 if (sbi->s_cluster_ratio > 1) {
2895 pblk = ext4_ext_pblock(ex) + end - ee_block + 1;
2896 partial.pclu = EXT4_B2C(sbi, pblk);
2897 partial.state = nofree;
2898 }
2899
2900 /*
2901 * Split the extent in two so that 'end' is the last
2902 * block in the first new extent. Also we should not
2903 * fail removing space due to ENOSPC so try to use
2904 * reserved block if that happens.
2905 */
2906 path = ext4_force_split_extent_at(handle, inode, path,
2907 end + 1, 1);
2908 if (IS_ERR(path)) {
2909 err = PTR_ERR(path);
2910 goto out;
2911 }
2912 } else if (sbi->s_cluster_ratio > 1 && end >= ex_end &&
2913 partial.state == initial) {
2914 /*
2915 * If we're punching, there's an extent to the right.
2916 * If the partial cluster hasn't been set, set it to
2917 * that extent's first cluster and its state to nofree
2918 * so it won't be freed should it contain blocks to be
2919 * removed. If it's already set (tofree/nofree), we're
2920 * retrying and keep the original partial cluster info
2921 * so a cluster marked tofree as a result of earlier
2922 * extent removal is not lost.
2923 */
2924 lblk = ex_end + 1;
2925 err = ext4_ext_search_right(inode, path, &lblk, &pblk,
2926 NULL, flags);
2927 if (err < 0)
2928 goto out;
2929 if (pblk) {
2930 partial.pclu = EXT4_B2C(sbi, pblk);
2931 partial.state = nofree;
2932 }
2933 }
2934 }
2935 /*
2936 * We start scanning from right side, freeing all the blocks
2937 * after i_size and walking into the tree depth-wise.
2938 */
2939 depth = ext_depth(inode);
2940 if (path) {
2941 int k = i = depth;
2942 while (--k > 0)
2943 path[k].p_block =
2944 le16_to_cpu(path[k].p_hdr->eh_entries)+1;
2945 } else {
2946 path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),
2947 GFP_NOFS | __GFP_NOFAIL);
2948 if (path == NULL) {
2949 ext4_journal_stop(handle);
2950 return -ENOMEM;
2951 }
2952 path[0].p_maxdepth = path[0].p_depth = depth;
2953 path[0].p_hdr = ext_inode_hdr(inode);
2954 i = 0;
2955
2956 if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) {
2957 err = -EFSCORRUPTED;
2958 goto out;
2959 }
2960 }
2961 err = 0;
2962
2963 while (i >= 0 && err == 0) {
2964 if (i == depth) {
2965 /* this is leaf block */
2966 err = ext4_ext_rm_leaf(handle, inode, path,
2967 &partial, start, end);
2968 /* root level has p_bh == NULL, brelse() eats this */
2969 ext4_ext_path_brelse(path + i);
2970 i--;
2971 continue;
2972 }
2973
2974 /* this is index block */
2975 if (!path[i].p_hdr) {
2976 ext_debug(inode, "initialize header\n");
2977 path[i].p_hdr = ext_block_hdr(path[i].p_bh);
2978 }
2979
2980 if (!path[i].p_idx) {
2981 /* this level hasn't been touched yet */
2982 path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr);
2983 path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;
2984 ext_debug(inode, "init index ptr: hdr 0x%p, num %d\n",
2985 path[i].p_hdr,
2986 le16_to_cpu(path[i].p_hdr->eh_entries));
2987 } else {
2988 /* we were already here, see at next index */
2989 path[i].p_idx--;
2990 }
2991
2992 ext_debug(inode, "level %d - index, first 0x%p, cur 0x%p\n",
2993 i, EXT_FIRST_INDEX(path[i].p_hdr),
2994 path[i].p_idx);
2995 if (ext4_ext_more_to_rm(path + i)) {
2996 struct buffer_head *bh;
2997 /* go to the next level */
2998 ext_debug(inode, "move to level %d (block %llu)\n",
2999 i + 1, ext4_idx_pblock(path[i].p_idx));
3000 memset(path + i + 1, 0, sizeof(*path));
3001 bh = read_extent_tree_block(inode, path[i].p_idx,
3002 depth - i - 1, flags);
3003 if (IS_ERR(bh)) {
3004 /* should we reset i_size? */
3005 err = PTR_ERR(bh);
3006 break;
3007 }
3008 /* Yield here to deal with large extent trees.
3009 * Should be a no-op if we did IO above. */
3010 cond_resched();
3011 if (WARN_ON(i + 1 > depth)) {
3012 err = -EFSCORRUPTED;
3013 break;
3014 }
3015 path[i + 1].p_bh = bh;
3016
3017 /* save actual number of indexes since this
3018 * number is changed at the next iteration */
3019 path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);
3020 i++;
3021 } else {
3022 /* we finished processing this index, go up */
3023 if (path[i].p_hdr->eh_entries == 0 && i > 0) {
3024 /* index is empty, remove it;
3025 * handle must be already prepared by the
3026 * truncatei_leaf() */
3027 err = ext4_ext_rm_idx(handle, inode, path, i);
3028 }
3029 /* root level has p_bh == NULL, brelse() eats this */
3030 ext4_ext_path_brelse(path + i);
3031 i--;
3032 ext_debug(inode, "return to level %d\n", i);
3033 }
3034 }
3035
3036 trace_ext4_ext_remove_space_done(inode, start, end, depth, &partial,
3037 path->p_hdr->eh_entries);
3038
3039 /*
3040 * if there's a partial cluster and we have removed the first extent
3041 * in the file, then we also free the partial cluster, if any
3042 */
3043 if (partial.state == tofree && err == 0) {
3044 int flags = get_default_free_blocks_flags(inode);
3045
3046 if (ext4_is_pending(inode, partial.lblk))
3047 flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
3048 ext4_free_blocks(handle, inode, NULL,
3049 EXT4_C2B(sbi, partial.pclu),
3050 sbi->s_cluster_ratio, flags);
3051 if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
3052 ext4_rereserve_cluster(inode, partial.lblk);
3053 partial.state = initial;
3054 }
3055
3056 /* TODO: flexible tree reduction should be here */
3057 if (path->p_hdr->eh_entries == 0) {
3058 /*
3059 * truncate to zero freed all the tree,
3060 * so we need to correct eh_depth
3061 */
3062 err = ext4_ext_get_access(handle, inode, path);
3063 if (err == 0) {
3064 ix = EXT_FIRST_INDEX(path->p_hdr);
> 3065 if (ix && ext_inode_hdr(inode)->eh_depth > 0)
3066 ext4_idx_store_pblock(ix, 0);
3067 ext_inode_hdr(inode)->eh_depth = 0;
3068 ext_inode_hdr(inode)->eh_max =
3069 cpu_to_le16(ext4_ext_space_root(inode, 0));
3070 err = ext4_ext_dirty(handle, inode, path);
3071 }
3072 }
3073 out:
3074 ext4_free_ext_path(path);
3075 path = NULL;
3076 if (err == -EAGAIN)
3077 goto again;
3078 ext4_journal_stop(handle);
3079
3080 return err;
3081 }
3082
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 2+ messages in thread