tree: https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next head: 7d05f2ecdd40cd928efc3feb0bfdc965aa5c89a9 commit: c950c6b7b34112061fc6acd30dc906f095a95a3d [59/70] btrfs: extent-tree: kill BUG_ON() in __btrfs_free_extent() and do better comment config: powerpc64-randconfig-r003-20200820 (attached as .config) compiler: clang version 12.0.0 (https://github.com/llvm/llvm-project 4deda57106f7c9b982a49cb907c33e3966c8de7f) reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # install powerpc64 cross compiling tool for clang build # apt-get install binutils-powerpc64-linux-gnu git checkout c950c6b7b34112061fc6acd30dc906f095a95a3d # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=powerpc64 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp(a)intel.com&gt; All warnings (new ones prefixed by >>): sizeof(*ei) + sizeof(*bi)); ^~~~~~~~~~~~~~~~~~~~~~~~~ fs/btrfs/ctree.h:3104:41: note: expanded from macro 'btrfs_crit' btrfs_printk(fs_info, KERN_CRIT fmt, ##args) ~~~ ^~~~ 1 warning generated. # https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git/commit/?i... git remote add kdave https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git git fetch --no-tags kdave for-next git checkout c950c6b7b34112061fc6acd30dc906f095a95a3d vim +3158 fs/btrfs/extent-tree.c 2932 2933 /* 2934 * Real work happens here to drop one or more refs of @node. 2935 * 2936 * The work is mostly done in two parts: 2937 * 1. Locate the extent refs. 2938 * It's either inlined in EXTENT/METADATA_ITEM or in keyed SHARED_* item. 2939 * Locate it then reduces the refs number or remove the ref line completely. 2940 * 2941 * 2. Update the refs count in EXTENT/METADATA_ITEM 2942 * 2943 * Due to the above two operations and possible optimizations, the function 2944 * is a little hard to read, but with the following examples, the result 2945 * of this function should be pretty easy to get. 2946 * 2947 * Example: 2948 * *** Inlined backref case *** 2949 * In extent tree we have: 2950 * item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 16201 itemsize 82 2951 * refs 2 gen 6 flags DATA 2952 * extent data backref root FS_TREE objectid 258 offset 0 count 1 2953 * extent data backref root FS_TREE objectid 257 offset 0 count 1 2954 * 2955 * This function get called with 2956 * node->bytenr = 13631488, node->num_bytes = 1048576 2957 * root_objectid = FS_TREE, owner_objectid = 257, owner_offset = 0, 2958 * refs_to_drop = 1 2959 * Then we should get some like: 2960 * item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 16201 itemsize 82 2961 * refs 1 gen 6 flags DATA 2962 * extent data backref root FS_TREE objectid 258 offset 0 count 1 2963 * 2964 * *** Keyed backref case *** 2965 * In extent tree we have: 2966 * item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 3971 itemsize 24 2967 * refs 754 gen 6 flags DATA 2968 * [...] 2969 * item 2 key (13631488 EXTENT_DATA_REF <HASH>) itemoff 3915 itemsize 28 2970 * extent data backref root FS_TREE objectid 866 offset 0 count 1 2971 * This function get called with 2972 * node->bytenr = 13631488, node->num_bytes = 1048576 2973 * root_objectid = FS_TREE, owner_objectid = 866, owner_offset = 0, 2974 * refs_to_drop = 1 2975 * Then we should get some like: 2976 * item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 3971 itemsize 24 2977 * refs 753 gen 6 flags DATA 2978 * And that (13631488 EXTENT_DATA_REF <HASH>) get removed. 2979 */ 2980 static int __btrfs_free_extent(struct btrfs_trans_handle *trans, 2981 struct btrfs_delayed_ref_node *node, u64 parent, 2982 u64 root_objectid, u64 owner_objectid, 2983 u64 owner_offset, int refs_to_drop, 2984 struct btrfs_delayed_extent_op *extent_op) 2985 { 2986 struct btrfs_fs_info *info = trans->fs_info; 2987 struct btrfs_key key; 2988 struct btrfs_path *path; 2989 struct btrfs_root *extent_root = info->extent_root; 2990 struct extent_buffer *leaf; 2991 struct btrfs_extent_item *ei; 2992 struct btrfs_extent_inline_ref *iref; 2993 int ret; 2994 int is_data; 2995 int extent_slot = 0; 2996 int found_extent = 0; 2997 int num_to_del = 1; 2998 u32 item_size; 2999 u64 refs; 3000 u64 bytenr = node->bytenr; 3001 u64 num_bytes = node->num_bytes; 3002 int last_ref = 0; 3003 bool skinny_metadata = btrfs_fs_incompat(info, SKINNY_METADATA); 3004 3005 path = btrfs_alloc_path(); 3006 if (!path) 3007 return -ENOMEM; 3008 3009 path->leave_spinning = 1; 3010 3011 is_data = owner_objectid >= BTRFS_FIRST_FREE_OBJECTID; 3012 3013 if (unlikely(!is_data && refs_to_drop != 1)) { 3014 btrfs_crit(info, 3015 "invalid refs_to_drop, dropping more than 1 refs for tree block %llu refs_to_drop %u", 3016 node->bytenr, refs_to_drop); 3017 ret = -EINVAL; 3018 btrfs_abort_transaction(trans, ret); 3019 goto out; 3020 } 3021 3022 if (is_data) 3023 skinny_metadata = false; 3024 3025 ret = lookup_extent_backref(trans, path, &iref, bytenr, num_bytes, 3026 parent, root_objectid, owner_objectid, 3027 owner_offset); 3028 if (ret == 0) { 3029 /* 3030 * Either the inline backref or the SHARED_DATA_REF/ 3031 * SHARED_BLOCK_REF is found 3032 * 3033 * Here is a quick path to locate EXTENT/METADATA_ITEM. 3034 * It's possible the EXTENT/METADATA_ITEM is near current slot. 3035 */ 3036 extent_slot = path->slots[0]; 3037 while (extent_slot >= 0) { 3038 btrfs_item_key_to_cpu(path->nodes[0], &key, 3039 extent_slot); 3040 if (key.objectid != bytenr) 3041 break; 3042 if (key.type == BTRFS_EXTENT_ITEM_KEY && 3043 key.offset == num_bytes) { 3044 found_extent = 1; 3045 break; 3046 } 3047 if (key.type == BTRFS_METADATA_ITEM_KEY && 3048 key.offset == owner_objectid) { 3049 found_extent = 1; 3050 break; 3051 } 3052 3053 /* Quick path didn't find the EXTEMT/METADATA_ITEM */ 3054 if (path->slots[0] - extent_slot > 5) 3055 break; 3056 extent_slot--; 3057 } 3058 3059 if (!found_extent) { 3060 if (unlikely(iref)) { 3061 btrfs_crit(info, 3062 "invalid iref, no EXTENT/METADATA_ITEM found but has inline extent ref"); 3063 btrfs_abort_transaction(trans, -EUCLEAN); 3064 goto err_dump; 3065 } 3066 /* Must be SHARED_* item, remove the backref first */ 3067 ret = remove_extent_backref(trans, path, NULL, 3068 refs_to_drop, 3069 is_data, &last_ref); 3070 if (ret) { 3071 btrfs_abort_transaction(trans, ret); 3072 goto out; 3073 } 3074 btrfs_release_path(path); 3075 path->leave_spinning = 1; 3076 3077 3078 /* Slow path to locate EXTENT/METADATA_ITEM */ 3079 key.objectid = bytenr; 3080 key.type = BTRFS_EXTENT_ITEM_KEY; 3081 key.offset = num_bytes; 3082 3083 if (!is_data && skinny_metadata) { 3084 key.type = BTRFS_METADATA_ITEM_KEY; 3085 key.offset = owner_objectid; 3086 } 3087 3088 ret = btrfs_search_slot(trans, extent_root, 3089 &key, path, -1, 1); 3090 if (ret > 0 && skinny_metadata && path->slots[0]) { 3091 /* 3092 * Couldn't find our skinny metadata item, 3093 * see if we have ye olde extent item. 3094 */ 3095 path->slots[0]--; 3096 btrfs_item_key_to_cpu(path->nodes[0], &key, 3097 path->slots[0]); 3098 if (key.objectid == bytenr && 3099 key.type == BTRFS_EXTENT_ITEM_KEY && 3100 key.offset == num_bytes) 3101 ret = 0; 3102 } 3103 3104 if (ret > 0 && skinny_metadata) { 3105 skinny_metadata = false; 3106 key.objectid = bytenr; 3107 key.type = BTRFS_EXTENT_ITEM_KEY; 3108 key.offset = num_bytes; 3109 btrfs_release_path(path); 3110 ret = btrfs_search_slot(trans, extent_root, 3111 &key, path, -1, 1); 3112 } 3113 3114 if (ret) { 3115 btrfs_err(info, 3116 "umm, got %d back from search, was looking for %llu", 3117 ret, bytenr); 3118 if (ret > 0) 3119 btrfs_print_leaf(path->nodes[0]); 3120 } 3121 if (ret < 0) { 3122 btrfs_abort_transaction(trans, ret); 3123 goto out; 3124 } 3125 extent_slot = path->slots[0]; 3126 } 3127 } else if (WARN_ON(ret == -ENOENT)) { 3128 btrfs_print_leaf(path->nodes[0]); 3129 btrfs_err(info, 3130 "unable to find ref byte nr %llu parent %llu root %llu owner %llu offset %llu", 3131 bytenr, parent, root_objectid, owner_objectid, 3132 owner_offset); 3133 btrfs_abort_transaction(trans, ret); 3134 goto out; 3135 } else { 3136 btrfs_abort_transaction(trans, ret); 3137 goto out; 3138 } 3139 3140 leaf = path->nodes[0]; 3141 item_size = btrfs_item_size_nr(leaf, extent_slot); 3142 if (unlikely(item_size < sizeof(*ei))) { 3143 ret = -EINVAL; 3144 btrfs_print_v0_err(info); 3145 btrfs_abort_transaction(trans, ret); 3146 goto out; 3147 } 3148 ei = btrfs_item_ptr(leaf, extent_slot, 3149 struct btrfs_extent_item); 3150 if (owner_objectid < BTRFS_FIRST_FREE_OBJECTID && 3151 key.type == BTRFS_EXTENT_ITEM_KEY) { 3152 struct btrfs_tree_block_info *bi; 3153 if (unlikely(item_size < sizeof(*ei) + sizeof(*bi))) { 3154 btrfs_crit(info, 3155 "invalid extent item size for key (%llu, %u, %llu) owner %llu, has %u expect >= %lu", 3156 key.objectid, key.type, key.offset, 3157 owner_objectid, item_size, 3159 btrfs_abort_transaction(trans, -EUCLEAN); 3160 goto err_dump; 3161 } 3162 bi = (struct btrfs_tree_block_info *)(ei + 1); 3163 WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi)); 3164 } 3165 3166 refs = btrfs_extent_refs(leaf, ei); 3167 if (refs < refs_to_drop) { 3168 btrfs_crit(info, 3169 "trying to drop %d refs but we only have %Lu for bytenr %Lu", 3170 refs_to_drop, refs, bytenr); 3171 btrfs_abort_transaction(trans, -EUCLEAN); 3172 goto err_dump; 3173 } 3174 refs -= refs_to_drop; 3175 3176 if (refs > 0) { 3177 if (extent_op) 3178 __run_delayed_extent_op(extent_op, leaf, ei); 3179 /* 3180 * In the case of inline back ref, reference count will 3181 * be updated by remove_extent_backref 3182 */ 3183 if (iref) { 3184 if (unlikely(!found_extent)) { 3185 btrfs_crit(info, 3186 "invalid iref, got inlined extent ref but no EXTENT/METADATA_ITEM found"); 3187 btrfs_abort_transaction(trans, -EUCLEAN); 3188 goto err_dump; 3189 } 3190 } else { 3191 btrfs_set_extent_refs(leaf, ei, refs); 3192 btrfs_mark_buffer_dirty(leaf); 3193 } 3194 if (found_extent) { 3195 ret = remove_extent_backref(trans, path, iref, 3196 refs_to_drop, is_data, 3197 &last_ref); 3198 if (ret) { 3199 btrfs_abort_transaction(trans, ret); 3200 goto out; 3201 } 3202 } 3203 } else { 3204 /* In this branch refs == 1 */ 3205 if (found_extent) { 3206 if (is_data && refs_to_drop != 3207 extent_data_ref_count(path, iref)) { 3208 btrfs_crit(info, 3209 "invalid refs_to_drop, current refs %u refs_to_drop %u", 3210 extent_data_ref_count(path, iref), 3211 refs_to_drop); 3212 btrfs_abort_transaction(trans, -EUCLEAN); 3213 goto err_dump; 3214 } 3215 if (iref) { 3216 if (path->slots[0] != extent_slot) { 3217 btrfs_crit(info, 3218 "invalid iref, extent item key (%llu %u %llu) doesn't has wanted iref", 3219 key.objectid, key.type, 3220 key.offset); 3221 btrfs_abort_transaction(trans, -EUCLEAN); 3222 goto err_dump; 3223 } 3224 } else { 3225 /* 3226 * No inline ref, we must at SHARED_* item, 3227 * And it's single ref, it must be: 3228 * | extent_slot ||extent_slot + 1| 3229 * [ EXTENT/METADATA_ITEM ][ SHARED_* ITEM ] 3230 */ 3231 if (path->slots[0] != extent_slot + 1) { 3232 btrfs_crit(info, 3233 "invalid SHARED_* item, previous item is not EXTENT/METADATA_ITEM"); 3234 btrfs_abort_transaction(trans, -EUCLEAN); 3235 goto err_dump; 3236 } 3237 path->slots[0] = extent_slot; 3238 num_to_del = 2; 3239 } 3240 } 3241 3242 last_ref = 1; 3243 ret = btrfs_del_items(trans, extent_root, path, path->slots[0], 3244 num_to_del); 3245 if (ret) { 3246 btrfs_abort_transaction(trans, ret); 3247 goto out; 3248 } 3249 btrfs_release_path(path); 3250 3251 if (is_data) { 3252 ret = btrfs_del_csums(trans, info->csum_root, bytenr, 3253 num_bytes); 3254 if (ret) { 3255 btrfs_abort_transaction(trans, ret); 3256 goto out; 3257 } 3258 } 3259 3260 ret = add_to_free_space_tree(trans, bytenr, num_bytes); 3261 if (ret) { 3262 btrfs_abort_transaction(trans, ret); 3263 goto out; 3264 } 3265 3266 ret = btrfs_update_block_group(trans, bytenr, num_bytes, 0); 3267 if (ret) { 3268 btrfs_abort_transaction(trans, ret); 3269 goto out; 3270 } 3271 } 3272 btrfs_release_path(path); 3273 3274 out: 3275 btrfs_free_path(path); 3276 return ret; 3277 err_dump: 3278 /* 3279 * Leaf dump can take up a lot of dmesg buffer since default nodesize 3280 * is already 16K. 3281 * So we only do full leaf dump for debug build. 3282 */ 3283 if (IS_ENABLED(CONFIG_BTRFS_DEBUG)) { 3284 btrfs_crit(info, "path->slots[0]=%d extent_slot=%d", 3285 path->slots[0], extent_slot); 3286 btrfs_print_leaf(path->nodes[0]); 3287 } 3288 3289 btrfs_free_path(path); 3290 return -EUCLEAN; 3291 } 3292 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org