Re: [PATCH v3 3/7] iommu/arm-smmu-v3: Introduce a per-domain arm_smmu_invs array

kernel test robot
2025-10-27T12:07:04Z

Hi Nicolin,

kernel test robot noticed the following build errors:

[auto build test ERROR on soc/for-next]
[also build test ERROR on linus/master v6.18-rc3 next-20251027]
[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/Nicolin-Chen/iommu-arm-smmu-v3-Explicitly-set-smmu_domain-stage-for-SVA/20251016-034754
base: https://git.kernel.org/pub/scm/linux/kernel/git/soc/soc.git for-next
patch link: https://lore.kernel.org/r/345bb7703ebd19992694758b47e371900267fa0e.1760555863.git.nicolinc%40nvidia.com
patch subject: [PATCH v3 3/7] iommu/arm-smmu-v3: Introduce a per-domain arm_smmu_invs array
config: arm64-defconfig (https://download.01.org/0day-ci/archive/20251027/202510271909.iEzPjNv4-lkp@intel.com/config)
compiler: aarch64-linux-gcc (GCC) 15.1.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20251027/202510271909.iEzPjNv4-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/202510271909.iEzPjNv4-lkp@intel.com/

All errors (new ones prefixed by >>):

>> drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c:1062:23: error: static declaration of 'arm_smmu_invs_merge' follows non-static declaration
1062 | struct arm_smmu_invs *arm_smmu_invs_merge(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~
In file included from drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c:34:
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h:731:23: note: previous declaration of 'arm_smmu_invs_merge' with type 'struct arm_smmu_invs *(struct arm_smmu_invs *, struct arm_smmu_invs *)'
731 | struct arm_smmu_invs *arm_smmu_invs_merge(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~
>> drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c:1157:8: error: static declaration of 'arm_smmu_invs_unref' follows non-static declaration
1157 | size_t arm_smmu_invs_unref(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h:733:8: note: previous declaration of 'arm_smmu_invs_unref' with type 'size_t(struct arm_smmu_invs *, struct arm_smmu_invs *, void (*)(struct arm_smmu_inv *))' {aka 'long unsigned int(struct arm_smmu_invs *, struct arm_smmu_invs *, void (*)(struct arm_smmu_inv *))'}
733 | size_t arm_smmu_invs_unref(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~
>> drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c:1227:23: error: static declaration of 'arm_smmu_invs_purge' follows non-static declaration
1227 | struct arm_smmu_invs *arm_smmu_invs_purge(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h:736:23: note: previous declaration of 'arm_smmu_invs_purge' with type 'struct arm_smmu_invs *(struct arm_smmu_invs *, size_t)' {aka 'struct arm_smmu_invs *(struct arm_smmu_invs *, long unsigned int)'}
736 | struct arm_smmu_invs *arm_smmu_invs_purge(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c:1227:23: warning: 'arm_smmu_invs_purge' defined but not used [-Wunused-function]
1227 | struct arm_smmu_invs *arm_smmu_invs_purge(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c:1157:8: warning: 'arm_smmu_invs_unref' defined but not used [-Wunused-function]
1157 | size_t arm_smmu_invs_unref(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c:1062:23: warning: 'arm_smmu_invs_merge' defined but not used [-Wunused-function]
1062 | struct arm_smmu_invs *arm_smmu_invs_merge(struct arm_smmu_invs *invs,
| ^~~~~~~~~~~~~~~~~~~

vim +/arm_smmu_invs_merge +1062 drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

1043
1044 /**
1045 * arm_smmu_invs_merge() - Merge @to_merge into @invs and generate a new array
1046 * @invs: the base invalidation array
1047 * @to_merge: an array of invlidations to merge
1048 *
1049 * Return: a newly allocated array on success, or ERR_PTR
1050 *
1051 * This function must be locked and serialized with arm_smmu_invs_unref() and
1052 * arm_smmu_invs_purge(), but do not lockdep on any lock for KUNIT test.
1053 *
1054 * Both @invs and @to_merge must be sorted, to ensure the returned array will be
1055 * sorted as well.
1056 *
1057 * Caller is resposible for freeing the @invs and the returned new one.
1058 *
1059 * Entries marked as trash will be purged in the returned array.
1060 */
1061 VISIBLE_IF_KUNIT
> 1062 struct arm_smmu_invs *arm_smmu_invs_merge(struct arm_smmu_invs *invs,
1063 struct arm_smmu_invs *to_merge)
1064 {
1065 struct arm_smmu_invs *new_invs;
1066 struct arm_smmu_inv *new;
1067 size_t num_trashes = 0;
1068 size_t num_adds = 0;
1069 size_t i, j;
1070
1071 for (i = j = 0; i != invs->num_invs || j != to_merge->num_invs;) {
1072 int cmp = arm_smmu_invs_cmp(invs, i, to_merge, j);
1073
1074 /* Skip any unwanted trash entry */
1075 if (cmp < 0 && !refcount_read(&invs->inv[i].users)) {
1076 num_trashes++;
1077 i++;
1078 continue;
1079 }
1080
1081 if (cmp < 0) {
1082 /* not found in to_merge, leave alone */
1083 i++;
1084 } else if (cmp == 0) {
1085 /* same item */
1086 i++;
1087 j++;
1088 } else {
1089 /* unique to to_merge */
1090 num_adds++;
1091 j++;
1092 }
1093 }
1094
1095 new_invs = arm_smmu_invs_alloc(invs->num_invs - num_trashes + num_adds);
1096 if (IS_ERR(new_invs))
1097 return new_invs;
1098
1099 new = new_invs->inv;
1100 for (i = j = 0; i != invs->num_invs || j != to_merge->num_invs;) {
1101 int cmp = arm_smmu_invs_cmp(invs, i, to_merge, j);
1102
1103 if (cmp <= 0 && !refcount_read(&invs->inv[i].users)) {
1104 i++;
1105 continue;
1106 }
1107
1108 if (cmp < 0) {
1109 *new = invs->inv[i];
1110 i++;
1111 } else if (cmp == 0) {
1112 *new = invs->inv[i];
1113 refcount_inc(&new->users);
1114 i++;
1115 j++;
1116 } else {
1117 *new = to_merge->inv[j];
1118 refcount_set(&new->users, 1);
1119 j++;
1120 }
1121
1122 if (new != new_invs->inv)
1123 WARN_ON_ONCE(arm_smmu_inv_cmp(new - 1, new) == 1);
1124 new++;
1125 }
1126
1127 WARN_ON(new != new_invs->inv + new_invs->num_invs);
1128
1129 return new_invs;
1130 }
1131 EXPORT_SYMBOL_IF_KUNIT(arm_smmu_invs_merge);
1132
1133 /**
1134 * arm_smmu_invs_unref() - Find in @invs for all entries in @to_unref, decrease
1135 * the user counts without deletions
1136 * @invs: the base invalidation array
1137 * @to_unref: an array of invlidations to decrease their user counts
1138 * @flush_fn: A callback function to invoke, when an entry's user count reduces
1139 * to 0
1140 *
1141 * Return: the number of trash entries in the array, for arm_smmu_invs_purge()
1142 *
1143 * This function will not fail. Any entry with users=0 will be marked as trash.
1144 * All tailing trash entries in the array will be dropped. And the size of the
1145 * array will be trimmed properly. All trash entries in-between will remain in
1146 * the @invs until being completely deleted by the next arm_smmu_invs_merge()
1147 * or an arm_smmu_invs_purge() function call.
1148 *
1149 * This function must be locked and serialized with arm_smmu_invs_merge() and
1150 * arm_smmu_invs_purge(), but do not lockdep on any mutex for KUNIT test.
1151 *
1152 * Note that the final @invs->num_invs might not reflect the actual number of
1153 * invalidations due to trash entries. Any reader should take the read lock to
1154 * iterate each entry and check its users counter till the last entry.
1155 */
1156 VISIBLE_IF_KUNIT
> 1157 size_t arm_smmu_invs_unref(struct arm_smmu_invs *invs,
1158 struct arm_smmu_invs *to_unref,
1159 void (*flush_fn)(struct arm_smmu_inv *inv))
1160 {
1161 unsigned long flags;
1162 size_t num_trashes = 0;
1163 size_t num_invs = 0;
1164 size_t i, j;
1165
1166 for (i = j = 0; i != invs->num_invs || j != to_unref->num_invs;) {
1167 int cmp;
1168
1169 /* Skip any existing trash entry */
1170 if (cmp <= 0 && !refcount_read(&invs->inv[i].users)) {
1171 num_trashes++;
1172 i++;
1173 continue;
1174 }
1175
1176 cmp = arm_smmu_invs_cmp(invs, i, to_unref, j);
1177 if (cmp < 0) {
1178 /* not found in to_unref, leave alone */
1179 i++;
1180 num_invs = i;
1181 } else if (cmp == 0) {
1182 /* same item */
1183 if (refcount_dec_and_test(&invs->inv[i].users)) {
1184 /* KUNIT test doesn't pass in a flush_fn */
1185 if (flush_fn)
1186 flush_fn(&invs->inv[i]);
1187 num_trashes++;
1188 } else {
1189 num_invs = i + 1;
1190 }
1191 i++;
1192 j++;
1193 } else {
1194 /* item in to_unref is not in invs or already a trash */
1195 WARN_ON(true);
1196 j++;
1197 }
1198 }
1199
1200 /* Exclude any tailing trash */
1201 num_trashes -= invs->num_invs - num_invs;
1202
1203 /* The lock is required to fence concurrent ATS operations. */
1204 write_lock_irqsave(&invs->rwlock, flags);
1205 WRITE_ONCE(invs->num_invs, num_invs); /* Remove tailing trash entries */
1206 write_unlock_irqrestore(&invs->rwlock, flags);
1207
1208 return num_trashes;
1209 }
1210 EXPORT_SYMBOL_IF_KUNIT(arm_smmu_invs_unref);
1211
1212 /**
1213 * arm_smmu_invs_purge() - Purge all the trash entries in the @invs
1214 * @invs: the base invalidation array
1215 * @num_trashes: expected number of trash entries, typically returned by a prior
1216 * arm_smmu_invs_unref() call
1217 *
1218 * Return: a newly allocated array on success removing all the trash entries, or
1219 * NULL on failure
1220 *
1221 * This function must be locked and serialized with arm_smmu_invs_merge() and
1222 * arm_smmu_invs_unref(), but do not lockdep on any lock for KUNIT test.
1223 *
1224 * Caller is resposible for freeing the @invs and the returned new one.
1225 */
1226 VISIBLE_IF_KUNIT
> 1227 struct arm_smmu_invs *arm_smmu_invs_purge(struct arm_smmu_invs *invs,
1228 size_t num_trashes)
1229 {
1230 struct arm_smmu_invs *new_invs;
1231 size_t i, j;
1232
1233 if (WARN_ON(invs->num_invs < num_trashes))
1234 return NULL;
1235
1236 new_invs = arm_smmu_invs_alloc(invs->num_invs - num_trashes);
1237 if (IS_ERR(new_invs))
1238 return NULL;
1239
1240 for (i = j = 0; i != invs->num_invs; i++) {
1241 if (!refcount_read(&invs->inv[i].users))
1242 continue;
1243 new_invs->inv[j] = invs->inv[i];
1244 j++;
1245 }
1246
1247 WARN_ON(j != new_invs->num_invs);
1248 return new_invs;
1249 }
1250 EXPORT_SYMBOL_IF_KUNIT(arm_smmu_invs_purge);
1251

--
0-DAY CI Kernel Test Service