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