• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 #ifndef _ASM_X86_SMP_H
2 #define _ASM_X86_SMP_H
3 #ifndef __ASSEMBLY__
4 #include <linux/cpumask.h>
5 #include <linux/init.h>
6 #include <asm/percpu.h>
7 
8 /*
9  * We need the APIC definitions automatically as part of 'smp.h'
10  */
11 #ifdef CONFIG_X86_LOCAL_APIC
12 # include <asm/mpspec.h>
13 # include <asm/apic.h>
14 # ifdef CONFIG_X86_IO_APIC
15 #  include <asm/io_apic.h>
16 # endif
17 #endif
18 #include <asm/thread_info.h>
19 #include <asm/cpumask.h>
20 #include <asm/cpufeature.h>
21 
22 extern int smp_num_siblings;
23 extern unsigned int num_processors;
24 
cpu_has_ht_siblings(void)25 static inline bool cpu_has_ht_siblings(void)
26 {
27 	bool has_siblings = false;
28 #ifdef CONFIG_SMP
29 	has_siblings = cpu_has_ht && smp_num_siblings > 1;
30 #endif
31 	return has_siblings;
32 }
33 
34 DECLARE_PER_CPU(cpumask_var_t, cpu_sibling_map);
35 DECLARE_PER_CPU(cpumask_var_t, cpu_core_map);
36 /* cpus sharing the last level cache: */
37 DECLARE_PER_CPU(cpumask_var_t, cpu_llc_shared_map);
38 DECLARE_PER_CPU(u16, cpu_llc_id);
39 DECLARE_PER_CPU(int, cpu_number);
40 
cpu_sibling_mask(int cpu)41 static inline struct cpumask *cpu_sibling_mask(int cpu)
42 {
43 	return per_cpu(cpu_sibling_map, cpu);
44 }
45 
cpu_core_mask(int cpu)46 static inline struct cpumask *cpu_core_mask(int cpu)
47 {
48 	return per_cpu(cpu_core_map, cpu);
49 }
50 
cpu_llc_shared_mask(int cpu)51 static inline struct cpumask *cpu_llc_shared_mask(int cpu)
52 {
53 	return per_cpu(cpu_llc_shared_map, cpu);
54 }
55 
56 DECLARE_EARLY_PER_CPU(u16, x86_cpu_to_apicid);
57 DECLARE_EARLY_PER_CPU(u16, x86_bios_cpu_apicid);
58 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86_32)
59 DECLARE_EARLY_PER_CPU(int, x86_cpu_to_logical_apicid);
60 #endif
61 
62 /* Static state in head.S used to set up a CPU */
63 extern unsigned long stack_start; /* Initial stack pointer address */
64 
65 struct smp_ops {
66 	void (*smp_prepare_boot_cpu)(void);
67 	void (*smp_prepare_cpus)(unsigned max_cpus);
68 	void (*smp_cpus_done)(unsigned max_cpus);
69 
70 	void (*stop_other_cpus)(int wait);
71 	void (*smp_send_reschedule)(int cpu);
72 
73 	int (*cpu_up)(unsigned cpu);
74 	int (*cpu_disable)(void);
75 	void (*cpu_die)(unsigned int cpu);
76 	void (*play_dead)(void);
77 
78 	void (*send_call_func_ipi)(const struct cpumask *mask);
79 	void (*send_call_func_single_ipi)(int cpu);
80 };
81 
82 /* Globals due to paravirt */
83 extern void set_cpu_sibling_map(int cpu);
84 
85 #ifdef CONFIG_SMP
86 #ifndef CONFIG_PARAVIRT
87 #define startup_ipi_hook(phys_apicid, start_eip, start_esp) do { } while (0)
88 #endif
89 extern struct smp_ops smp_ops;
90 
smp_send_stop(void)91 static inline void smp_send_stop(void)
92 {
93 	smp_ops.stop_other_cpus(0);
94 }
95 
stop_other_cpus(void)96 static inline void stop_other_cpus(void)
97 {
98 	smp_ops.stop_other_cpus(1);
99 }
100 
smp_prepare_boot_cpu(void)101 static inline void smp_prepare_boot_cpu(void)
102 {
103 	smp_ops.smp_prepare_boot_cpu();
104 }
105 
smp_prepare_cpus(unsigned int max_cpus)106 static inline void smp_prepare_cpus(unsigned int max_cpus)
107 {
108 	smp_ops.smp_prepare_cpus(max_cpus);
109 }
110 
smp_cpus_done(unsigned int max_cpus)111 static inline void smp_cpus_done(unsigned int max_cpus)
112 {
113 	smp_ops.smp_cpus_done(max_cpus);
114 }
115 
__cpu_up(unsigned int cpu)116 static inline int __cpu_up(unsigned int cpu)
117 {
118 	return smp_ops.cpu_up(cpu);
119 }
120 
__cpu_disable(void)121 static inline int __cpu_disable(void)
122 {
123 	return smp_ops.cpu_disable();
124 }
125 
__cpu_die(unsigned int cpu)126 static inline void __cpu_die(unsigned int cpu)
127 {
128 	smp_ops.cpu_die(cpu);
129 }
130 
play_dead(void)131 static inline void play_dead(void)
132 {
133 	smp_ops.play_dead();
134 }
135 
smp_send_reschedule(int cpu)136 static inline void smp_send_reschedule(int cpu)
137 {
138 	smp_ops.smp_send_reschedule(cpu);
139 }
140 
arch_send_call_function_single_ipi(int cpu)141 static inline void arch_send_call_function_single_ipi(int cpu)
142 {
143 	smp_ops.send_call_func_single_ipi(cpu);
144 }
145 
arch_send_call_function_ipi_mask(const struct cpumask * mask)146 static inline void arch_send_call_function_ipi_mask(const struct cpumask *mask)
147 {
148 	smp_ops.send_call_func_ipi(mask);
149 }
150 
151 void cpu_disable_common(void);
152 void native_smp_prepare_boot_cpu(void);
153 void native_smp_prepare_cpus(unsigned int max_cpus);
154 void native_smp_cpus_done(unsigned int max_cpus);
155 int native_cpu_up(unsigned int cpunum);
156 int native_cpu_disable(void);
157 void native_cpu_die(unsigned int cpu);
158 void native_play_dead(void);
159 void play_dead_common(void);
160 void wbinvd_on_cpu(int cpu);
161 int wbinvd_on_all_cpus(void);
162 
163 void native_send_call_func_ipi(const struct cpumask *mask);
164 void native_send_call_func_single_ipi(int cpu);
165 
166 void smp_store_cpu_info(int id);
167 #define cpu_physical_id(cpu)	per_cpu(x86_cpu_to_apicid, cpu)
168 
169 /* We don't mark CPUs online until __cpu_up(), so we need another measure */
num_booting_cpus(void)170 static inline int num_booting_cpus(void)
171 {
172 	return cpumask_weight(cpu_callout_mask);
173 }
174 #else /* !CONFIG_SMP */
175 #define wbinvd_on_cpu(cpu)     wbinvd()
wbinvd_on_all_cpus(void)176 static inline int wbinvd_on_all_cpus(void)
177 {
178 	wbinvd();
179 	return 0;
180 }
181 #endif /* CONFIG_SMP */
182 
183 extern unsigned disabled_cpus __cpuinitdata;
184 
185 #ifdef CONFIG_X86_32_SMP
186 /*
187  * This function is needed by all SMP systems. It must _always_ be valid
188  * from the initial startup. We map APIC_BASE very early in page_setup(),
189  * so this is correct in the x86 case.
190  */
191 #define raw_smp_processor_id() (percpu_read(cpu_number))
192 extern int safe_smp_processor_id(void);
193 
194 #elif defined(CONFIG_X86_64_SMP)
195 #define raw_smp_processor_id() (percpu_read(cpu_number))
196 
197 #define stack_smp_processor_id()					\
198 ({								\
199 	struct thread_info *ti;						\
200 	__asm__("andq %%rsp,%0; ":"=r" (ti) : "0" (CURRENT_MASK));	\
201 	ti->cpu;							\
202 })
203 #define safe_smp_processor_id()		smp_processor_id()
204 
205 #endif
206 
207 #ifdef CONFIG_X86_LOCAL_APIC
208 
209 #ifndef CONFIG_X86_64
logical_smp_processor_id(void)210 static inline int logical_smp_processor_id(void)
211 {
212 	/* we don't want to mark this access volatile - bad code generation */
213 	return GET_APIC_LOGICAL_ID(apic_read(APIC_LDR));
214 }
215 
216 #endif
217 
218 extern int hard_smp_processor_id(void);
219 
220 #else /* CONFIG_X86_LOCAL_APIC */
221 
222 # ifndef CONFIG_SMP
223 #  define hard_smp_processor_id()	0
224 # endif
225 
226 #endif /* CONFIG_X86_LOCAL_APIC */
227 
228 #ifdef CONFIG_DEBUG_NMI_SELFTEST
229 extern void nmi_selftest(void);
230 #else
231 #define nmi_selftest() do { } while (0)
232 #endif
233 
234 #endif /* __ASSEMBLY__ */
235 #endif /* _ASM_X86_SMP_H */
236