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 <[email protected]>
"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/[email protected]
