[dhowells-fs:netfs-folio-regions 13/28] fs/netfs/write_helper.c:758:25: error: implicit declaration of function 'flush_dcache_folio'; did you mean 'flush_dcache_page'?

From: kernel test robot
Date: Thu Aug 19 2021 - 13:36:43 EST

tree: https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git netfs-folio-regions
head: 215a4ee495a95cc73256ed76f91cb78bcabd6b8e
commit: ec49a6ac065699ec5e4f782529b05681d970dde9 [13/28] netfs: Keep lists of pending, active, dirty and flushed regions
config: sh-allmodconfig (attached as .config)
compiler: sh4-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/commit/?id=ec49a6ac065699ec5e4f782529b05681d970dde9
git remote add dhowells-fs https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git
git fetch --no-tags dhowells-fs netfs-folio-regions
git checkout ec49a6ac065699ec5e4f782529b05681d970dde9
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross ARCH=sh

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@xxxxxxxxx>

All errors (new ones prefixed by >>):

In file included from include/linux/kernel.h:16,
from include/linux/list.h:9,
from include/linux/wait.h:7,
from include/linux/wait_bit.h:8,
from include/linux/fs.h:6,
from fs/netfs/write_helper.c:9:
fs/netfs/write_helper.c: In function 'copy_folio_from_iter_atomic':
include/linux/minmax.h:20:35: warning: comparison of distinct pointer types lacks a cast
20 | (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1)))
| ^~
include/linux/minmax.h:26:18: note: in expansion of macro '__typecheck'
26 | (__typecheck(x, y) && __no_side_effects(x, y))
| ^~~~~~~~~~~
include/linux/minmax.h:36:31: note: in expansion of macro '__safe_cmp'
36 | __builtin_choose_expr(__safe_cmp(x, y), \
| ^~~~~~~~~~
include/linux/minmax.h:45:25: note: in expansion of macro '__careful_cmp'
45 | #define min(x, y) __careful_cmp(x, y, <)
| ^~~~~~~~~~~~~
fs/netfs/write_helper.c:25:40: note: in expansion of macro 'min'
25 | unsigned int psize = min(PAGE_SIZE - offset, size);
| ^~~
fs/netfs/write_helper.c: In function 'netfs_perform_write':
>> fs/netfs/write_helper.c:758:25: error: implicit declaration of function 'flush_dcache_folio'; did you mean 'flush_dcache_page'? [-Werror=implicit-function-declaration]
758 | flush_dcache_folio(folio);
| ^~~~~~~~~~~~~~~~~~
| flush_dcache_page
>> fs/netfs/write_helper.c:784:58: error: 'struct netfs_i_context' has no member named 'cache'
784 | fscache_update_cookie(ctx->cache, NULL);
| ^~
cc1: some warnings being treated as errors

Kconfig warnings: (for reference only)
WARNING: unmet direct dependencies detected for SND_ATMEL_SOC_PDC
Depends on SOUND && !UML && SND && SND_SOC && SND_ATMEL_SOC && HAS_DMA
Selected by
- SND_ATMEL_SOC_SSC && SOUND && !UML && SND && SND_SOC && SND_ATMEL_SOC
- SND_ATMEL_SOC_SSC_PDC && SOUND && !UML && SND && SND_SOC && SND_ATMEL_SOC && ATMEL_SSC


vim +758 fs/netfs/write_helper.c

680
681 /*
682 * Write data into a prereserved region of the pagecache attached to a netfs
683 * inode.
684 */
685 static ssize_t netfs_perform_write(struct netfs_dirty_region *region,
686 struct kiocb *iocb, struct iov_iter *i)
687 {
688 struct file *file = iocb->ki_filp;
689 struct netfs_i_context *ctx = netfs_i_context(file_inode(file));
690 struct folio *folio;
691 ssize_t written = 0, ret;
692 loff_t new_pos, i_size;
693 bool always_fill = false;
694
695 do {
696 size_t plen;
697 size_t offset; /* Offset into pagecache page */
698 size_t bytes; /* Bytes to write to page */
699 size_t copied; /* Bytes copied from user */
700 bool relock = false;
701
702 folio = netfs_grab_folio_for_write(file->f_mapping,
703 region->dirty.end,
704 iov_iter_count(i));
705 if (!folio)
706 return -ENOMEM;
707
708 plen = folio_size(folio);
709 offset = region->dirty.end - folio_file_pos(folio);
710 bytes = min_t(size_t, plen - offset, iov_iter_count(i));
711
712 if (!folio_test_uptodate(folio)) {
713 folio_unlock(folio); /* Avoid deadlocking fault-in */
714 relock = true;
715 }
716
717 /* Bring in the user page that we will copy from _first_.
718 * Otherwise there's a nasty deadlock on copying from the
719 * same page as we're writing to, without it being marked
720 * up-to-date.
721 *
722 * Not only is this an optimisation, but it is also required
723 * to check that the address is actually valid, when atomic
724 * usercopies are used, below.
725 */
726 if (unlikely(iov_iter_fault_in_readable(i, bytes))) {
727 ret = -EFAULT;
728 goto error_folio;
729 }
730
731 if (fatal_signal_pending(current)) {
732 ret = -EINTR;
733 goto error_folio;
734 }
735
736 if (relock) {
737 ret = folio_lock_killable(folio);
738 if (ret < 0)
739 goto error_folio;
740 }
741
742 redo_prefetch:
743 /* Prefetch area to be written into the cache if we're caching
744 * this file. We need to do this before we get a lock on the
745 * folio in case there's more than one writer competing for the
746 * same cache block.
747 */
748 if (!folio_test_uptodate(folio)) {
749 ret = netfs_prefetch_for_write(file, folio, region->dirty.end,
750 bytes, always_fill);
751 if (ret < 0) {
752 kdebug("prefetch %zx", ret);
753 goto error_folio;
754 }
755 }
756
757 if (mapping_writably_mapped(folio_file_mapping(folio)))
> 758 flush_dcache_folio(folio);
759 copied = copy_folio_from_iter_atomic(folio, offset, bytes, i);
760 flush_dcache_folio(folio);
761
762 /* Deal with a (partially) failed copy */
763 if (!folio_test_uptodate(folio)) {
764 if (copied == 0) {
765 ret = -EFAULT;
766 goto error_folio;
767 }
768 if (copied < bytes) {
769 iov_iter_revert(i, copied);
770 always_fill = true;
771 goto redo_prefetch;
772 }
773 folio_mark_uptodate(folio);
774 }
775
776 /* Update the inode size if we moved the EOF marker */
777 new_pos = region->dirty.end + copied;
778 i_size = i_size_read(file_inode(file));
779 if (new_pos > i_size) {
780 if (ctx->ops->update_i_size) {
781 ctx->ops->update_i_size(file, new_pos);
782 } else {
783 i_size_write(file_inode(file), new_pos);
> 784 fscache_update_cookie(ctx->cache, NULL);
785 }
786 }
787
788 /* Update the region appropriately */
789 if (i_size > region->i_size)
790 region->i_size = i_size;
791 smp_store_release(&region->dirty.end, new_pos);
792
793 trace_netfs_dirty(ctx, region, NULL, netfs_dirty_trace_modified);
794 folio_mark_dirty(folio);
795 folio_unlock(folio);
796 folio_put(folio);
797 folio = NULL;
798
799 cond_resched();
800
801 written += copied;
802
803 balance_dirty_pages_ratelimited(file->f_mapping);
804 } while (iov_iter_count(i));
805
806 out:
807 if (likely(written)) {
808 iocb->ki_pos += written;
809
810 /* Flush and wait for a write that requires immediate synchronisation. */
811 if (region->type == NETFS_REGION_DSYNC) {
812 kdebug("dsync");
813 spin_lock(&ctx->lock);
814 netfs_flush_region(ctx, region, netfs_dirty_trace_flush_dsync);
815 spin_unlock(&ctx->lock);
816
817 ret = wait_on_region(region, NETFS_REGION_IS_COMPLETE);
818 if (ret < 0)
819 written = ret;
820 }
821 }
822
823 netfs_commit_write(ctx, region);
824 return written ? written : ret;
825
826 error_folio:
827 folio_unlock(folio);
828 folio_put(folio);
829 goto out;
830 }
831

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@xxxxxxxxxxxx

Attachment: .config.gz
Description: application/gzip