1
2
3#ifdef CONFIG_XEN_BALLOON_MEMORY_HOTPLUG
4#include <linux/memblock.h>
5#endif
6#include <linux/cpu.h>
7#include <linux/kexec.h>
8#include <linux/slab.h>
9
10#include <xen/xen.h>
11#include <xen/features.h>
12#include <xen/page.h>
13
14#include <asm/xen/hypercall.h>
15#include <asm/xen/hypervisor.h>
16#include <asm/cpu.h>
17#include <asm/e820/api.h>
18
19#include "xen-ops.h"
20#include "smp.h"
21#include "pmu.h"
22
23EXPORT_SYMBOL_GPL(hypercall_page);
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu);
42
43
44
45
46
47
48DEFINE_PER_CPU(struct vcpu_info, xen_vcpu_info);
49
50
51DEFINE_PER_CPU(uint32_t, xen_vcpu_id);
52EXPORT_PER_CPU_SYMBOL(xen_vcpu_id);
53
54enum xen_domain_type xen_domain_type = XEN_NATIVE;
55EXPORT_SYMBOL_GPL(xen_domain_type);
56
57unsigned long *machine_to_phys_mapping = (void *)MACH2PHYS_VIRT_START;
58EXPORT_SYMBOL(machine_to_phys_mapping);
59unsigned long machine_to_phys_nr;
60EXPORT_SYMBOL(machine_to_phys_nr);
61
62struct start_info *xen_start_info;
63EXPORT_SYMBOL_GPL(xen_start_info);
64
65struct shared_info xen_dummy_shared_info;
66
67__read_mostly int xen_have_vector_callback;
68EXPORT_SYMBOL_GPL(xen_have_vector_callback);
69
70
71
72
73
74uint32_t xen_start_flags __attribute__((section(".data"))) = 0;
75EXPORT_SYMBOL(xen_start_flags);
76
77
78
79
80
81struct shared_info *HYPERVISOR_shared_info = &xen_dummy_shared_info;
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96int xen_have_vcpu_info_placement = 1;
97
98static int xen_cpu_up_online(unsigned int cpu)
99{
100 xen_init_lock_cpu(cpu);
101 return 0;
102}
103
104int xen_cpuhp_setup(int (*cpu_up_prepare_cb)(unsigned int),
105 int (*cpu_dead_cb)(unsigned int))
106{
107 int rc;
108
109 rc = cpuhp_setup_state_nocalls(CPUHP_XEN_PREPARE,
110 "x86/xen/guest:prepare",
111 cpu_up_prepare_cb, cpu_dead_cb);
112 if (rc >= 0) {
113 rc = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
114 "x86/xen/guest:online",
115 xen_cpu_up_online, NULL);
116 if (rc < 0)
117 cpuhp_remove_state_nocalls(CPUHP_XEN_PREPARE);
118 }
119
120 return rc >= 0 ? 0 : rc;
121}
122
123static int xen_vcpu_setup_restore(int cpu)
124{
125 int rc = 0;
126
127
128 xen_vcpu_info_reset(cpu);
129
130
131
132
133
134 if (xen_pv_domain() ||
135 (xen_hvm_domain() && cpu_online(cpu))) {
136 rc = xen_vcpu_setup(cpu);
137 }
138
139 return rc;
140}
141
142
143
144
145
146
147void xen_vcpu_restore(void)
148{
149 int cpu, rc;
150
151 for_each_possible_cpu(cpu) {
152 bool other_cpu = (cpu != smp_processor_id());
153 bool is_up;
154
155 if (xen_vcpu_nr(cpu) == XEN_VCPU_ID_INVALID)
156 continue;
157
158
159 is_up = HYPERVISOR_vcpu_op(VCPUOP_is_up,
160 xen_vcpu_nr(cpu), NULL) > 0;
161
162 if (other_cpu && is_up &&
163 HYPERVISOR_vcpu_op(VCPUOP_down, xen_vcpu_nr(cpu), NULL))
164 BUG();
165
166 if (xen_pv_domain() || xen_feature(XENFEAT_hvm_safe_pvclock))
167 xen_setup_runstate_info(cpu);
168
169 rc = xen_vcpu_setup_restore(cpu);
170 if (rc)
171 pr_emerg_once("vcpu restore failed for cpu=%d err=%d. "
172 "System will hang.\n", cpu, rc);
173
174
175
176
177
178
179
180
181
182 if (other_cpu && is_up && (rc == 0) &&
183 HYPERVISOR_vcpu_op(VCPUOP_up, xen_vcpu_nr(cpu), NULL))
184 BUG();
185 }
186}
187
188void xen_vcpu_info_reset(int cpu)
189{
190 if (xen_vcpu_nr(cpu) < MAX_VIRT_CPUS) {
191 per_cpu(xen_vcpu, cpu) =
192 &HYPERVISOR_shared_info->vcpu_info[xen_vcpu_nr(cpu)];
193 } else {
194
195 per_cpu(xen_vcpu, cpu) = NULL;
196 }
197}
198
199int xen_vcpu_setup(int cpu)
200{
201 struct vcpu_register_vcpu_info info;
202 int err;
203 struct vcpu_info *vcpup;
204
205 BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
206
207
208
209
210
211
212
213
214
215
216
217
218 if (xen_hvm_domain()) {
219 if (per_cpu(xen_vcpu, cpu) == &per_cpu(xen_vcpu_info, cpu))
220 return 0;
221 }
222
223 if (xen_have_vcpu_info_placement) {
224 vcpup = &per_cpu(xen_vcpu_info, cpu);
225 info.mfn = arbitrary_virt_to_mfn(vcpup);
226 info.offset = offset_in_page(vcpup);
227
228
229
230
231
232
233
234
235
236
237
238 err = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_info,
239 xen_vcpu_nr(cpu), &info);
240
241 if (err) {
242 pr_warn_once("register_vcpu_info failed: cpu=%d err=%d\n",
243 cpu, err);
244 xen_have_vcpu_info_placement = 0;
245 } else {
246
247
248
249
250 per_cpu(xen_vcpu, cpu) = vcpup;
251 }
252 }
253
254 if (!xen_have_vcpu_info_placement)
255 xen_vcpu_info_reset(cpu);
256
257 return ((per_cpu(xen_vcpu, cpu) == NULL) ? -ENODEV : 0);
258}
259
260void xen_reboot(int reason)
261{
262 struct sched_shutdown r = { .reason = reason };
263 int cpu;
264
265 for_each_online_cpu(cpu)
266 xen_pmu_finish(cpu);
267
268 if (HYPERVISOR_sched_op(SCHEDOP_shutdown, &r))
269 BUG();
270}
271
272void xen_emergency_restart(void)
273{
274 xen_reboot(SHUTDOWN_reboot);
275}
276
277static int
278xen_panic_event(struct notifier_block *this, unsigned long event, void *ptr)
279{
280 if (!kexec_crash_loaded())
281 xen_reboot(SHUTDOWN_crash);
282 return NOTIFY_DONE;
283}
284
285static struct notifier_block xen_panic_block = {
286 .notifier_call = xen_panic_event,
287 .priority = INT_MIN
288};
289
290int xen_panic_handler_init(void)
291{
292 atomic_notifier_chain_register(&panic_notifier_list, &xen_panic_block);
293 return 0;
294}
295
296void xen_pin_vcpu(int cpu)
297{
298 static bool disable_pinning;
299 struct sched_pin_override pin_override;
300 int ret;
301
302 if (disable_pinning)
303 return;
304
305 pin_override.pcpu = cpu;
306 ret = HYPERVISOR_sched_op(SCHEDOP_pin_override, &pin_override);
307
308
309 if (cpu < 0)
310 return;
311
312 switch (ret) {
313 case -ENOSYS:
314 pr_warn("Unable to pin on physical cpu %d. In case of problems consider vcpu pinning.\n",
315 cpu);
316 disable_pinning = true;
317 break;
318 case -EPERM:
319 WARN(1, "Trying to pin vcpu without having privilege to do so\n");
320 disable_pinning = true;
321 break;
322 case -EINVAL:
323 case -EBUSY:
324 pr_warn("Physical cpu %d not available for pinning. Check Xen cpu configuration.\n",
325 cpu);
326 break;
327 case 0:
328 break;
329 default:
330 WARN(1, "rc %d while trying to pin vcpu\n", ret);
331 disable_pinning = true;
332 }
333}
334
335#ifdef CONFIG_HOTPLUG_CPU
336void xen_arch_register_cpu(int num)
337{
338 arch_register_cpu(num);
339}
340EXPORT_SYMBOL(xen_arch_register_cpu);
341
342void xen_arch_unregister_cpu(int num)
343{
344 arch_unregister_cpu(num);
345}
346EXPORT_SYMBOL(xen_arch_unregister_cpu);
347#endif
348