tree: https://git.kernel.org/pub/scm/linux/kernel/git/peterz/queue.git sched/cleanup head: b1c1a5a4deb824bd5612b40a0a1fffb805dd9799 commit: b1c1a5a4deb824bd5612b40a0a1fffb805dd9799 [54/54] rcu/tree: Use irq_work_queue_remote() config: x86_64-randconfig-r002-20210211 (attached as .config) compiler: clang version 12.0.0 (https://github.com/llvm/llvm-project c9439ca36342fb6013187d0a69aef92736951476) 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/peterz/queue.git/commit/?... git remote add peterz-queue https://git.kernel.org/pub/scm/linux/kernel/git/peterz/queue.git git fetch --no-tags peterz-queue sched/cleanup git checkout b1c1a5a4deb824bd5612b40a0a1fffb805dd9799 # 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(a)intel.com&gt; All errors (new ones prefixed by >>): irq_work_queue_remote(rdp->cpu, &rdp->rcu_iw); ^ kernel/rcu/tree.c:1380:5: note: did you mean 'irq_work_queue_on'? include/linux/irq_work.h:52:6: note: 'irq_work_queue_on' declared here bool irq_work_queue_on(struct irq_work *work, int cpu); ^ 1 error generated. vim +/irq_work_queue_remote +1380 kernel/rcu/tree.c 1255 1256 /* 1257 * Return true if the specified CPU has passed through a quiescent 1258 * state by virtue of being in or having passed through an dynticks 1259 * idle state since the last call to dyntick_save_progress_counter() 1260 * for this same CPU, or by virtue of having been offline. 1261 */ 1262 static int rcu_implicit_dynticks_qs(struct rcu_data *rdp) 1263 { 1264 unsigned long jtsq; 1265 bool *rnhqp; 1266 bool *ruqp; 1267 struct rcu_node *rnp = rdp->mynode; 1268 1269 raw_lockdep_assert_held_rcu_node(rnp); 1270 1271 /* 1272 * If the CPU passed through or entered a dynticks idle phase with 1273 * no active irq/NMI handlers, then we can safely pretend that the CPU 1274 * already acknowledged the request to pass through a quiescent 1275 * state. Either way, that CPU cannot possibly be in an RCU 1276 * read-side critical section that started before the beginning 1277 * of the current RCU grace period. 1278 */ 1279 if (rcu_dynticks_in_eqs_since(rdp, rdp->dynticks_snap)) { 1280 trace_rcu_fqs(rcu_state.name, rdp->gp_seq, rdp->cpu, TPS("dti")); 1281 rcu_gpnum_ovf(rnp, rdp); 1282 return 1; 1283 } 1284 1285 /* 1286 * Complain if a CPU that is considered to be offline from RCU's 1287 * perspective has not yet reported a quiescent state. After all, 1288 * the offline CPU should have reported a quiescent state during 1289 * the CPU-offline process, or, failing that, by rcu_gp_init() 1290 * if it ran concurrently with either the CPU going offline or the 1291 * last task on a leaf rcu_node structure exiting its RCU read-side 1292 * critical section while all CPUs corresponding to that structure 1293 * are offline. This added warning detects bugs in any of these 1294 * code paths. 1295 * 1296 * The rcu_node structure's ->lock is held here, which excludes 1297 * the relevant portions the CPU-hotplug code, the grace-period 1298 * initialization code, and the rcu_read_unlock() code paths. 1299 * 1300 * For more detail, please refer to the "Hotplug CPU" section 1301 * of RCU's Requirements documentation. 1302 */ 1303 if (WARN_ON_ONCE(!(rdp->grpmask & rcu_rnp_online_cpus(rnp)))) { 1304 bool onl; 1305 struct rcu_node *rnp1; 1306 1307 pr_info("%s: grp: %d-%d level: %d ->gp_seq %ld ->completedqs %ld\n", 1308 __func__, rnp->grplo, rnp->grphi, rnp->level, 1309 (long)rnp->gp_seq, (long)rnp->completedqs); 1310 for (rnp1 = rnp; rnp1; rnp1 = rnp1->parent) 1311 pr_info("%s: %d:%d ->qsmask %#lx ->qsmaskinit %#lx ->qsmaskinitnext %#lx ->rcu_gp_init_mask %#lx\n", 1312 __func__, rnp1->grplo, rnp1->grphi, rnp1->qsmask, rnp1->qsmaskinit, rnp1->qsmaskinitnext, rnp1->rcu_gp_init_mask); 1313 onl = !!(rdp->grpmask & rcu_rnp_online_cpus(rnp)); 1314 pr_info("%s %d: %c online: %ld(%d) offline: %ld(%d)\n", 1315 __func__, rdp->cpu, ".o"[onl], 1316 (long)rdp->rcu_onl_gp_seq, rdp->rcu_onl_gp_flags, 1317 (long)rdp->rcu_ofl_gp_seq, rdp->rcu_ofl_gp_flags); 1318 return 1; /* Break things loose after complaining. */ 1319 } 1320 1321 /* 1322 * A CPU running for an extended time within the kernel can 1323 * delay RCU grace periods: (1) At age jiffies_to_sched_qs, 1324 * set .rcu_urgent_qs, (2) At age 2*jiffies_to_sched_qs, set 1325 * both .rcu_need_heavy_qs and .rcu_urgent_qs. Note that the 1326 * unsynchronized assignments to the per-CPU rcu_need_heavy_qs 1327 * variable are safe because the assignments are repeated if this 1328 * CPU failed to pass through a quiescent state. This code 1329 * also checks .jiffies_resched in case jiffies_to_sched_qs 1330 * is set way high. 1331 */ 1332 jtsq = READ_ONCE(jiffies_to_sched_qs); 1333 ruqp = per_cpu_ptr(&rcu_data.rcu_urgent_qs, rdp->cpu); 1334 rnhqp = &per_cpu(rcu_data.rcu_need_heavy_qs, rdp->cpu); 1335 if (!READ_ONCE(*rnhqp) && 1336 (time_after(jiffies, rcu_state.gp_start + jtsq * 2) || 1337 time_after(jiffies, rcu_state.jiffies_resched) || 1338 rcu_state.cbovld)) { 1339 WRITE_ONCE(*rnhqp, true); 1340 /* Store rcu_need_heavy_qs before rcu_urgent_qs. */ 1341 smp_store_release(ruqp, true); 1342 } else if (time_after(jiffies, rcu_state.gp_start + jtsq)) { 1343 WRITE_ONCE(*ruqp, true); 1344 } 1345 1346 /* 1347 * NO_HZ_FULL CPUs can run in-kernel without rcu_sched_clock_irq! 1348 * The above code handles this, but only for straight cond_resched(). 1349 * And some in-kernel loops check need_resched() before calling 1350 * cond_resched(), which defeats the above code for CPUs that are 1351 * running in-kernel with scheduling-clock interrupts disabled. 1352 * So hit them over the head with the resched_cpu() hammer! 1353 */ 1354 if (tick_nohz_full_cpu(rdp->cpu) && 1355 (time_after(jiffies, READ_ONCE(rdp->last_fqs_resched) + jtsq * 3) || 1356 rcu_state.cbovld)) { 1357 WRITE_ONCE(*ruqp, true); 1358 resched_cpu(rdp->cpu); 1359 WRITE_ONCE(rdp->last_fqs_resched, jiffies); 1360 } 1361 1362 /* 1363 * If more than halfway to RCU CPU stall-warning time, invoke 1364 * resched_cpu() more frequently to try to loosen things up a bit. 1365 * Also check to see if the CPU is getting hammered with interrupts, 1366 * but only once per grace period, just to keep the IPIs down to 1367 * a dull roar. 1368 */ 1369 if (time_after(jiffies, rcu_state.jiffies_resched)) { 1370 if (time_after(jiffies, 1371 READ_ONCE(rdp->last_fqs_resched) + jtsq)) { 1372 resched_cpu(rdp->cpu); 1373 WRITE_ONCE(rdp->last_fqs_resched, jiffies); 1374 } 1375 if (!rdp->rcu_iw_pending && rdp->rcu_iw_gp_seq != rnp->gp_seq && 1376 (rnp->ffmask & rdp->grpmask)) { 1377 rdp->rcu_iw_gp_seq = rnp->gp_seq; 1378 if (likely(rdp->cpu != smp_processor_id())) { 1379 rdp->rcu_iw_pending = true; 1381 } 1382 } 1383 } 1384 1385 return 0; 1386 } 1387 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org