Hi Chunhai,

kernel test robot noticed the following build warnings:

[auto build test WARNING on xiang-erofs/dev-test]
[also build test WARNING on xiang-erofs/dev xiang-erofs/fixes linus/master 
v6.17-rc7 next-20250922]
[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/Chunhai-Guo/erofs-add-direct-I-O-support-for-compressed-data/20250922-204843
base:   https://git.kernel.org/pub/scm/linux/kernel/git/xiang/erofs.git dev-test
patch link:    
https://lore.kernel.org/r/20250922124304.489419-1-guochunhai%40vivo.com
patch subject: [PATCH] erofs: add direct I/O support for compressed data
config: loongarch-randconfig-r072-20250923 
(https://download.01.org/0day-ci/archive/20250923/[email protected]/config)
compiler: clang version 22.0.0git (https://github.com/llvm/llvm-project 
cafc064fc7a96b3979a023ddae1da2b499d6c954)
reproduce (this is a W=1 build): 
(https://download.01.org/0day-ci/archive/20250923/[email protected]/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 protected]>
| Closes: 
https://lore.kernel.org/oe-kbuild-all/[email protected]/

All warnings (new ones prefixed by >>):

>> fs/erofs/zdata.c:2069:6: warning: variable 'tmp_cnt' set but not used 
>> [-Wunused-but-set-variable]
    2069 |         int tmp_cnt = 0;
         |             ^
   1 warning generated.


vim +/tmp_cnt +2069 fs/erofs/zdata.c

  2056  
  2057  static ssize_t z_erofs_dio_read_iter(struct kiocb *iocb, struct 
iov_iter *iter)
  2058  {
  2059          struct inode *inode = file_inode(iocb->ki_filp);
  2060          Z_EROFS_DEFINE_FRONTEND(f, inode, iocb->ki_pos);
  2061          ssize_t err, off0;
  2062          loff_t offset = iocb->ki_pos;
  2063          unsigned int i = 0, total_pages, nr_pages = 0;
  2064          struct folio *head = NULL, *folio;
  2065          struct dio_erofs dio;
  2066          struct page **pages;
  2067          loff_t i_size;
  2068          struct iov_iter iter_saved = *iter;
> 2069          int tmp_cnt = 0;
  2070  
  2071          if (!iov_iter_count(iter))
  2072                  return 0;
  2073  
  2074          i_size = i_size_read(inode);
  2075          if (offset >= i_size)
  2076                  return 0;
  2077  
  2078          memset(&dio, 0, offsetof(struct dio_erofs, pages));
  2079          atomic_set(&dio.ref, 1);
  2080          dio.should_dirty = user_backed_iter(iter) && iov_iter_rw(iter) 
== READ;
  2081          dio.iocb = iocb;
  2082          dio.pos = ALIGN(min(iocb->ki_pos + (loff_t)iov_iter_count(iter),
  2083                                  i_size), PAGE_SIZE);
  2084          dio.is_pinned = iov_iter_extract_will_pin(iter);
  2085          dio.waiter = current;
  2086          f.dio = &dio;
  2087          iter_saved = *iter;
  2088          inode_dio_begin(inode);
  2089          pages = dio.pages;
  2090          total_pages = DIV_ROUND_UP(dio.pos - iocb->ki_pos, PAGE_SIZE);
  2091          for (; total_pages > 0; total_pages -= nr_pages) {
  2092                  err = iov_iter_extract_pages(iter, &pages, LONG_MAX,
  2093                                  min(ARRAY_SIZE(dio.pages), 
total_pages), 0,
  2094                                  &off0);
  2095                  if (err <= 0) {
  2096                          err = -EFAULT;
  2097                          goto fail_dio;
  2098                  }
  2099                  DBG_BUGON(off0);
  2100                  iov_iter_revert(iter, err & ~PAGE_MASK);
  2101                  nr_pages = DIV_ROUND_UP(err, PAGE_SIZE);
  2102                  tmp_cnt += nr_pages;
  2103                  for (i = 0; i < nr_pages; i++) {
  2104                          folio = page_folio(pages[i]);
  2105                          if (folio_test_large(folio) ||
  2106                                          folio_test_private(folio)) {
  2107                                  err = -EFAULT;
  2108                                  goto fail_dio;
  2109                          }
  2110                          folio->private = head;
  2111                          head = folio;
  2112                  }
  2113          }
  2114  
  2115          z_erofs_pcluster_readmore(&f, NULL, true);
  2116          while (head) {
  2117                  folio = head;
  2118                  head = folio_get_private(folio);
  2119                  dio.pos -= folio_size(folio);
  2120                  err = z_erofs_scan_folio(&f, folio, false);
  2121                  if (err && err != -EINTR)
  2122                          erofs_err(inode->i_sb, "readahead error at 
folio %lu @ nid %llu",
  2123                                    folio->index, EROFS_I(inode)->nid);
  2124          }
  2125          z_erofs_pcluster_end(&f);
  2126  
  2127          err = z_erofs_runqueue(&f, 0);
  2128          erofs_put_metabuf(&f.map.buf);
  2129          erofs_release_pages(&f.pagepool);
  2130  
  2131          if (!atomic_dec_and_test(&dio.ref)) {
  2132                  for (;;) {
  2133                          set_current_state(TASK_UNINTERRUPTIBLE);
  2134                          if (!READ_ONCE(dio.waiter))
  2135                                  break;
  2136  
  2137                          blk_io_schedule();
  2138                  }
  2139                  __set_current_state(TASK_RUNNING);
  2140          }
  2141  
  2142          err = err ?: dio.eio;
  2143          if (likely(!err)) {
  2144                  err = dio.size;
  2145                  if (offset + dio.size > i_size) /* check for short read 
*/
  2146                          err = i_size - offset;
  2147                  iocb->ki_pos += err;
  2148          }
  2149          inode_dio_end(inode);
  2150          return err;
  2151  
  2152  fail_dio:
  2153          if (dio.is_pinned) {
  2154                  while (head) {
  2155                          folio = head;
  2156                          head = folio_get_private(folio);
  2157                          unpin_user_page(folio_page(folio, 0));
  2158                  }
  2159                  for (; i < nr_pages; i++)
  2160                          unpin_user_page(dio.pages[i]);
  2161          }
  2162          *iter = iter_saved;
  2163          return err;
  2164  }
  2165  

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

Reply via email to