[kbuild-all] Re: [PATCH v2 16/18] btrfs: introduce btrfs_subpage for data inodes

Hi Qu, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on kdave/for-next] [also build test WARNING on next-20201209] [cannot apply to v5.10-rc7] [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-su... base: https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next config: x86_64-randconfig-s021-20201210 (attached as .config) compiler: gcc-9 (Debian 9.3.0-15) 9.3.0 reproduce: # apt-get install sparse # sparse version: v0.6.3-179-ga00755aa-dirty # https://github.com/0day-ci/linux/commit/3852ff477c118432fb205a3422aa538dc... 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/20201210-144442 git checkout 3852ff477c118432fb205a3422aa538dc8ac3a5f # save the attached .config to linux build tree make W=1 C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=x86_64 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp(a)intel.com&gt; "sparse warnings: (new ones prefixed by >>)" fs/btrfs/inode.c:8360:13: sparse: expected restricted vm_fault_t [assigned] [usertype] ret fs/btrfs/inode.c:8360:13: sparse: got int vim +8360 fs/btrfs/inode.c 8283 8284 /* 8285 * btrfs_page_mkwrite() is not allowed to change the file size as it gets 8286 * called from a page fault handler when a page is first dirtied. Hence we must 8287 * be careful to check for EOF conditions here. We set the page up correctly 8288 * for a written page which means we get ENOSPC checking when writing into 8289 * holes and correct delalloc and unwritten extent mapping on filesystems that 8290 * support these features. 8291 * 8292 * We are not allowed to take the i_mutex here so we have to play games to 8293 * protect against truncate races as the page could now be beyond EOF. Because 8294 * truncate_setsize() writes the inode size before removing pages, once we have 8295 * the page lock we can determine safely if the page is beyond EOF. If it is not 8296 * beyond EOF, then the page is guaranteed safe against truncation until we 8297 * unlock the page. 8298 */ 8299 vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) 8300 { 8301 struct page *page = vmf->page; 8302 struct inode *inode = file_inode(vmf->vma->vm_file); 8303 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 8304 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 8305 struct btrfs_ordered_extent *ordered; 8306 struct extent_state *cached_state = NULL; 8307 struct extent_changeset *data_reserved = NULL; 8308 char *kaddr; 8309 unsigned long zero_start; 8310 loff_t size; 8311 vm_fault_t ret; 8312 int ret2; 8313 int reserved = 0; 8314 u64 reserved_space; 8315 u64 page_start; 8316 u64 page_end; 8317 u64 end; 8318 8319 reserved_space = PAGE_SIZE; 8320 8321 sb_start_pagefault(inode->i_sb); 8322 page_start = page_offset(page); 8323 page_end = page_start + PAGE_SIZE - 1; 8324 end = page_end; 8325 8326 /* 8327 * Reserving delalloc space after obtaining the page lock can lead to 8328 * deadlock. For example, if a dirty page is locked by this function 8329 * and the call to btrfs_delalloc_reserve_space() ends up triggering 8330 * dirty page write out, then the btrfs_writepage() function could 8331 * end up waiting indefinitely to get a lock on the page currently 8332 * being processed by btrfs_page_mkwrite() function. 8333 */ 8334 ret2 = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved, 8335 page_start, reserved_space); 8336 if (!ret2) { 8337 ret2 = file_update_time(vmf->vma->vm_file); 8338 reserved = 1; 8339 } 8340 if (ret2) { 8341 ret = vmf_error(ret2); 8342 if (reserved) 8343 goto out; 8344 goto out_noreserve; 8345 } 8346 8347 ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */ 8348 again: 8349 lock_page(page); 8350 size = i_size_read(inode); 8351 8352 if ((page->mapping != inode->i_mapping) || 8353 (page_start >= size)) { 8354 /* page got truncated out from underneath us */ 8355 goto out_unlock; 8356 } 8357 wait_on_page_writeback(page); 8358 8359 lock_extent_bits(io_tree, page_start, page_end, &cached_state); 8362 goto out_unlock; 8363 8364 /* 8365 * we can't set the delalloc bits if there are pending ordered 8366 * extents. Drop our locks and wait for them to finish 8367 */ 8368 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start, 8369 PAGE_SIZE); 8370 if (ordered) { 8371 unlock_extent_cached(io_tree, page_start, page_end, 8372 &cached_state); 8373 unlock_page(page); 8374 btrfs_start_ordered_extent(ordered, 1); 8375 btrfs_put_ordered_extent(ordered); 8376 goto again; 8377 } 8378 8379 if (page->index == ((size - 1) >> PAGE_SHIFT)) { 8380 reserved_space = round_up(size - page_start, 8381 fs_info->sectorsize); 8382 if (reserved_space < PAGE_SIZE) { 8383 end = page_start + reserved_space - 1; 8384 btrfs_delalloc_release_space(BTRFS_I(inode), 8385 data_reserved, page_start, 8386 PAGE_SIZE - reserved_space, true); 8387 } 8388 } 8389 8390 /* 8391 * page_mkwrite gets called when the page is firstly dirtied after it's 8392 * faulted in, but write(2) could also dirty a page and set delalloc 8393 * bits, thus in this case for space account reason, we still need to 8394 * clear any delalloc bits within this page range since we have to 8395 * reserve data&meta space before lock_page() (see above comments). 8396 */ 8397 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end, 8398 EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | 8399 EXTENT_DEFRAG, 0, 0, &cached_state); 8400 8401 ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0, 8402 &cached_state); 8403 if (ret2) { 8404 unlock_extent_cached(io_tree, page_start, page_end, 8405 &cached_state); 8406 ret = VM_FAULT_SIGBUS; 8407 goto out_unlock; 8408 } 8409 8410 /* page is wholly or partially inside EOF */ 8411 if (page_start + PAGE_SIZE > size) 8412 zero_start = offset_in_page(size); 8413 else 8414 zero_start = PAGE_SIZE; 8415 8416 if (zero_start != PAGE_SIZE) { 8417 kaddr = kmap(page); 8418 memset(kaddr + zero_start, 0, PAGE_SIZE - zero_start); 8419 flush_dcache_page(page); 8420 kunmap(page); 8421 } 8422 ClearPageChecked(page); 8423 set_page_dirty(page); 8424 SetPageUptodate(page); 8425 8426 BTRFS_I(inode)->last_trans = fs_info->generation; 8427 BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid; 8428 BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit; 8429 8430 unlock_extent_cached(io_tree, page_start, page_end, &cached_state); 8431 8432 btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE); 8433 sb_end_pagefault(inode->i_sb); 8434 extent_changeset_free(data_reserved); 8435 return VM_FAULT_LOCKED; 8436 8437 out_unlock: 8438 unlock_page(page); 8439 out: 8440 btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE); 8441 btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start, 8442 reserved_space, (ret != 0)); 8443 out_noreserve: 8444 sb_end_pagefault(inode->i_sb); 8445 extent_changeset_free(data_reserved); 8446 return ret; 8447 } 8448 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org