Re: [RFC PATCH] clocksource: skip check while watchdog hung up or unstable

[kernel test robot <lkp@intel.com>]

[-- Attachment #1: Type: text/plain, Size: 7695 bytes --]

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-while-watchdog-hung-up-or-unstable/20210811-175707
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/085c7bc9e8da6deabad14b2093bd8409cb77b3be
        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@intel.com>

All warnings (new ones prefixed by >>):

>> kernel/time/clocksource.c:403:41: warning: more '%' conversions than data arguments [-Wformat-insufficient-args]
                           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) {
 > 403				pr_warn("timekeeping watchdog on CPU%d seems hung up or unstable:");
   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(a)lists.01.org

[-- Attachment #2: config.gz --]
[-- Type: application/gzip, Size: 36329 bytes --]