* [jlayton:mgctime 8/10] fs/xfs/xfs_iops.c:920:4: error: call to undeclared function 'current_mgtime'; ISO C99 and later do not support implicit function declarations
@ 2023-08-03 20:52 kernel test robot
0 siblings, 0 replies; only message in thread
From: kernel test robot @ 2023-08-03 20:52 UTC (permalink / raw)
To: Jeff Layton; +Cc: llvm, oe-kbuild-all
tree: https://git.kernel.org/pub/scm/linux/kernel/git/jlayton/linux.git mgctime
head: ffef667f9698cae637fe41b46df59816f79c050f
commit: 710fc0a96d7a0e69f16b6ded3de9959969246c3e [8/10] xfs: switch to multigrain timestamps
config: riscv-randconfig-r023-20230731 (https://download.01.org/0day-ci/archive/20230804/202308040449.cQuIsvCc-lkp@intel.com/config)
compiler: clang version 17.0.0 (https://github.com/llvm/llvm-project.git 4a5ac14ee968ff0ad5d2cc1ffa0299048db4c88a)
reproduce: (https://download.01.org/0day-ci/archive/20230804/202308040449.cQuIsvCc-lkp@intel.com/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 <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202308040449.cQuIsvCc-lkp@intel.com/
All errors (new ones prefixed by >>):
>> fs/xfs/xfs_iops.c:920:4: error: call to undeclared function 'current_mgtime'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
920 | current_mgtime(inode);
| ^
fs/xfs/xfs_iops.c:920:4: note: did you mean 'current_time'?
include/linux/fs.h:1477:19: note: 'current_time' declared here
1477 | struct timespec64 current_time(struct inode *inode);
| ^
>> fs/xfs/xfs_iops.c:919:37: error: assigning to 'struct timespec64' from incompatible type 'int'
919 | iattr->ia_ctime = iattr->ia_mtime =
| ^
920 | current_mgtime(inode);
| ~~~~~~~~~~~~~~~~~~~~~
2 errors generated.
vim +/current_mgtime +920 fs/xfs/xfs_iops.c
772
773 /*
774 * Truncate file. Must have write permission and not be a directory.
775 *
776 * Caution: The caller of this function is responsible for calling
777 * setattr_prepare() or otherwise verifying the change is fine.
778 */
779 STATIC int
780 xfs_setattr_size(
781 struct mnt_idmap *idmap,
782 struct dentry *dentry,
783 struct xfs_inode *ip,
784 struct iattr *iattr)
785 {
786 struct xfs_mount *mp = ip->i_mount;
787 struct inode *inode = VFS_I(ip);
788 xfs_off_t oldsize, newsize;
789 struct xfs_trans *tp;
790 int error;
791 uint lock_flags = 0;
792 bool did_zeroing = false;
793
794 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
795 ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
796 ASSERT(S_ISREG(inode->i_mode));
797 ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
798 ATTR_MTIME_SET|ATTR_TIMES_SET)) == 0);
799
800 oldsize = inode->i_size;
801 newsize = iattr->ia_size;
802
803 /*
804 * Short circuit the truncate case for zero length files.
805 */
806 if (newsize == 0 && oldsize == 0 && ip->i_df.if_nextents == 0) {
807 if (!(iattr->ia_valid & (ATTR_CTIME|ATTR_MTIME)))
808 return 0;
809
810 /*
811 * Use the regular setattr path to update the timestamps.
812 */
813 iattr->ia_valid &= ~ATTR_SIZE;
814 return xfs_setattr_nonsize(idmap, dentry, ip, iattr);
815 }
816
817 /*
818 * Make sure that the dquots are attached to the inode.
819 */
820 error = xfs_qm_dqattach(ip);
821 if (error)
822 return error;
823
824 /*
825 * Wait for all direct I/O to complete.
826 */
827 inode_dio_wait(inode);
828
829 /*
830 * File data changes must be complete before we start the transaction to
831 * modify the inode. This needs to be done before joining the inode to
832 * the transaction because the inode cannot be unlocked once it is a
833 * part of the transaction.
834 *
835 * Start with zeroing any data beyond EOF that we may expose on file
836 * extension, or zeroing out the rest of the block on a downward
837 * truncate.
838 */
839 if (newsize > oldsize) {
840 trace_xfs_zero_eof(ip, oldsize, newsize - oldsize);
841 error = xfs_zero_range(ip, oldsize, newsize - oldsize,
842 &did_zeroing);
843 } else {
844 /*
845 * iomap won't detect a dirty page over an unwritten block (or a
846 * cow block over a hole) and subsequently skips zeroing the
847 * newly post-EOF portion of the page. Flush the new EOF to
848 * convert the block before the pagecache truncate.
849 */
850 error = filemap_write_and_wait_range(inode->i_mapping, newsize,
851 newsize);
852 if (error)
853 return error;
854 error = xfs_truncate_page(ip, newsize, &did_zeroing);
855 }
856
857 if (error)
858 return error;
859
860 /*
861 * We've already locked out new page faults, so now we can safely remove
862 * pages from the page cache knowing they won't get refaulted until we
863 * drop the XFS_MMAP_EXCL lock after the extent manipulations are
864 * complete. The truncate_setsize() call also cleans partial EOF page
865 * PTEs on extending truncates and hence ensures sub-page block size
866 * filesystems are correctly handled, too.
867 *
868 * We have to do all the page cache truncate work outside the
869 * transaction context as the "lock" order is page lock->log space
870 * reservation as defined by extent allocation in the writeback path.
871 * Hence a truncate can fail with ENOMEM from xfs_trans_alloc(), but
872 * having already truncated the in-memory version of the file (i.e. made
873 * user visible changes). There's not much we can do about this, except
874 * to hope that the caller sees ENOMEM and retries the truncate
875 * operation.
876 *
877 * And we update in-core i_size and truncate page cache beyond newsize
878 * before writeback the [i_disk_size, newsize] range, so we're
879 * guaranteed not to write stale data past the new EOF on truncate down.
880 */
881 truncate_setsize(inode, newsize);
882
883 /*
884 * We are going to log the inode size change in this transaction so
885 * any previous writes that are beyond the on disk EOF and the new
886 * EOF that have not been written out need to be written here. If we
887 * do not write the data out, we expose ourselves to the null files
888 * problem. Note that this includes any block zeroing we did above;
889 * otherwise those blocks may not be zeroed after a crash.
890 */
891 if (did_zeroing ||
892 (newsize > ip->i_disk_size && oldsize != ip->i_disk_size)) {
893 error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
894 ip->i_disk_size, newsize - 1);
895 if (error)
896 return error;
897 }
898
899 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
900 if (error)
901 return error;
902
903 lock_flags |= XFS_ILOCK_EXCL;
904 xfs_ilock(ip, XFS_ILOCK_EXCL);
905 xfs_trans_ijoin(tp, ip, 0);
906
907 /*
908 * Only change the c/mtime if we are changing the size or we are
909 * explicitly asked to change it. This handles the semantic difference
910 * between truncate() and ftruncate() as implemented in the VFS.
911 *
912 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
913 * special case where we need to update the times despite not having
914 * these flags set. For all other operations the VFS set these flags
915 * explicitly if it wants a timestamp update.
916 */
917 if (newsize != oldsize &&
918 !(iattr->ia_valid & (ATTR_CTIME | ATTR_MTIME))) {
> 919 iattr->ia_ctime = iattr->ia_mtime =
> 920 current_mgtime(inode);
921 iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
922 }
923
924 /*
925 * The first thing we do is set the size to new_size permanently on
926 * disk. This way we don't have to worry about anyone ever being able
927 * to look at the data being freed even in the face of a crash.
928 * What we're getting around here is the case where we free a block, it
929 * is allocated to another file, it is written to, and then we crash.
930 * If the new data gets written to the file but the log buffers
931 * containing the free and reallocation don't, then we'd end up with
932 * garbage in the blocks being freed. As long as we make the new size
933 * permanent before actually freeing any blocks it doesn't matter if
934 * they get written to.
935 */
936 ip->i_disk_size = newsize;
937 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
938
939 if (newsize <= oldsize) {
940 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, newsize);
941 if (error)
942 goto out_trans_cancel;
943
944 /*
945 * Truncated "down", so we're removing references to old data
946 * here - if we delay flushing for a long time, we expose
947 * ourselves unduly to the notorious NULL files problem. So,
948 * we mark this inode and flush it when the file is closed,
949 * and do not wait the usual (long) time for writeout.
950 */
951 xfs_iflags_set(ip, XFS_ITRUNCATED);
952
953 /* A truncate down always removes post-EOF blocks. */
954 xfs_inode_clear_eofblocks_tag(ip);
955 }
956
957 ASSERT(!(iattr->ia_valid & (ATTR_UID | ATTR_GID)));
958 setattr_copy(idmap, inode, iattr);
959 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
960
961 XFS_STATS_INC(mp, xs_ig_attrchg);
962
963 if (xfs_has_wsync(mp))
964 xfs_trans_set_sync(tp);
965
966 error = xfs_trans_commit(tp);
967 out_unlock:
968 if (lock_flags)
969 xfs_iunlock(ip, lock_flags);
970 return error;
971
972 out_trans_cancel:
973 xfs_trans_cancel(tp);
974 goto out_unlock;
975 }
976
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2023-08-03 20:52 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2023-08-03 20:52 [jlayton:mgctime 8/10] fs/xfs/xfs_iops.c:920:4: error: call to undeclared function 'current_mgtime'; ISO C99 and later do not support implicit function declarations kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.