* [paulmck-rcu:context-tracking.2022.05.19a 20/21] kernel/context_tracking.c:500:4: error: call to undeclared function 'ct_kernel_exit'; ISO C99 and later do not support implicit function declarations
@ 2022-05-19 21:54 kernel test robot
0 siblings, 0 replies; only message in thread
From: kernel test robot @ 2022-05-19 21:54 UTC (permalink / raw)
To: Frederic Weisbecker; +Cc: llvm, kbuild-all, linux-kernel
tree: https://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git context-tracking.2022.05.19a
head: 6153dca9e37b244684bf472728f5c3688c5b0aca
commit: 02be5e537043004b7c133565ae473daf19a99e5d [20/21] rcu/context_tracking: Merge dynticks counter and context tracking states
config: x86_64-randconfig-a001 (https://download.01.org/0day-ci/archive/20220520/202205200501.17EQ97Fa-lkp@intel.com/config)
compiler: clang version 15.0.0 (https://github.com/llvm/llvm-project e00cbbec06c08dc616a0d52a20f678b8fbd4e304)
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://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git/commit/?id=02be5e537043004b7c133565ae473daf19a99e5d
git remote add paulmck-rcu https://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git
git fetch --no-tags paulmck-rcu context-tracking.2022.05.19a
git checkout 02be5e537043004b7c133565ae473daf19a99e5d
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=x86_64 SHELL=/bin/bash
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/context_tracking.c:500:4: error: call to undeclared function 'ct_kernel_exit'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
ct_kernel_exit(true, RCU_DYNTICKS_IDX + state);
^
kernel/context_tracking.c:500:4: note: did you mean 'is_kernel_text'?
include/linux/kallsyms.h:27:19: note: 'is_kernel_text' declared here
static inline int is_kernel_text(unsigned long addr)
^
>> kernel/context_tracking.c:607:4: error: call to undeclared function 'ct_kernel_enter'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
ct_kernel_enter(true, RCU_DYNTICKS_IDX - state);
^
2 errors generated.
vim +/ct_kernel_exit +500 kernel/context_tracking.c
451
452 /**
453 * __ct_user_enter - Inform the context tracking that the CPU is going
454 * to enter user or guest space mode.
455 *
456 * This function must be called right before we switch from the kernel
457 * to user or guest space, when it's guaranteed the remaining kernel
458 * instructions to execute won't use any RCU read side critical section
459 * because this function sets RCU in extended quiescent state.
460 */
461 void noinstr __ct_user_enter(enum ctx_state state)
462 {
463 struct context_tracking *ct = this_cpu_ptr(&context_tracking);
464 lockdep_assert_irqs_disabled();
465
466 /* Kernel threads aren't supposed to go to userspace */
467 WARN_ON_ONCE(!current->mm);
468
469 if (!context_tracking_recursion_enter())
470 return;
471
472 if (__ct_state() != state) {
473 if (ct->active) {
474 /*
475 * At this stage, only low level arch entry code remains and
476 * then we'll run in userspace. We can assume there won't be
477 * any RCU read-side critical section until the next call to
478 * user_exit() or ct_irq_enter(). Let's remove RCU's dependency
479 * on the tick.
480 */
481 if (state == CONTEXT_USER) {
482 instrumentation_begin();
483 trace_user_enter(0);
484 vtime_user_enter(current);
485 instrumentation_end();
486 }
487 /*
488 * Other than generic entry implementation, we may be past the last
489 * rescheduling opportunity in the entry code. Trigger a self IPI
490 * that will fire and reschedule once we resume in user/guest mode.
491 */
492 rcu_irq_work_resched();
493
494 /*
495 * Enter RCU idle mode right before resuming userspace. No use of RCU
496 * is permitted between this call and rcu_eqs_exit(). This way the
497 * CPU doesn't need to maintain the tick for RCU maintenance purposes
498 * when the CPU runs in userspace.
499 */
> 500 ct_kernel_exit(true, RCU_DYNTICKS_IDX + state);
501
502 /*
503 * Special case if we only track user <-> kernel transitions for tickless
504 * cputime accounting but we don't support RCU extended quiescent state.
505 * In this we case we don't care about any concurrency/ordering.
506 */
507 if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE))
508 atomic_set(&ct->state, state);
509 } else {
510 /*
511 * Even if context tracking is disabled on this CPU, because it's outside
512 * the full dynticks mask for example, we still have to keep track of the
513 * context transitions and states to prevent inconsistency on those of
514 * other CPUs.
515 * If a task triggers an exception in userspace, sleep on the exception
516 * handler and then migrate to another CPU, that new CPU must know where
517 * the exception returns by the time we call exception_exit().
518 * This information can only be provided by the previous CPU when it called
519 * exception_enter().
520 * OTOH we can spare the calls to vtime and RCU when context_tracking.active
521 * is false because we know that CPU is not tickless.
522 */
523 if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE)) {
524 /* Tracking for vtime only, no concurrent RCU EQS accounting */
525 atomic_set(&ct->state, state);
526 } else {
527 /*
528 * Tracking for vtime and RCU EQS. Make sure we don't race
529 * with NMIs. OTOH we don't care about ordering here since
530 * RCU only requires RCU_DYNTICKS_IDX increments to be fully
531 * ordered.
532 */
533 atomic_add(state, &ct->state);
534 }
535 }
536 }
537 context_tracking_recursion_exit();
538 }
539 EXPORT_SYMBOL_GPL(__ct_user_enter);
540
541 /*
542 * FIXME: This function should be noinstr but the below local_irq_restore() is
543 * unsafe because it involves illegal RCU uses through tracing and lockdep. This
544 * must be fixed first.
545 */
546 void ct_user_enter(enum ctx_state state)
547 {
548 unsigned long flags;
549
550 /*
551 * Some contexts may involve an exception occuring in an irq,
552 * leading to that nesting:
553 * ct_irq_enter() rcu_eqs_exit(true) rcu_eqs_enter(true) ct_irq_exit()
554 * This would mess up the dyntick_nesting count though. And rcu_irq_*()
555 * helpers are enough to protect RCU uses inside the exception. So
556 * just return immediately if we detect we are in an IRQ.
557 */
558 if (in_interrupt())
559 return;
560
561 local_irq_save(flags);
562 __ct_user_enter(state);
563 local_irq_restore(flags);
564 }
565 NOKPROBE_SYMBOL(ct_user_enter);
566 EXPORT_SYMBOL_GPL(ct_user_enter);
567
568 /**
569 * user_enter_callable() - Unfortunate ASM callable version of user_enter() for
570 * archs that didn't manage to check the context tracking
571 * static key from low level code.
572 *
573 * FIXME: This function should be noinstr but it unsafely calls local_irq_restore(),
574 * involving illegal RCU uses through tracing and lockdep. This must be fixed first.
575 */
576 void user_enter_callable(void)
577 {
578 user_enter();
579 }
580 NOKPROBE_SYMBOL(user_enter_callable);
581
582 /**
583 * __ct_user_exit - Inform the context tracking that the CPU is
584 * exiting user or guest mode and entering the kernel.
585 *
586 * This function must be called after we entered the kernel from user or
587 * guest space before any use of RCU read side critical section. This
588 * potentially include any high level kernel code like syscalls, exceptions,
589 * signal handling, etc...
590 *
591 * This call supports re-entrancy. This way it can be called from any exception
592 * handler without needing to know if we came from userspace or not.
593 */
594 void noinstr __ct_user_exit(enum ctx_state state)
595 {
596 struct context_tracking *ct = this_cpu_ptr(&context_tracking);
597
598 if (!context_tracking_recursion_enter())
599 return;
600
601 if (__ct_state() == state) {
602 if (ct->active) {
603 /*
604 * Exit RCU idle mode while entering the kernel because it can
605 * run a RCU read side critical section anytime.
606 */
> 607 ct_kernel_enter(true, RCU_DYNTICKS_IDX - state);
608 if (state == CONTEXT_USER) {
609 instrumentation_begin();
610 vtime_user_exit(current);
611 trace_user_exit(0);
612 instrumentation_end();
613 }
614
615 /*
616 * Special case if we only track user <-> kernel transitions for tickless
617 * cputime accounting but we don't support RCU extended quiescent state.
618 * In this we case we don't care about any concurrency/ordering.
619 */
620 if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE))
621 atomic_set(&ct->state, CONTEXT_KERNEL);
622
623 } else {
624 if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE)) {
625 /* Tracking for vtime only, no concurrent RCU EQS accounting */
626 atomic_set(&ct->state, CONTEXT_KERNEL);
627 } else {
628 /*
629 * Tracking for vtime and RCU EQS. Make sure we don't race
630 * with NMIs. OTOH we don't care about ordering here since
631 * RCU only requires RCU_DYNTICKS_IDX increments to be fully
632 * ordered.
633 */
634 atomic_sub(state, &ct->state);
635 }
636 }
637 }
638 context_tracking_recursion_exit();
639 }
640 EXPORT_SYMBOL_GPL(__ct_user_exit);
641
--
0-DAY CI Kernel Test Service
https://01.org/lkp
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-05-19 21:54 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2022-05-19 21:54 [paulmck-rcu:context-tracking.2022.05.19a 20/21] kernel/context_tracking.c:500:4: error: call to undeclared function 'ct_kernel_exit'; ISO C99 and later do not support implicit function declarations kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.