Hi brookxu, [FYI, it's a private test report for your RFC patch.] [auto build test WARNING on tip/timers/core] [also build test WARNING on v5.14-rc5 next-20210811] [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] url: https://github.com/0day-ci/linux/commits/brookxu/clocksource-skip-check-w... base: https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git 1e7f7fbcd40c69d23e3fe641ead9f3dc128fa8aa config: x86_64-randconfig-c001-20210810 (attached as .config) compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project d39ebdae674c8efc84ebe8dc32716ec353220530) 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://github.com/0day-ci/linux/commit/085c7bc9e8da6deabad14b2093bd8409c... git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review brookxu/clocksource-skip-check-while-watchdog-hung-up-or-unstable/20210811-175707 git checkout 085c7bc9e8da6deabad14b2093bd8409cb77b3be # 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 warnings (new ones prefixed by >>): pr_warn("timekeeping watchdog on CPU%d seems hung up or unstable:"); ~^ include/linux/printk.h:400:29: note: expanded from macro 'pr_warn' printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__) ^~~ kernel/time/clocksource.c:8:41: note: expanded from macro 'pr_fmt' #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt ^~~ 1 warning generated. vim +403 kernel/time/clocksource.c 352 353 static void clocksource_watchdog(struct timer_list *unused) 354 { 355 u64 csnow, wdnow, cslast, wdlast, delta; 356 int next_cpu, reset_pending; 357 int64_t wd_nsec, cs_nsec; 358 struct clocksource *cs; 359 u32 md; 360 361 spin_lock(&watchdog_lock); 362 if (!watchdog_running) 363 goto out; 364 365 reset_pending = atomic_read(&watchdog_reset_pending); 366 367 list_for_each_entry(cs, &watchdog_list, wd_list) { 368 369 /* Clocksource already marked unstable? */ 370 if (cs->flags & CLOCK_SOURCE_UNSTABLE) { 371 if (finished_booting) 372 schedule_work(&watchdog_work); 373 continue; 374 } 375 376 if (!cs_watchdog_read(cs, &csnow, &wdnow)) { 377 /* Clock readout unreliable, so give it up. */ 378 __clocksource_unstable(cs); 379 continue; 380 } 381 382 /* Clocksource initialized ? */ 383 if (!(cs->flags & CLOCK_SOURCE_WATCHDOG) || 384 atomic_read(&watchdog_reset_pending)) { 385 cs->flags |= CLOCK_SOURCE_WATCHDOG; 386 cs->wd_last = wdnow; 387 cs->cs_last = csnow; 388 continue; 389 } 390 391 delta = clocksource_delta(wdnow, cs->wd_last, watchdog->mask); 392 wd_nsec = clocksource_cyc2ns(delta, watchdog->mult, 393 watchdog->shift); 394 395 delta = clocksource_delta(csnow, cs->cs_last, cs->mask); 396 cs_nsec = clocksource_cyc2ns(delta, cs->mult, cs->shift); 397 wdlast = cs->wd_last; /* save these in case we print them */ 398 cslast = cs->cs_last; 399 cs->cs_last = csnow; 400 cs->wd_last = wdnow; 401 402 if (!wd_nsec) { 404 pr_warn("'%s' wd_now: %llx wd_last: %llx mask: %llx\n", 405 watchdog->name, wdnow, wdlast, watchdog->mask); 406 continue; 407 } 408 409 if (atomic_read(&watchdog_reset_pending)) 410 continue; 411 412 /* Check the deviation from the watchdog clocksource. */ 413 md = cs->uncertainty_margin + watchdog->uncertainty_margin; 414 if (abs(cs_nsec - wd_nsec) > md) { 415 pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n", 416 smp_processor_id(), cs->name); 417 pr_warn(" '%s' wd_nsec: %lld wd_now: %llx wd_last: %llx mask: %llx\n", 418 watchdog->name, wd_nsec, wdnow, wdlast, watchdog->mask); 419 pr_warn(" '%s' cs_nsec: %lld cs_now: %llx cs_last: %llx mask: %llx\n", 420 cs->name, cs_nsec, csnow, cslast, cs->mask); 421 if (curr_clocksource == cs) 422 pr_warn(" '%s' is current clocksource.\n", cs->name); 423 else if (curr_clocksource) 424 pr_warn(" '%s' (not '%s') is current clocksource.\n", curr_clocksource->name, cs->name); 425 else 426 pr_warn(" No current clocksource.\n"); 427 __clocksource_unstable(cs); 428 continue; 429 } 430 431 if (cs == curr_clocksource && cs->tick_stable) 432 cs->tick_stable(cs); 433 434 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) && 435 (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) && 436 (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) { 437 /* Mark it valid for high-res. */ 438 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES; 439 440 /* 441 * clocksource_done_booting() will sort it if 442 * finished_booting is not set yet. 443 */ 444 if (!finished_booting) 445 continue; 446 447 /* 448 * If this is not the current clocksource let 449 * the watchdog thread reselect it. Due to the 450 * change to high res this clocksource might 451 * be preferred now. If it is the current 452 * clocksource let the tick code know about 453 * that change. 454 */ 455 if (cs != curr_clocksource) { 456 cs->flags |= CLOCK_SOURCE_RESELECT; 457 schedule_work(&watchdog_work); 458 } else { 459 tick_clock_notify(); 460 } 461 } 462 } 463 464 /* 465 * We only clear the watchdog_reset_pending, when we did a 466 * full cycle through all clocksources. 467 */ 468 if (reset_pending) 469 atomic_dec(&watchdog_reset_pending); 470 471 /* 472 * Cycle through CPUs to check if the CPUs stay synchronized 473 * to each other. 474 */ 475 next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask); 476 if (next_cpu >= nr_cpu_ids) 477 next_cpu = cpumask_first(cpu_online_mask); 478 479 /* 480 * Arm timer if not already pending: could race with concurrent 481 * pair clocksource_stop_watchdog() clocksource_start_watchdog(). 482 */ 483 if (!timer_pending(&watchdog_timer)) { 484 watchdog_timer.expires += WATCHDOG_INTERVAL; 485 add_timer_on(&watchdog_timer, next_cpu); 486 } 487 out: 488 spin_unlock(&watchdog_lock); 489 } 490 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org