Re: [PATCH v3 20/22] btrfs: introduce btrfs_subpage for data inodes

[Qu Wenruo <quwenruo.btrfs@gmx.com>]

On 2021/1/6 下午1:04, kernel test robot wrote:
> Hi Qu,
>
> Thank you for the patch! Perhaps something to improve:
>
> [auto build test WARNING on kdave/for-next]
> [also build test WARNING on v5.11-rc2 next-20210104]
> [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]
>
> url:    https://github.com/0day-ci/linux/commits/Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847
> base:   https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next
> config: m68k-randconfig-s032-20210106 (attached as .config)
> compiler: m68k-linux-gcc (GCC) 9.3.0
> reproduce:
>          wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
>          chmod +x ~/bin/make.cross
>          # apt-get install sparse
>          # sparse version: v0.6.3-208-g46a52ca4-dirty
>          # https://github.com/0day-ci/linux/commit/2c54bbf363f66a7c4d489fa0b7967ce5fc960afb
>          git remote add linux-review https://github.com/0day-ci/linux
>          git fetch --no-tags linux-review Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847
>          git checkout 2c54bbf363f66a7c4d489fa0b7967ce5fc960afb
>          # save the attached .config to linux build tree
>          COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=m68k
>
> If you fix the issue, kindly add following tag as appropriate
> Reported-by: kernel test robot <lkp@intel.com>
>
>
> "sparse warnings: (new ones prefixed by >>)"
>>> fs/btrfs/inode.c:8352:13: sparse: sparse: incorrect type in assignment (different base types) @@     expected restricted vm_fault_t [assigned] [usertype] ret @@     got int @@
>     fs/btrfs/inode.c:8352:13: sparse:     expected restricted vm_fault_t [assigned] [usertype] ret
>     fs/btrfs/inode.c:8352:13: sparse:     got int
>>> fs/btrfs/inode.c:8353:13: sparse: sparse: restricted vm_fault_t degrades to integer

Why I always forgot this...

Now it get properly fixed in github. Although the submitted patch is
still using @ret other than @ret2.

Is there anyway to let LKP to run on specific branch so that I can avoid
similar problems.

Thanks,
Qu
>     fs/btrfs/inode.c: note: in included file (through include/linux/mmzone.h, include/linux/gfp.h, include/linux/slab.h, ...):
>     include/linux/spinlock.h:394:9: sparse: sparse: context imbalance in 'run_delayed_iput_locked' - unexpected unlock
>
> vim +8352 fs/btrfs/inode.c
>
>    8275
>    8276	/*
>    8277	 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
>    8278	 * called from a page fault handler when a page is first dirtied. Hence we must
>    8279	 * be careful to check for EOF conditions here. We set the page up correctly
>    8280	 * for a written page which means we get ENOSPC checking when writing into
>    8281	 * holes and correct delalloc and unwritten extent mapping on filesystems that
>    8282	 * support these features.
>    8283	 *
>    8284	 * We are not allowed to take the i_mutex here so we have to play games to
>    8285	 * protect against truncate races as the page could now be beyond EOF.  Because
>    8286	 * truncate_setsize() writes the inode size before removing pages, once we have
>    8287	 * the page lock we can determine safely if the page is beyond EOF. If it is not
>    8288	 * beyond EOF, then the page is guaranteed safe against truncation until we
>    8289	 * unlock the page.
>    8290	 */
>    8291	vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
>    8292	{
>    8293		struct page *page = vmf->page;
>    8294		struct inode *inode = file_inode(vmf->vma->vm_file);
>    8295		struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
>    8296		struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
>    8297		struct btrfs_ordered_extent *ordered;
>    8298		struct extent_state *cached_state = NULL;
>    8299		struct extent_changeset *data_reserved = NULL;
>    8300		char *kaddr;
>    8301		unsigned long zero_start;
>    8302		loff_t size;
>    8303		vm_fault_t ret;
>    8304		int ret2;
>    8305		int reserved = 0;
>    8306		u64 reserved_space;
>    8307		u64 page_start;
>    8308		u64 page_end;
>    8309		u64 end;
>    8310
>    8311		reserved_space = PAGE_SIZE;
>    8312
>    8313		sb_start_pagefault(inode->i_sb);
>    8314		page_start = page_offset(page);
>    8315		page_end = page_start + PAGE_SIZE - 1;
>    8316		end = page_end;
>    8317
>    8318		/*
>    8319		 * Reserving delalloc space after obtaining the page lock can lead to
>    8320		 * deadlock. For example, if a dirty page is locked by this function
>    8321		 * and the call to btrfs_delalloc_reserve_space() ends up triggering
>    8322		 * dirty page write out, then the btrfs_writepage() function could
>    8323		 * end up waiting indefinitely to get a lock on the page currently
>    8324		 * being processed by btrfs_page_mkwrite() function.
>    8325		 */
>    8326		ret2 = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
>    8327						    page_start, reserved_space);
>    8328		if (!ret2) {
>    8329			ret2 = file_update_time(vmf->vma->vm_file);
>    8330			reserved = 1;
>    8331		}
>    8332		if (ret2) {
>    8333			ret = vmf_error(ret2);
>    8334			if (reserved)
>    8335				goto out;
>    8336			goto out_noreserve;
>    8337		}
>    8338
>    8339		ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
>    8340	again:
>    8341		lock_page(page);
>    8342		size = i_size_read(inode);
>    8343
>    8344		if ((page->mapping != inode->i_mapping) ||
>    8345		    (page_start >= size)) {
>    8346			/* page got truncated out from underneath us */
>    8347			goto out_unlock;
>    8348		}
>    8349		wait_on_page_writeback(page);
>    8350
>    8351		lock_extent_bits(io_tree, page_start, page_end, &cached_state);
>> 8352		ret = set_page_extent_mapped(page);
>> 8353		if (ret < 0)
>    8354			goto out_unlock;
>    8355
>    8356		/*
>    8357		 * we can't set the delalloc bits if there are pending ordered
>    8358		 * extents.  Drop our locks and wait for them to finish
>    8359		 */
>    8360		ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
>    8361				PAGE_SIZE);
>    8362		if (ordered) {
>    8363			unlock_extent_cached(io_tree, page_start, page_end,
>    8364					     &cached_state);
>    8365			unlock_page(page);
>    8366			btrfs_start_ordered_extent(ordered, 1);
>    8367			btrfs_put_ordered_extent(ordered);
>    8368			goto again;
>    8369		}
>    8370
>    8371		if (page->index == ((size - 1) >> PAGE_SHIFT)) {
>    8372			reserved_space = round_up(size - page_start,
>    8373						  fs_info->sectorsize);
>    8374			if (reserved_space < PAGE_SIZE) {
>    8375				end = page_start + reserved_space - 1;
>    8376				btrfs_delalloc_release_space(BTRFS_I(inode),
>    8377						data_reserved, page_start,
>    8378						PAGE_SIZE - reserved_space, true);
>    8379			}
>    8380		}
>    8381
>    8382		/*
>    8383		 * page_mkwrite gets called when the page is firstly dirtied after it's
>    8384		 * faulted in, but write(2) could also dirty a page and set delalloc
>    8385		 * bits, thus in this case for space account reason, we still need to
>    8386		 * clear any delalloc bits within this page range since we have to
>    8387		 * reserve data&meta space before lock_page() (see above comments).
>    8388		 */
>    8389		clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
>    8390				  EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
>    8391				  EXTENT_DEFRAG, 0, 0, &cached_state);
>    8392
>    8393		ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
>    8394						&cached_state);
>    8395		if (ret2) {
>    8396			unlock_extent_cached(io_tree, page_start, page_end,
>    8397					     &cached_state);
>    8398			ret = VM_FAULT_SIGBUS;
>    8399			goto out_unlock;
>    8400		}
>    8401
>    8402		/* page is wholly or partially inside EOF */
>    8403		if (page_start + PAGE_SIZE > size)
>    8404			zero_start = offset_in_page(size);
>    8405		else
>    8406			zero_start = PAGE_SIZE;
>    8407
>    8408		if (zero_start != PAGE_SIZE) {
>    8409			kaddr = kmap(page);
>    8410			memset(kaddr + zero_start, 0, PAGE_SIZE - zero_start);
>    8411			flush_dcache_page(page);
>    8412			kunmap(page);
>    8413		}
>    8414		ClearPageChecked(page);
>    8415		set_page_dirty(page);
>    8416		SetPageUptodate(page);
>    8417
>    8418		BTRFS_I(inode)->last_trans = fs_info->generation;
>    8419		BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
>    8420		BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
>    8421
>    8422		unlock_extent_cached(io_tree, page_start, page_end, &cached_state);
>    8423
>    8424		btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
>    8425		sb_end_pagefault(inode->i_sb);
>    8426		extent_changeset_free(data_reserved);
>    8427		return VM_FAULT_LOCKED;
>    8428
>    8429	out_unlock:
>    8430		unlock_page(page);
>    8431	out:
>    8432		btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
>    8433		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
>    8434					     reserved_space, (ret != 0));
>    8435	out_noreserve:
>    8436		sb_end_pagefault(inode->i_sb);
>    8437		extent_changeset_free(data_reserved);
>    8438		return ret;
>    8439	}
>    8440
>
> ---
> 0-DAY CI Kernel Test Service, Intel Corporation
> https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
>