tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master head: 0513e464f9007b70b96740271a948ca5ab6e7dd7 commit: f273387b048543f2b8b2d809cc65fca28e7788a1 xfs: refactor reflink functions to use xfs_trans_alloc_inode date: 8 months ago config: i386-randconfig-a015-20210927 (attached as .config) compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project dc6e8dfdfe7efecfda318d43a06fae18b40eb498) 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/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 W=1 ARCH=i386 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot 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@lists.01.org