Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'stable/for-linus-4.0-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip
Pull xen bugfixes from David Vrabel:
"Xen regression and bug fixes for 4.0-rc1
- Fix two regressions introduced in 4.0-rc1 affecting PV/PVH guests
in certain configurations.
- Prevent pvscsi frontends bypassing backend checks.
- Allow privcmd hypercalls to be preempted even on kernel with
voluntary preemption. This fixes soft-lockups with long running
toolstack hypercalls (e.g., when creating/destroying large
domains)"
* tag 'stable/for-linus-4.0-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip:
x86/xen: Initialize cr4 shadow for 64-bit PV(H) guests
xen-scsiback: mark pvscsi frontend request consumed only after last read
x86/xen: allow privcmd hypercalls to be preempted
x86/xen: Make sure X2APIC_ENABLE bit of MSR_IA32_APICBASE is not set
+104
-10
+3
arch/x86/kernel/entry_32.S
+3
arch/x86/kernel/entry_32.S
+3
arch/x86/kernel/entry_64.S
+3
arch/x86/kernel/entry_64.S
+19
-1
arch/x86/xen/enlighten.c
+19
-1
arch/x86/xen/enlighten.c
···
1070
1070
BUG_ON(val);
1071
1071
}
1072
1072
#endif
1073
+
1074
+
static u64 xen_read_msr_safe(unsigned int msr, int *err)
1075
+
{
1076
+
u64 val;
1077
+
1078
+
val = native_read_msr_safe(msr, err);
1079
+
switch (msr) {
1080
+
case MSR_IA32_APICBASE:
1081
+
#ifdef CONFIG_X86_X2APIC
1082
+
if (!(cpuid_ecx(1) & (1 << (X86_FEATURE_X2APIC & 31))))
1083
+
#endif
1084
+
val &= ~X2APIC_ENABLE;
1085
+
break;
1086
+
}
1087
+
return val;
1088
+
}
1089
+
1073
1090
static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
1074
1091
{
1075
1092
int ret;
···
1257
1240
1258
1241
.wbinvd = native_wbinvd,
1259
1242
1260
-
.read_msr = native_read_msr_safe,
1243
+
.read_msr = xen_read_msr_safe,
1261
1244
.write_msr = xen_write_msr_safe,
1262
1245
1263
1246
.read_tsc = native_read_tsc,
···
1758
1741
#ifdef CONFIG_X86_32
1759
1742
i386_start_kernel();
1760
1743
#else
1744
+
cr4_init_shadow(); /* 32b kernel does this in i386_start_kernel() */
1761
1745
x86_64_start_reservations((char *)__pa_symbol(&boot_params));
1762
1746
#endif
1763
1747
}
+1
-1
drivers/xen/Makefile
+1
-1
drivers/xen/Makefile
+44
drivers/xen/preempt.c
+44
drivers/xen/preempt.c
···
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
+
28
+
DEFINE_PER_CPU(bool, xen_in_preemptible_hcall);
29
+
EXPORT_SYMBOL_GPL(xen_in_preemptible_hcall);
30
+
31
+
asmlinkage __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 */
+2
drivers/xen/privcmd.c
+2
drivers/xen/privcmd.c
···
56
56
if (copy_from_user(&hypercall, udata, sizeof(hypercall)))
57
57
return -EFAULT;
58
58
59
+
xen_preemptible_hcall_begin();
59
60
ret = privcmd_call(hypercall.op,
60
61
hypercall.arg[0], hypercall.arg[1],
61
62
hypercall.arg[2], hypercall.arg[3],
62
63
hypercall.arg[4]);
64
+
xen_preemptible_hcall_end();
63
65
64
66
return ret;
65
67
}
+6
-8
drivers/xen/xen-scsiback.c
+6
-8
drivers/xen/xen-scsiback.c
···
709
709
static int scsiback_do_cmd_fn(struct vscsibk_info *info)
710
710
{
711
711
struct vscsiif_back_ring *ring = &info->ring;
712
-
struct vscsiif_request *ring_req;
712
+
struct vscsiif_request ring_req;
713
713
struct vscsibk_pend *pending_req;
714
714
RING_IDX rc, rp;
715
715
int err, more_to_do;
716
716
uint32_t result;
717
-
uint8_t act;
718
717
719
718
rc = ring->req_cons;
720
719
rp = ring->sring->req_prod;
···
734
735
if (!pending_req)
735
736
return 1;
736
737
737
-
ring_req = RING_GET_REQUEST(ring, rc);
738
+
ring_req = *RING_GET_REQUEST(ring, rc);
738
739
ring->req_cons = ++rc;
739
740
740
-
act = ring_req->act;
741
-
err = prepare_pending_reqs(info, ring_req, pending_req);
741
+
err = prepare_pending_reqs(info, &ring_req, pending_req);
742
742
if (err) {
743
743
switch (err) {
744
744
case -ENODEV:
···
753
755
return 1;
754
756
}
755
757
756
-
switch (act) {
758
+
switch (ring_req.act) {
757
759
case VSCSIIF_ACT_SCSI_CDB:
758
-
if (scsiback_gnttab_data_map(ring_req, pending_req)) {
760
+
if (scsiback_gnttab_data_map(&ring_req, pending_req)) {
759
761
scsiback_fast_flush_area(pending_req);
760
762
scsiback_do_resp_with_sense(NULL,
761
763
DRIVER_ERROR << 24, 0, pending_req);
···
766
768
break;
767
769
case VSCSIIF_ACT_SCSI_ABORT:
768
770
scsiback_device_action(pending_req, TMR_ABORT_TASK,
769
-
ring_req->ref_rqid);
771
+
ring_req.ref_rqid);
770
772
break;
771
773
case VSCSIIF_ACT_SCSI_RESET:
772
774
scsiback_device_action(pending_req, TMR_LUN_RESET, 0);
+26
include/xen/xen-ops.h
+26
include/xen/xen-ops.h
···
46
46
}
47
47
#endif
48
48
49
+
#ifdef CONFIG_PREEMPT
50
+
51
+
static inline void xen_preemptible_hcall_begin(void)
52
+
{
53
+
}
54
+
55
+
static inline void xen_preemptible_hcall_end(void)
56
+
{
57
+
}
58
+
59
+
#else
60
+
61
+
DECLARE_PER_CPU(bool, xen_in_preemptible_hcall);
62
+
63
+
static inline void xen_preemptible_hcall_begin(void)
64
+
{
65
+
__this_cpu_write(xen_in_preemptible_hcall, true);
66
+
}
67
+
68
+
static 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
75
#endif /* INCLUDE_XEN_OPS_H */