Hi Stephane,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on tip/perf/core]
[also build test ERROR on next-20210909]
[cannot apply to tip/sched/core tip/x86/core v5.14]
[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/Stephane-Eranian/perf-x86-amd-Add-AMD-Fam19h-Branch-Sampling-support/20210909-160050
base:   https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git 4034fb207e302cc0b1f304084d379640c1fb1436
config: um-x86_64_defconfig (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
        # https://github.com/0day-ci/linux/commit/35333fae36d4dee3e2225674fca8d745364482fa
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Stephane-Eranian/perf-x86-amd-Add-AMD-Fam19h-Branch-Sampling-support/20210909-160050
        git checkout 35333fae36d4dee3e2225674fca8d745364482fa
        # save the attached .config to linux build tree
        make W=1 ARCH=um SUBARCH=x86_64

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All errors (new ones prefixed by >>):

   kernel/sched/idle.c: In function 'cpuidle_idle_call':
>> kernel/sched/idle.c:182:3: error: implicit declaration of function 'perf_lopwr_cb' [-Werror=implicit-function-declaration]
     182 |   perf_lopwr_cb(false);
         |   ^~~~~~~~~~~~~
   cc1: some warnings being treated as errors


vim +/perf_lopwr_cb +182 kernel/sched/idle.c

   160	
   161	/**
   162	 * cpuidle_idle_call - the main idle function
   163	 *
   164	 * NOTE: no locks or semaphores should be used here
   165	 *
   166	 * On architectures that support TIF_POLLING_NRFLAG, is called with polling
   167	 * set, and it returns with polling set.  If it ever stops polling, it
   168	 * must clear the polling bit.
   169	 */
   170	static void cpuidle_idle_call(void)
   171	{
   172		struct cpuidle_device *dev = cpuidle_get_device();
   173		struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
   174		int next_state, entered_state;
   175	
   176		/*
   177		 * Check if the idle task must be rescheduled. If it is the
   178		 * case, exit the function after re-enabling the local irq.
   179		 */
   180		if (need_resched()) {
   181			local_irq_enable();
 > 182			perf_lopwr_cb(false);
   183			return;
   184		}
   185	
   186		/*
   187		 * The RCU framework needs to be told that we are entering an idle
   188		 * section, so no more rcu read side critical sections and one more
   189		 * step to the grace period
   190		 */
   191	
   192		if (cpuidle_not_available(drv, dev)) {
   193			tick_nohz_idle_stop_tick();
   194	
   195			if (!cpu_idle_force_poll)
   196				perf_lopwr_cb(true);
   197	
   198			default_idle_call();
   199	
   200			if (!cpu_idle_force_poll)
   201				perf_lopwr_cb(false);
   202	
   203			goto exit_idle;
   204		}
   205	
   206		/*
   207		 * Suspend-to-idle ("s2idle") is a system state in which all user space
   208		 * has been frozen, all I/O devices have been suspended and the only
   209		 * activity happens here and in interrupts (if any). In that case bypass
   210		 * the cpuidle governor and go straight for the deepest idle state
   211		 * available.  Possibly also suspend the local tick and the entire
   212		 * timekeeping to prevent timer interrupts from kicking us out of idle
   213		 * until a proper wakeup interrupt happens.
   214		 */
   215	
   216		if (idle_should_enter_s2idle() || dev->forced_idle_latency_limit_ns) {
   217			u64 max_latency_ns;
   218	
   219			if (idle_should_enter_s2idle()) {
   220	
   221				entered_state = call_cpuidle_s2idle(drv, dev);
   222				if (entered_state > 0)
   223					goto exit_idle;
   224	
   225				max_latency_ns = U64_MAX;
   226			} else {
   227				max_latency_ns = dev->forced_idle_latency_limit_ns;
   228			}
   229	
   230			tick_nohz_idle_stop_tick();
   231	
   232			next_state = cpuidle_find_deepest_state(drv, dev, max_latency_ns);
   233			call_cpuidle(drv, dev, next_state);
   234		} else {
   235			bool stop_tick = true;
   236	
   237			/*
   238			 * Ask the cpuidle framework to choose a convenient idle state.
   239			 */
   240			next_state = cpuidle_select(drv, dev, &stop_tick);
   241	
   242			if (stop_tick || tick_nohz_tick_stopped())
   243				tick_nohz_idle_stop_tick();
   244			else
   245				tick_nohz_idle_retain_tick();
   246	
   247			entered_state = call_cpuidle(drv, dev, next_state);
   248			/*
   249			 * Give the governor an opportunity to reflect on the outcome
   250			 */
   251			cpuidle_reflect(dev, entered_state);
   252		}
   253	
   254	exit_idle:
   255		__current_set_polling();
   256	
   257		/*
   258		 * It is up to the idle functions to reenable local interrupts
   259		 */
   260		if (WARN_ON_ONCE(irqs_disabled())) {
   261			local_irq_enable();
   262			perf_lopwr_cb(false);
   263		}
   264	}
   265	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org