fs/xfs/xfs_reflink.c:992:12: warning: variable 'qdelta' set but not used

From: kernel test robot
Date: Wed Jun 02 2021 - 14:26:58 EST

tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
head: 231bc539066760aaa44d46818c85b14ca2f56d9f
commit: f273387b048543f2b8b2d809cc65fca28e7788a1 xfs: refactor reflink functions to use xfs_trans_alloc_inode
date: 4 months ago
config: x86_64-randconfig-a013-20210602 (attached as .config)
compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project d41cb6bb2607fa5c7a9df2b3dab361353657d225)
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
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f273387b048543f2b8b2d809cc65fca28e7788a1
git remote add linus https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
git fetch --no-tags linus master
git checkout f273387b048543f2b8b2d809cc65fca28e7788a1
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64

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

All warnings (new ones prefixed by >>):

>> fs/xfs/xfs_reflink.c:992:12: warning: variable 'qdelta' set but not used [-Wunused-but-set-variable]
int64_t qdelta = 0;
^
1 warning generated.


vim +/qdelta +992 fs/xfs/xfs_reflink.c

977
978 /*
979 * Remap the given extent into the file. The dmap blockcount will be set to
980 * the number of blocks that were actually remapped.
981 */
982 STATIC int
983 xfs_reflink_remap_extent(
984 struct xfs_inode *ip,
985 struct xfs_bmbt_irec *dmap,
986 xfs_off_t new_isize)
987 {
988 struct xfs_bmbt_irec smap;
989 struct xfs_mount *mp = ip->i_mount;
990 struct xfs_trans *tp;
991 xfs_off_t newlen;
> 992 int64_t qdelta = 0;
993 unsigned int resblks;
994 bool smap_real;
995 bool dmap_written = xfs_bmap_is_written_extent(dmap);
996 int iext_delta = 0;
997 int nimaps;
998 int error;
999
1000 /*
1001 * Start a rolling transaction to switch the mappings.
1002 *
1003 * Adding a written extent to the extent map can cause a bmbt split,
1004 * and removing a mapped extent from the extent can cause a bmbt split.
1005 * The two operations cannot both cause a split since they operate on
1006 * the same index in the bmap btree, so we only need a reservation for
1007 * one bmbt split if either thing is happening. However, we haven't
1008 * locked the inode yet, so we reserve assuming this is the case.
1009 */
1010 resblks = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
1011 error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, resblks, 0,
1012 false, &tp);
1013 if (error)
1014 goto out;
1015
1016 /*
1017 * Read what's currently mapped in the destination file into smap.
1018 * If smap isn't a hole, we will have to remove it before we can add
1019 * dmap to the destination file.
1020 */
1021 nimaps = 1;
1022 error = xfs_bmapi_read(ip, dmap->br_startoff, dmap->br_blockcount,
1023 &smap, &nimaps, 0);
1024 if (error)
1025 goto out_cancel;
1026 ASSERT(nimaps == 1 && smap.br_startoff == dmap->br_startoff);
1027 smap_real = xfs_bmap_is_real_extent(&smap);
1028
1029 /*
1030 * We can only remap as many blocks as the smaller of the two extent
1031 * maps, because we can only remap one extent at a time.
1032 */
1033 dmap->br_blockcount = min(dmap->br_blockcount, smap.br_blockcount);
1034 ASSERT(dmap->br_blockcount == smap.br_blockcount);
1035
1036 trace_xfs_reflink_remap_extent_dest(ip, &smap);
1037
1038 /*
1039 * Two extents mapped to the same physical block must not have
1040 * different states; that's filesystem corruption. Move on to the next
1041 * extent if they're both holes or both the same physical extent.
1042 */
1043 if (dmap->br_startblock == smap.br_startblock) {
1044 if (dmap->br_state != smap.br_state)
1045 error = -EFSCORRUPTED;
1046 goto out_cancel;
1047 }
1048
1049 /* If both extents are unwritten, leave them alone. */
1050 if (dmap->br_state == XFS_EXT_UNWRITTEN &&
1051 smap.br_state == XFS_EXT_UNWRITTEN)
1052 goto out_cancel;
1053
1054 /* No reflinking if the AG of the dest mapping is low on space. */
1055 if (dmap_written) {
1056 error = xfs_reflink_ag_has_free_space(mp,
1057 XFS_FSB_TO_AGNO(mp, dmap->br_startblock));
1058 if (error)
1059 goto out_cancel;
1060 }
1061
1062 /*
1063 * Increase quota reservation if we think the quota block counter for
1064 * this file could increase.
1065 *
1066 * If we are mapping a written extent into the file, we need to have
1067 * enough quota block count reservation to handle the blocks in that
1068 * extent. We log only the delta to the quota block counts, so if the
1069 * extent we're unmapping also has blocks allocated to it, we don't
1070 * need a quota reservation for the extent itself.
1071 *
1072 * Note that if we're replacing a delalloc reservation with a written
1073 * extent, we have to take the full quota reservation because removing
1074 * the delalloc reservation gives the block count back to the quota
1075 * count. This is suboptimal, but the VFS flushed the dest range
1076 * before we started. That should have removed all the delalloc
1077 * reservations, but we code defensively.
1078 */
1079 if (!smap_real && dmap_written) {
1080 error = xfs_trans_reserve_quota_nblks(tp, ip,
1081 dmap->br_blockcount, 0, false);
1082 if (error)
1083 goto out_cancel;
1084 }
1085
1086 if (smap_real)
1087 ++iext_delta;
1088
1089 if (dmap_written)
1090 ++iext_delta;
1091
1092 error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, iext_delta);
1093 if (error)
1094 goto out_cancel;
1095
1096 if (smap_real) {
1097 /*
1098 * If the extent we're unmapping is backed by storage (written
1099 * or not), unmap the extent and drop its refcount.
1100 */
1101 xfs_bmap_unmap_extent(tp, ip, &smap);
1102 xfs_refcount_decrease_extent(tp, &smap);
1103 qdelta -= smap.br_blockcount;
1104 } else if (smap.br_startblock == DELAYSTARTBLOCK) {
1105 xfs_filblks_t len = smap.br_blockcount;
1106
1107 /*
1108 * If the extent we're unmapping is a delalloc reservation,
1109 * we can use the regular bunmapi function to release the
1110 * incore state. Dropping the delalloc reservation takes care
1111 * of the quota reservation for us.
1112 */
1113 error = __xfs_bunmapi(NULL, ip, smap.br_startoff, &len, 0, 1);
1114 if (error)
1115 goto out_cancel;
1116 ASSERT(len == 0);
1117 }
1118
1119 /*
1120 * If the extent we're sharing is backed by written storage, increase
1121 * its refcount and map it into the file.
1122 */
1123 if (dmap_written) {
1124 xfs_refcount_increase_extent(tp, dmap);
1125 xfs_bmap_map_extent(tp, ip, dmap);
1126 qdelta += dmap->br_blockcount;
1127 }
1128
1129 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, qdelta);
1130
1131 /* Update dest isize if needed. */
1132 newlen = XFS_FSB_TO_B(mp, dmap->br_startoff + dmap->br_blockcount);
1133 newlen = min_t(xfs_off_t, newlen, new_isize);
1134 if (newlen > i_size_read(VFS_I(ip))) {
1135 trace_xfs_reflink_update_inode_size(ip, newlen);
1136 i_size_write(VFS_I(ip), newlen);
1137 ip->i_d.di_size = newlen;
1138 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1139 }
1140
1141 /* Commit everything and unlock. */
1142 error = xfs_trans_commit(tp);
1143 goto out_unlock;
1144
1145 out_cancel:
1146 xfs_trans_cancel(tp);
1147 out_unlock:
1148 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1149 out:
1150 if (error)
1151 trace_xfs_reflink_remap_extent_error(ip, error, _RET_IP_);
1152 return error;
1153 }
1154

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

Attachment: .config.gz
Description: application/gzip