[sashal-linux-stable:queue-5.4 136/137] fs/btrfs/file.c:2664:16: error: 'drop_args' undeclared

[kernel test robot <lkp@intel.com>]

[-- Attachment #1: Type: text/plain, Size: 9130 bytes --]

tree:   https://git.kernel.org/pub/scm/linux/kernel/git/sashal/linux-stable.git queue-5.4
head:   aef7415b52ffa3bd0111b7b7a3dd47e27584a1e0
commit: 3744bdfd37eaa635ddb70f15fe5d3bde233e54f0 [136/137] btrfs: fix a potential hole punching failure
config: i386-randconfig-m021-20210509 (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
        # https://git.kernel.org/pub/scm/linux/kernel/git/sashal/linux-stable.git/commit/?id=3744bdfd37eaa635ddb70f15fe5d3bde233e54f0
        git remote add sashal-linux-stable https://git.kernel.org/pub/scm/linux/kernel/git/sashal/linux-stable.git
        git fetch --no-tags sashal-linux-stable queue-5.4
        git checkout 3744bdfd37eaa635ddb70f15fe5d3bde233e54f0
        # save the attached .config to linux build tree
        make W=1 W=1 ARCH=i386 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All errors (new ones prefixed by >>):

   fs/btrfs/file.c: In function 'btrfs_punch_hole_range':
>> fs/btrfs/file.c:2664:16: error: 'drop_args' undeclared (first use in this function)
    2664 |   cur_offset = drop_args.drop_end;
         |                ^~~~~~~~~
   fs/btrfs/file.c:2664:16: note: each undeclared identifier is reported only once for each function it appears in


vim +/drop_args +2664 fs/btrfs/file.c

  2534	
  2535	/*
  2536	 * The respective range must have been previously locked, as well as the inode.
  2537	 * The end offset is inclusive (last byte of the range).
  2538	 * @clone_info is NULL for fallocate's hole punching and non-NULL for extent
  2539	 * cloning.
  2540	 * When cloning, we don't want to end up in a state where we dropped extents
  2541	 * without inserting a new one, so we must abort the transaction to avoid a
  2542	 * corruption.
  2543	 */
  2544	int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
  2545				   const u64 start, const u64 end,
  2546				   struct btrfs_clone_extent_info *clone_info,
  2547				   struct btrfs_trans_handle **trans_out)
  2548	{
  2549		struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
  2550		u64 min_size = btrfs_calc_insert_metadata_size(fs_info, 1);
  2551		u64 ino_size = round_up(inode->i_size, fs_info->sectorsize);
  2552		struct btrfs_root *root = BTRFS_I(inode)->root;
  2553		struct btrfs_trans_handle *trans = NULL;
  2554		struct btrfs_block_rsv *rsv;
  2555		unsigned int rsv_count;
  2556		u64 cur_offset;
  2557		u64 drop_end;
  2558		u64 len = end - start;
  2559		int ret = 0;
  2560	
  2561		if (end <= start)
  2562			return -EINVAL;
  2563	
  2564		rsv = btrfs_alloc_block_rsv(fs_info, BTRFS_BLOCK_RSV_TEMP);
  2565		if (!rsv) {
  2566			ret = -ENOMEM;
  2567			goto out;
  2568		}
  2569		rsv->size = btrfs_calc_insert_metadata_size(fs_info, 1);
  2570		rsv->failfast = 1;
  2571	
  2572		/*
  2573		 * 1 - update the inode
  2574		 * 1 - removing the extents in the range
  2575		 * 1 - adding the hole extent if no_holes isn't set or if we are cloning
  2576		 *     an extent
  2577		 */
  2578		if (!btrfs_fs_incompat(fs_info, NO_HOLES) || clone_info)
  2579			rsv_count = 3;
  2580		else
  2581			rsv_count = 2;
  2582	
  2583		trans = btrfs_start_transaction(root, rsv_count);
  2584		if (IS_ERR(trans)) {
  2585			ret = PTR_ERR(trans);
  2586			trans = NULL;
  2587			goto out_free;
  2588		}
  2589	
  2590		ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv,
  2591					      min_size, false);
  2592		BUG_ON(ret);
  2593		trans->block_rsv = rsv;
  2594	
  2595		cur_offset = start;
  2596		while (cur_offset < end) {
  2597			ret = __btrfs_drop_extents(trans, root, inode, path,
  2598						   cur_offset, end + 1, &drop_end,
  2599						   1, 0, 0, NULL);
  2600			if (ret != -ENOSPC) {
  2601				/*
  2602				 * When cloning we want to avoid transaction aborts when
  2603				 * nothing was done and we are attempting to clone parts
  2604				 * of inline extents, in such cases -EOPNOTSUPP is
  2605				 * returned by __btrfs_drop_extents() without having
  2606				 * changed anything in the file.
  2607				 */
  2608				if (clone_info && ret && ret != -EOPNOTSUPP)
  2609					btrfs_abort_transaction(trans, ret);
  2610				break;
  2611			}
  2612	
  2613			trans->block_rsv = &fs_info->trans_block_rsv;
  2614	
  2615			if (!clone_info && cur_offset < drop_end &&
  2616			    cur_offset < ino_size) {
  2617				ret = fill_holes(trans, BTRFS_I(inode), path,
  2618						cur_offset, drop_end);
  2619				if (ret) {
  2620					/*
  2621					 * If we failed then we didn't insert our hole
  2622					 * entries for the area we dropped, so now the
  2623					 * fs is corrupted, so we must abort the
  2624					 * transaction.
  2625					 */
  2626					btrfs_abort_transaction(trans, ret);
  2627					break;
  2628				}
  2629			}
  2630	
  2631			if (clone_info && drop_end > clone_info->file_offset) {
  2632				u64 clone_len = drop_end - clone_info->file_offset;
  2633	
  2634				ret = btrfs_insert_clone_extent(trans, inode, path,
  2635								clone_info, clone_len);
  2636				if (ret) {
  2637					btrfs_abort_transaction(trans, ret);
  2638					break;
  2639				}
  2640				clone_info->data_len -= clone_len;
  2641				clone_info->data_offset += clone_len;
  2642				clone_info->file_offset += clone_len;
  2643			}
  2644	
  2645			ret = btrfs_update_inode(trans, root, inode);
  2646			if (ret)
  2647				break;
  2648	
  2649			btrfs_end_transaction(trans);
  2650			btrfs_btree_balance_dirty(fs_info);
  2651	
  2652			trans = btrfs_start_transaction(root, rsv_count);
  2653			if (IS_ERR(trans)) {
  2654				ret = PTR_ERR(trans);
  2655				trans = NULL;
  2656				break;
  2657			}
  2658	
  2659			ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,
  2660						      rsv, min_size, false);
  2661			BUG_ON(ret);	/* shouldn't happen */
  2662			trans->block_rsv = rsv;
  2663	
> 2664			cur_offset = drop_args.drop_end;
  2665	                len = end - cur_offset;
  2666			if (!clone_info && len) {
  2667				ret = find_first_non_hole(inode, &cur_offset, &len);
  2668				if (unlikely(ret < 0))
  2669					break;
  2670				if (ret && !len) {
  2671					ret = 0;
  2672					break;
  2673				}
  2674			}
  2675		}
  2676	
  2677		/*
  2678		 * If we were cloning, force the next fsync to be a full one since we
  2679		 * we replaced (or just dropped in the case of cloning holes when
  2680		 * NO_HOLES is enabled) extents and extent maps.
  2681		 * This is for the sake of simplicity, and cloning into files larger
  2682		 * than 16Mb would force the full fsync any way (when
  2683		 * try_release_extent_mapping() is invoked during page cache truncation.
  2684		 */
  2685		if (clone_info)
  2686			set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
  2687				&BTRFS_I(inode)->runtime_flags);
  2688	
  2689		if (ret)
  2690			goto out_trans;
  2691	
  2692		trans->block_rsv = &fs_info->trans_block_rsv;
  2693		/*
  2694		 * If we are using the NO_HOLES feature we might have had already an
  2695		 * hole that overlaps a part of the region [lockstart, lockend] and
  2696		 * ends at (or beyond) lockend. Since we have no file extent items to
  2697		 * represent holes, drop_end can be less than lockend and so we must
  2698		 * make sure we have an extent map representing the existing hole (the
  2699		 * call to __btrfs_drop_extents() might have dropped the existing extent
  2700		 * map representing the existing hole), otherwise the fast fsync path
  2701		 * will not record the existence of the hole region
  2702		 * [existing_hole_start, lockend].
  2703		 */
  2704		if (drop_end <= end)
  2705			drop_end = end + 1;
  2706		/*
  2707		 * Don't insert file hole extent item if it's for a range beyond eof
  2708		 * (because it's useless) or if it represents a 0 bytes range (when
  2709		 * cur_offset == drop_end).
  2710		 */
  2711		if (!clone_info && cur_offset < ino_size && cur_offset < drop_end) {
  2712			ret = fill_holes(trans, BTRFS_I(inode), path,
  2713					cur_offset, drop_end);
  2714			if (ret) {
  2715				/* Same comment as above. */
  2716				btrfs_abort_transaction(trans, ret);
  2717				goto out_trans;
  2718			}
  2719		}
  2720		if (clone_info) {
  2721			ret = btrfs_insert_clone_extent(trans, inode, path, clone_info,
  2722							clone_info->data_len);
  2723			if (ret) {
  2724				btrfs_abort_transaction(trans, ret);
  2725				goto out_trans;
  2726			}
  2727		}
  2728	
  2729	out_trans:
  2730		if (!trans)
  2731			goto out_free;
  2732	
  2733		trans->block_rsv = &fs_info->trans_block_rsv;
  2734		if (ret)
  2735			btrfs_end_transaction(trans);
  2736		else
  2737			*trans_out = trans;
  2738	out_free:
  2739		btrfs_free_block_rsv(fs_info, rsv);
  2740	out:
  2741		return ret;
  2742	}
  2743	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

[-- Attachment #2: config.gz --]
[-- Type: application/gzip, Size: 30565 bytes --]