Subject: Re: linux-next: build failure after merge of the fsverity tree

From: kernel test robot <[email-masked]>
Date: Thu, 5 Feb 2026 01:39:21 +0800

Hi Mark,

kernel test robot noticed the following build errors:

[auto build test ERROR on jaegeuk-f2fs/dev-test]
[also build test ERROR on jaegeuk-f2fs/dev]
[cannot apply to linus/master v6.19-rc8 next-20260204]
[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#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Mark-Brown/linux-next-build-failure-after-merge-of-the-fsverity-tree/20260203-214224
base:   https://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git dev-test
patch link:    https://lore.kernel.org/r/aYH54qJee85qLLkN%40sirena.org.uk
patch subject: linux-next: build failure after merge of the fsverity tree
config: x86_64-rhel-9.4-bpf (https://download.01.org/0day-ci/archive/20260205/[email-masked]/config)
compiler: gcc-14 (Debian 14.2.0-19) 14.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260205/[email-masked]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email-masked]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email-masked]/

All errors (new ones prefixed by >>):

   fs/f2fs/data.c: In function 'f2fs_read_data_large_folio':
   fs/f2fs/data.c:2523:51: error: passing argument 1 of 'fsverity_verify_page' from incompatible pointer type [-Wincompatible-pointer-types]
    2523 |                             !fsverity_verify_page(vi, folio_file_page(folio,
         |                                                   ^~
         |                                                   |
         |                                                   struct fsverity_info *
   In file included from fs/f2fs/f2fs.h:29,
                    from fs/f2fs/data.c:24:
   include/linux/fsverity.h:298:54: note: expected 'struct page *' but argument is of type 'struct fsverity_info *'
     298 | static inline bool fsverity_verify_page(struct page *page)
         |                                         ~~~~~~~~~~~~~^~~~
>> fs/f2fs/data.c:2523:30: error: too many arguments to function 'fsverity_verify_page'
    2523 |                             !fsverity_verify_page(vi, folio_file_page(folio,
         |                              ^~~~~~~~~~~~~~~~~~~~
   include/linux/fsverity.h:298:20: note: declared here
     298 | static inline bool fsverity_verify_page(struct page *page)
         |                    ^~~~~~~~~~~~~~~~~~~~
   fs/f2fs/data.c:2555:57: error: passing argument 2 of 'f2fs_grab_read_bio' makes integer from pointer without a cast [-Wint-conversion]
    2555 |                         bio = f2fs_grab_read_bio(inode, vi, block_nr,
         |                                                         ^~
         |                                                         |
         |                                                         struct fsverity_info *
   fs/f2fs/data.c:1097:68: note: expected 'block_t' {aka 'unsigned int'} but argument is of type 'struct fsverity_info *'
    1097 | static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
         |                                                            ~~~~~~~~^~~~~~~
>> fs/f2fs/data.c:2555:31: error: too many arguments to function 'f2fs_grab_read_bio'
    2555 |                         bio = f2fs_grab_read_bio(inode, vi, block_nr,
         |                               ^~~~~~~~~~~~~~~~~~
   fs/f2fs/data.c:1097:20: note: declared here
    1097 | static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
         |                    ^~~~~~~~~~~~~~~~~~
   fs/f2fs/data.c: In function 'f2fs_mpage_readpages':
   fs/f2fs/data.c:2629:58: error: 'vi' undeclared (first use in this function)
    2629 |                 return f2fs_read_data_large_folio(inode, vi, rac, folio);
         |                                                          ^~
   fs/f2fs/data.c:2629:58: note: each undeclared identifier is reported only once for each function it appears in

vim +/fsverity_verify_page +2523 fs/f2fs/data.c

  2449	
  2450	static int f2fs_read_data_large_folio(struct inode *inode,
  2451			struct fsverity_info *vi,
  2452			struct readahead_control *rac, struct folio *folio)
  2453	{
  2454		struct bio *bio = NULL;
  2455		sector_t last_block_in_bio = 0;
  2456		struct f2fs_map_blocks map = {0, };
  2457		pgoff_t index, offset, next_pgofs = 0;
  2458		unsigned max_nr_pages = rac ? readahead_count(rac) :
  2459					folio_nr_pages(folio);
  2460		unsigned nrpages;
  2461		struct f2fs_folio_state *ffs;
  2462		int ret = 0;
  2463		bool folio_in_bio;
  2464	
  2465		if (!IS_IMMUTABLE(inode) || f2fs_compressed_file(inode)) {
  2466			if (folio)
  2467				folio_unlock(folio);
  2468			return -EOPNOTSUPP;
  2469		}
  2470	
  2471		map.m_seg_type = NO_CHECK_TYPE;
  2472	
  2473		if (rac)
  2474			folio = readahead_folio(rac);
  2475	next_folio:
  2476		if (!folio)
  2477			goto out;
  2478	
  2479		folio_in_bio = false;
  2480		index = folio->index;
  2481		offset = 0;
  2482		ffs = NULL;
  2483		nrpages = folio_nr_pages(folio);
  2484	
  2485		for (; nrpages; nrpages--, max_nr_pages--, index++, offset++) {
  2486			sector_t block_nr;
  2487			/*
  2488			 * Map blocks using the previous result first.
  2489			 */
  2490			if (map.m_flags & F2FS_MAP_MAPPED) {
  2491				if (index > map.m_lblk &&
  2492					index < (map.m_lblk + map.m_len))
  2493					goto got_it;
  2494			} else if (index < next_pgofs) {
  2495				/* hole case */
  2496				goto got_it;
  2497			}
  2498	
  2499			/*
  2500			 * Then do more f2fs_map_blocks() calls until we are
  2501			 * done with this page.
  2502			 */
  2503			memset(&map, 0, sizeof(map));
  2504			map.m_next_pgofs = &next_pgofs;
  2505			map.m_seg_type = NO_CHECK_TYPE;
  2506			map.m_lblk = index;
  2507			map.m_len = max_nr_pages;
  2508	
  2509			ret = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DEFAULT);
  2510			if (ret)
  2511				goto err_out;
  2512	got_it:
  2513			if ((map.m_flags & F2FS_MAP_MAPPED)) {
  2514				block_nr = map.m_pblk + index - map.m_lblk;
  2515				if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode), block_nr,
  2516							DATA_GENERIC_ENHANCE_READ)) {
  2517					ret = -EFSCORRUPTED;
  2518					goto err_out;
  2519				}
  2520			} else {
  2521				folio_zero_range(folio, offset << PAGE_SHIFT, PAGE_SIZE);
  2522				if (f2fs_need_verity(inode, index) &&
> 2523				    !fsverity_verify_page(vi, folio_file_page(folio,
  2524									index))) {
  2525					ret = -EIO;
  2526					goto err_out;
  2527				}
  2528				continue;
  2529			}
  2530	
  2531			/* We must increment read_pages_pending before possible BIOs submitting
  2532			 * to prevent from premature folio_end_read() call on folio
  2533			 */
  2534			if (folio_test_large(folio)) {
  2535				ffs = ffs_find_or_alloc(folio);
  2536	
  2537				/* set the bitmap to wait */
  2538				spin_lock_irq(&ffs->state_lock);
  2539				ffs->read_pages_pending++;
  2540				spin_unlock_irq(&ffs->state_lock);
  2541			}
  2542	
  2543			/*
  2544			 * This page will go to BIO.  Do we need to send this
  2545			 * BIO off first?
  2546			 */
  2547			if (bio && (!page_is_mergeable(F2FS_I_SB(inode), bio,
  2548							last_block_in_bio, block_nr) ||
  2549				!f2fs_crypt_mergeable_bio(bio, inode, index, NULL))) {
  2550	submit_and_realloc:
  2551				f2fs_submit_read_bio(F2FS_I_SB(inode), bio, DATA);
  2552				bio = NULL;
  2553			}
  2554			if (bio == NULL)
> 2555				bio = f2fs_grab_read_bio(inode, vi, block_nr,
  2556						max_nr_pages,
  2557						f2fs_ra_op_flags(rac),
  2558						index, false);
  2559	
  2560			/*
  2561			 * If the page is under writeback, we need to wait for
  2562			 * its completion to see the correct decrypted data.
  2563			 */
  2564			f2fs_wait_on_block_writeback(inode, block_nr);
  2565	
  2566			if (!bio_add_folio(bio, folio, F2FS_BLKSIZE,
  2567						offset << PAGE_SHIFT))
  2568				goto submit_and_realloc;
  2569	
  2570			folio_in_bio = true;
  2571			inc_page_count(F2FS_I_SB(inode), F2FS_RD_DATA);
  2572			f2fs_update_iostat(F2FS_I_SB(inode), NULL, FS_DATA_READ_IO,
  2573					F2FS_BLKSIZE);
  2574			last_block_in_bio = block_nr;
  2575		}
  2576		trace_f2fs_read_folio(folio, DATA);
  2577	err_out:
  2578		if (!folio_in_bio) {
  2579			folio_end_read(folio, !ret);
  2580			if (ret)
  2581				return ret;
  2582		}
  2583		if (rac) {
  2584			folio = readahead_folio(rac);
  2585			goto next_folio;
  2586		}
  2587	out:
  2588		f2fs_submit_read_bio(F2FS_I_SB(inode), bio, DATA);
  2589		if (ret) {
  2590			/* Wait bios and clear uptodate. */
  2591			folio_lock(folio);
  2592			folio_clear_uptodate(folio);
  2593			folio_unlock(folio);
  2594		}
  2595		return ret;
  2596	}
  2597	

-- 
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki