Messages in this thread | | | Date | Wed, 20 Sep 2017 00:56:02 +0800 | From | kbuild test robot <> | Subject | [rcu:dev.2017.09.17a 32/32] kernel/cpu.c:721:6: error: 'cpuhp_state_down_key' undeclared |
| |
tree: https://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git dev.2017.09.17a head: 0cb8379979ad024d4024bd552bb0287d46a19b0c commit: 0cb8379979ad024d4024bd552bb0287d46a19b0c [32/32] EXP smp/hotplug,lockdep: Annotate cpuhp_state config: i386-randconfig-x079-201738 (attached as .config) compiler: gcc-6 (Debian 6.2.0-3) 6.2.0 20160901 reproduce: git checkout 0cb8379979ad024d4024bd552bb0287d46a19b0c # save the attached .config to linux build tree make ARCH=i386
All errors (new ones prefixed by >>):
In file included from include/linux/spinlock_types.h:18:0, from include/linux/spinlock.h:81, from include/linux/wait.h:8, from include/linux/wait_bit.h:7, from include/linux/fs.h:5, from include/linux/proc_fs.h:8, from kernel/cpu.c:6: kernel/cpu.c: In function '_cpu_down': >> kernel/cpu.c:721:6: error: 'cpuhp_state_down_key' undeclared (first use in this function) &cpuhp_state_down_key, 0); ^ include/linux/lockdep.h:505:29: note: in definition of macro 'lockdep_init_map' do { (void)(name); (void)(key); } while (0) ^~~ kernel/cpu.c:721:6: note: each undeclared identifier is reported only once for each function it appears in &cpuhp_state_down_key, 0); ^ include/linux/lockdep.h:505:29: note: in definition of macro 'lockdep_init_map' do { (void)(name); (void)(key); } while (0) ^~~ kernel/cpu.c: In function '_cpu_up': >> kernel/cpu.c:837:6: error: 'cpuhp_state_up_key' undeclared (first use in this function) &cpuhp_state_up_key, 0); ^ include/linux/lockdep.h:505:29: note: in definition of macro 'lockdep_init_map' do { (void)(name); (void)(key); } while (0) ^~~
vim +/cpuhp_state_down_key +721 kernel/cpu.c
703 704 /* Requires cpu_add_remove_lock to be held */ 705 static int __ref _cpu_down(unsigned int cpu, int tasks_frozen, 706 enum cpuhp_state target) 707 { 708 struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu); 709 int prev_state, ret = 0; 710 711 if (num_online_cpus() == 1) 712 return -EBUSY; 713 714 if (!cpu_present(cpu)) 715 return -EINVAL; 716 717 cpus_write_lock(); 718 719 lockdep_reinit_st_done(); 720 lockdep_init_map(&cpuhp_state_lock_map, "cpuhp_state-down", > 721 &cpuhp_state_down_key, 0); 722 723 cpuhp_tasks_frozen = tasks_frozen; 724 725 prev_state = st->state; 726 st->target = target; 727 /* 728 * If the current CPU state is in the range of the AP hotplug thread, 729 * then we need to kick the thread. 730 */ 731 if (st->state > CPUHP_TEARDOWN_CPU) { 732 ret = cpuhp_kick_ap_work(cpu); 733 /* 734 * The AP side has done the error rollback already. Just 735 * return the error code.. 736 */ 737 if (ret) 738 goto out; 739 740 /* 741 * We might have stopped still in the range of the AP hotplug 742 * thread. Nothing to do anymore. 743 */ 744 if (st->state > CPUHP_TEARDOWN_CPU) 745 goto out; 746 } 747 /* 748 * The AP brought itself down to CPUHP_TEARDOWN_CPU. So we need 749 * to do the further cleanups. 750 */ 751 ret = cpuhp_down_callbacks(cpu, st, target); 752 if (ret && st->state > CPUHP_TEARDOWN_CPU && st->state < prev_state) { 753 st->target = prev_state; 754 st->rollback = true; 755 cpuhp_kick_ap_work(cpu); 756 } 757 758 out: 759 cpus_write_unlock(); 760 return ret; 761 } 762 763 static int do_cpu_down(unsigned int cpu, enum cpuhp_state target) 764 { 765 int err; 766 767 cpu_maps_update_begin(); 768 769 if (cpu_hotplug_disabled) { 770 err = -EBUSY; 771 goto out; 772 } 773 774 err = _cpu_down(cpu, 0, target); 775 776 out: 777 cpu_maps_update_done(); 778 return err; 779 } 780 int cpu_down(unsigned int cpu) 781 { 782 return do_cpu_down(cpu, CPUHP_OFFLINE); 783 } 784 EXPORT_SYMBOL(cpu_down); 785 786 #else 787 #define takedown_cpu NULL 788 #endif /*CONFIG_HOTPLUG_CPU*/ 789 790 /** 791 * notify_cpu_starting(cpu) - Invoke the callbacks on the starting CPU 792 * @cpu: cpu that just started 793 * 794 * It must be called by the arch code on the new cpu, before the new cpu 795 * enables interrupts and before the "boot" cpu returns from __cpu_up(). 796 */ 797 void notify_cpu_starting(unsigned int cpu) 798 { 799 struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu); 800 enum cpuhp_state target = min((int)st->target, CPUHP_AP_ONLINE); 801 802 rcu_cpu_starting(cpu); /* Enables RCU usage on this CPU. */ 803 while (st->state < target) { 804 st->state++; 805 cpuhp_invoke_callback(cpu, st->state, true, NULL); 806 } 807 } 808 809 /* 810 * Called from the idle task. Wake up the controlling task which brings the 811 * stopper and the hotplug thread of the upcoming CPU up and then delegates 812 * the rest of the online bringup to the hotplug thread. 813 */ 814 void cpuhp_online_idle(enum cpuhp_state state) 815 { 816 struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); 817 818 /* Happens for the boot cpu */ 819 if (state != CPUHP_AP_ONLINE_IDLE) 820 return; 821 822 st->state = CPUHP_AP_ONLINE_IDLE; 823 complete(&st->done); 824 } 825 826 /* Requires cpu_add_remove_lock to be held */ 827 static int _cpu_up(unsigned int cpu, int tasks_frozen, enum cpuhp_state target) 828 { 829 struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu); 830 struct task_struct *idle; 831 int ret = 0; 832 833 cpus_write_lock(); 834 835 lockdep_reinit_st_done(); 836 lockdep_init_map(&cpuhp_state_lock_map, "cpuhp_state-up", > 837 &cpuhp_state_up_key, 0); 838 839 if (!cpu_present(cpu)) { 840 ret = -EINVAL; 841 goto out; 842 } 843 844 /* 845 * The caller of do_cpu_up might have raced with another 846 * caller. Ignore it for now. 847 */ 848 if (st->state >= target) 849 goto out; 850 851 if (st->state == CPUHP_OFFLINE) { 852 /* Let it fail before we try to bring the cpu up */ 853 idle = idle_thread_get(cpu); 854 if (IS_ERR(idle)) { 855 ret = PTR_ERR(idle); 856 goto out; 857 } 858 } 859 860 cpuhp_tasks_frozen = tasks_frozen; 861 862 st->target = target; 863 /* 864 * If the current CPU state is in the range of the AP hotplug thread, 865 * then we need to kick the thread once more. 866 */ 867 if (st->state > CPUHP_BRINGUP_CPU) { 868 ret = cpuhp_kick_ap_work(cpu); 869 /* 870 * The AP side has done the error rollback already. Just 871 * return the error code.. 872 */ 873 if (ret) 874 goto out; 875 } 876 877 /* 878 * Try to reach the target state. We max out on the BP at 879 * CPUHP_BRINGUP_CPU. After that the AP hotplug thread is 880 * responsible for bringing it up to the target state. 881 */ 882 target = min((int)target, CPUHP_BRINGUP_CPU); 883 ret = cpuhp_up_callbacks(cpu, st, target); 884 out: 885 cpus_write_unlock(); 886 return ret; 887 } 888
--- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation [unhandled content-type:application/gzip] | |