History

x86/xen: allow privcmd hypercalls to be preempted

Hypercalls submitted by user space tools via the privcmd driver can take a long time (potentially many 10s of seconds) if the hypercall has many sub-operations. A fully preemptible kernel may deschedule such as task in any upcall called from a hypercall continuation. However, in a kernel with voluntary or no preemption, hypercall continuations in Xen allow event handlers to be run but the task issuing the hypercall will not be descheduled until the hypercall is complete and the ioctl returns to user space. These long running tasks may also trigger the kernel's soft lockup detection. Add xen_preemptible_hcall_begin() and xen_preemptible_hcall_end() to bracket hypercalls that may be preempted. Use these in the privcmd driver. When returning from an upcall, call xen_maybe_preempt_hcall() which adds a schedule point if if the current task was within a preemptible hypercall. Since _cond_resched() can move the task to a different CPU, clear and set xen_in_preemptible_hcall around the call.

David Vrabel committed 11 years ago

Commit fdfd8111 parent 31795b46 files · +79 −1Browse files

Unified · Split

6 files
  1. arch/x86/kernel/entry_32.S +3 −0
  2. arch/x86/kernel/entry_64.S +3 −0
  3. drivers/xen/Makefile +1 −1
  4. drivers/xen/preempt.c +44 −0
  5. drivers/xen/privcmd.c +2 −0
  6. include/xen/xen-ops.h +26 −0
arch/x86/kernel/entry_32.S+3−0
@@ -982,6 +982,9 @@ ENTRY(xen_hypervisor_callback) · 981 unmodified lines
982ENTRY(xen_do_upcall)982ENTRY(xen_do_upcall)
9831: mov %esp, %eax9831: mov %esp, %eax
984 call xen_evtchn_do_upcall984 call xen_evtchn_do_upcall
985#ifndef CONFIG_PREEMPT
986 call xen_maybe_preempt_hcall
987#endif
985 jmp ret_from_intr988 jmp ret_from_intr
986 CFI_ENDPROC989 CFI_ENDPROC
987ENDPROC(xen_hypervisor_callback)990ENDPROC(xen_hypervisor_callback)
arch/x86/kernel/entry_64.S+3−0
@@ -1208,6 +1208,9 @@ ENTRY(xen_do_hypervisor_callback) # do_hypervisor_callback(struct *pt_regs) · 1207 unmodified lines
1208 popq %rsp1208 popq %rsp
1209 CFI_DEF_CFA_REGISTER rsp1209 CFI_DEF_CFA_REGISTER rsp
1210 decl PER_CPU_VAR(irq_count)1210 decl PER_CPU_VAR(irq_count)
1211#ifndef CONFIG_PREEMPT
1212 call xen_maybe_preempt_hcall
1213#endif
1211 jmp error_exit1214 jmp error_exit
1212 CFI_ENDPROC1215 CFI_ENDPROC
1213END(xen_do_hypervisor_callback)1216END(xen_do_hypervisor_callback)
drivers/xen/Makefile+1−1
@@ -2,7 +2,7 @@ ifeq ($(filter y, $(CONFIG_ARM) $(CONFIG_ARM64)),) · 1 unmodified line
2obj-$(CONFIG_HOTPLUG_CPU) += cpu_hotplug.o2obj-$(CONFIG_HOTPLUG_CPU) += cpu_hotplug.o
3endif3endif
4obj-$(CONFIG_X86) += fallback.o4obj-$(CONFIG_X86) += fallback.o
5obj-y += grant-table.o features.o balloon.o manage.o5obj-y += grant-table.o features.o balloon.o manage.o preempt.o
6obj-y += events/6obj-y += events/
7obj-y += xenbus/7obj-y += xenbus/
8 8
drivers/xen/preempt.c+44−0
@@ -0,0 +1,44 @@
1/*
2 * Preemptible hypercalls
3 *
4 * Copyright (C) 2014 Citrix Systems R&D ltd.
5 *
6 * This source code is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (at your option) any later version.
10 */
11
12#include <linux/sched.h>
13#include <xen/xen-ops.h>
14
15#ifndef CONFIG_PREEMPT
16
17/*
18 * Some hypercalls issued by the toolstack can take many 10s of
19 * seconds. Allow tasks running hypercalls via the privcmd driver to
20 * be voluntarily preempted even if full kernel preemption is
21 * disabled.
22 *
23 * Such preemptible hypercalls are bracketed by
24 * xen_preemptible_hcall_begin() and xen_preemptible_hcall_end()
25 * calls.
26 */
27
28DEFINE_PER_CPU(bool, xen_in_preemptible_hcall);
29EXPORT_SYMBOL_GPL(xen_in_preemptible_hcall);
30
31asmlinkage __visible void xen_maybe_preempt_hcall(void)
32{
33 if (unlikely(__this_cpu_read(xen_in_preemptible_hcall)
34 && should_resched())) {
35 /*
36 * Clear flag as we may be rescheduled on a different
37 * cpu.
38 */
39 __this_cpu_write(xen_in_preemptible_hcall, false);
40 _cond_resched();
41 __this_cpu_write(xen_in_preemptible_hcall, true);
42 }
43}
44#endif /* CONFIG_PREEMPT */
drivers/xen/privcmd.c+2−0
@@ -56,10 +56,12 @@ static long privcmd_ioctl_hypercall(void __user *udata) · 55 unmodified lines
56 if (copy_from_user(&hypercall, udata, sizeof(hypercall)))56 if (copy_from_user(&hypercall, udata, sizeof(hypercall)))
57 return -EFAULT;57 return -EFAULT;
58 58
59 xen_preemptible_hcall_begin();
59 ret = privcmd_call(hypercall.op,60 ret = privcmd_call(hypercall.op,
60 hypercall.arg[0], hypercall.arg[1],61 hypercall.arg[0], hypercall.arg[1],
61 hypercall.arg[2], hypercall.arg[3],62 hypercall.arg[2], hypercall.arg[3],
62 hypercall.arg[4]);63 hypercall.arg[4]);
64 xen_preemptible_hcall_end();
63 65
64 return ret;66 return ret;
65}67}
include/xen/xen-ops.h+26−0
@@ -46,4 +46,30 @@ static inline efi_system_table_t __init *xen_efi_probe(void) · 45 unmodified lines
46}46}
47#endif47#endif
48 48
49#ifdef CONFIG_PREEMPT
50
51static inline void xen_preemptible_hcall_begin(void)
52{
53}
54
55static inline void xen_preemptible_hcall_end(void)
56{
57}
58
59#else
60
61DECLARE_PER_CPU(bool, xen_in_preemptible_hcall);
62
63static inline void xen_preemptible_hcall_begin(void)
64{
65 __this_cpu_write(xen_in_preemptible_hcall, true);
66}
67
68static inline void xen_preemptible_hcall_end(void)
69{
70 __this_cpu_write(xen_in_preemptible_hcall, false);
71}
72
73#endif /* CONFIG_PREEMPT */
74
49#endif /* INCLUDE_XEN_OPS_H */75#endif /* INCLUDE_XEN_OPS_H */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t