From: Greg Kroah-Hartman Date: Thu, 11 May 2017 12:25:19 +0000 (+0200) Subject: 4.9-stable patches X-Git-Tag: v4.4.68~18 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=517ec11f806bfe572bb792f49e685d64c07f90b9;p=thirdparty%2Fkernel%2Fstable-queue.git 4.9-stable patches added patches: f2fs-sanity-check-segment-count.patch xen-revert-commits-da72ff5bfcb0-and-72a9b186292d.patch --- diff --git a/queue-4.9/f2fs-sanity-check-segment-count.patch b/queue-4.9/f2fs-sanity-check-segment-count.patch new file mode 100644 index 00000000000..07f86d52b9b --- /dev/null +++ b/queue-4.9/f2fs-sanity-check-segment-count.patch @@ -0,0 +1,52 @@ +From b9dd46188edc2f0d1f37328637860bb65a771124 Mon Sep 17 00:00:00 2001 +From: Jin Qian +Date: Tue, 25 Apr 2017 16:28:48 -0700 +Subject: f2fs: sanity check segment count + +From: Jin Qian + +commit b9dd46188edc2f0d1f37328637860bb65a771124 upstream. + +F2FS uses 4 bytes to represent block address. As a result, supported +size of disk is 16 TB and it equals to 16 * 1024 * 1024 / 2 segments. + +Signed-off-by: Jin Qian +Signed-off-by: Jaegeuk Kim +Signed-off-by: Greg Kroah-Hartman + +--- + fs/f2fs/super.c | 7 +++++++ + include/linux/f2fs_fs.h | 6 ++++++ + 2 files changed, 13 insertions(+) + +--- a/fs/f2fs/super.c ++++ b/fs/f2fs/super.c +@@ -1405,6 +1405,13 @@ static int sanity_check_raw_super(struct + return 1; + } + ++ if (le32_to_cpu(raw_super->segment_count) > F2FS_MAX_SEGMENT) { ++ f2fs_msg(sb, KERN_INFO, ++ "Invalid segment count (%u)", ++ le32_to_cpu(raw_super->segment_count)); ++ return 1; ++ } ++ + /* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */ + if (sanity_check_area_boundary(sbi, bh)) + return 1; +--- a/include/linux/f2fs_fs.h ++++ b/include/linux/f2fs_fs.h +@@ -286,6 +286,12 @@ struct f2fs_nat_block { + #define SIT_ENTRY_PER_BLOCK (PAGE_SIZE / sizeof(struct f2fs_sit_entry)) + + /* ++ * F2FS uses 4 bytes to represent block address. As a result, supported size of ++ * disk is 16 TB and it equals to 16 * 1024 * 1024 / 2 segments. ++ */ ++#define F2FS_MAX_SEGMENT ((16 * 1024 * 1024) / 2) ++ ++/* + * Note that f2fs_sit_entry->vblocks has the following bit-field information. + * [15:10] : allocation type such as CURSEG_XXXX_TYPE + * [9:0] : valid block count diff --git a/queue-4.9/series b/queue-4.9/series index e742513ab84..6bfcc1520f7 100644 --- a/queue-4.9/series +++ b/queue-4.9/series @@ -78,7 +78,6 @@ brcmfmac-make-skb-header-writable-before-use.patch staging-lustre-llite-move-root_squash-from-sysfs-to-debugfs.patch staging-wlan-ng-add-missing-byte-order-conversion.patch staging-emxx_udc-remove-incorrect-__init-annotations.patch -staging-lustre-mdc-make-it_open-take-lookup-bits-lock.patch alsa-hda-fix-deadlock-of-controller-device-lock-at-unbinding.patch sparc64-fix-fault-handling-in-ngbzero.s-and-genbzero.s.patch macsec-dynamically-allocate-space-for-sglist.patch @@ -96,3 +95,5 @@ ipv6-reorder-ip6_route_dev_notifier-after-ipv6_dev_notf.patch bnxt_en-allocate-enough-space-for-ntp_fltr_bmap.patch bpf-don-t-let-ldimm64-leak-map-addresses-on-unprivileged.patch net-mdio-mux-bcm-iproc-call-mdiobus_free-in-error-path.patch +f2fs-sanity-check-segment-count.patch +xen-revert-commits-da72ff5bfcb0-and-72a9b186292d.patch diff --git a/queue-4.9/staging-lustre-mdc-make-it_open-take-lookup-bits-lock.patch b/queue-4.9/staging-lustre-mdc-make-it_open-take-lookup-bits-lock.patch deleted file mode 100644 index 317be443786..00000000000 --- a/queue-4.9/staging-lustre-mdc-make-it_open-take-lookup-bits-lock.patch +++ /dev/null @@ -1,38 +0,0 @@ -From 26d2bf1e71525f4c0f644820c30d1344633159e2 Mon Sep 17 00:00:00 2001 -From: Patrick Farrell -Date: Sat, 28 Jan 2017 19:05:14 -0500 -Subject: staging: lustre: mdc: Make IT_OPEN take lookup bits lock - -From: Patrick Farrell - -commit 26d2bf1e71525f4c0f644820c30d1344633159e2 upstream. - -An earlier commit accidentally changed handling of IT_OPEN, -making it take the MDS_INODELOCK_UPDATE bits lock instead of -MDS_INODELOCK_LOOKUP. This does not cause any known bugs. - -Signed-off-by: Patrick Farrell -Intel-bug-id: https://jira.hpdd.intel.com/browse/LU-8842 -Reviewed-on: https://review.whamcloud.com/23797 -Fixes: 70a251f68dea ("staging: lustre: obd: decruft md_enqueue() and md_intent_lock()" -Reviewed-by: John L. Hammond -Reviewed-by: Lai Siyao -Reviewed-by: Oleg Drokin -Signed-off-by: James Simmons -Signed-off-by: Greg Kroah-Hartman - ---- - drivers/staging/lustre/lustre/mdc/mdc_locks.c | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - ---- a/drivers/staging/lustre/lustre/mdc/mdc_locks.c -+++ b/drivers/staging/lustre/lustre/mdc/mdc_locks.c -@@ -721,7 +721,7 @@ int mdc_enqueue(struct obd_export *exp, - LASSERT(!policy); - - saved_flags |= LDLM_FL_HAS_INTENT; -- if (it->it_op & (IT_OPEN | IT_UNLINK | IT_GETATTR | IT_READDIR)) -+ if (it->it_op & (IT_UNLINK | IT_GETATTR | IT_READDIR)) - policy = &update_policy; - else if (it->it_op & IT_LAYOUT) - policy = &layout_policy; diff --git a/queue-4.9/xen-revert-commits-da72ff5bfcb0-and-72a9b186292d.patch b/queue-4.9/xen-revert-commits-da72ff5bfcb0-and-72a9b186292d.patch new file mode 100644 index 00000000000..667ee0934f8 --- /dev/null +++ b/queue-4.9/xen-revert-commits-da72ff5bfcb0-and-72a9b186292d.patch @@ -0,0 +1,342 @@ +From 84d582d236dc1f9085e741affc72e9ba061a67c2 Mon Sep 17 00:00:00 2001 +From: Boris Ostrovsky +Date: Mon, 24 Apr 2017 15:04:53 -0400 +Subject: xen: Revert commits da72ff5bfcb0 and 72a9b186292d + +From: Boris Ostrovsky + +commit 84d582d236dc1f9085e741affc72e9ba061a67c2 upstream. + +Recent discussion (http://marc.info/?l=xen-devel&m=149192184523741) +established that commit 72a9b186292d ("xen: Remove event channel +notification through Xen PCI platform device") (and thus commit +da72ff5bfcb0 ("partially revert "xen: Remove event channel +notification through Xen PCI platform device"")) are unnecessary and, +in fact, prevent HVM guests from booting on Xen releases prior to 4.0 + +Therefore we revert both of those commits. + +The summary of that discussion is below: + + Here is the brief summary of the current situation: + + Before the offending commit (72a9b186292): + + 1) INTx does not work because of the reset_watches path. + 2) The reset_watches path is only taken if you have Xen > 4.0 + 3) The Linux Kernel by default will use vector inject if the hypervisor + support. So even INTx does not work no body running the kernel with + Xen > 4.0 would notice. Unless he explicitly disabled this feature + either in the kernel or in Xen (and this can only be disabled by + modifying the code, not user-supported way to do it). + + After the offending commit (+ partial revert): + + 1) INTx is no longer support for HVM (only for PV guests). + 2) Any HVM guest The kernel will not boot on Xen < 4.0 which does + not have vector injection support. Since the only other mode + supported is INTx which. + + So based on this summary, I think before commit (72a9b186292) we were + in much better position from a user point of view. + +Signed-off-by: Boris Ostrovsky +Reviewed-by: Juergen Gross +Cc: Boris Ostrovsky +Cc: Thomas Gleixner +Cc: Ingo Molnar +Cc: "H. Peter Anvin" +Cc: x86@kernel.org +Cc: Konrad Rzeszutek Wilk +Cc: Bjorn Helgaas +Cc: Stefano Stabellini +Cc: Julien Grall +Cc: Vitaly Kuznetsov +Cc: Paul Gortmaker +Cc: Ross Lagerwall +Cc: xen-devel@lists.xenproject.org +Cc: linux-kernel@vger.kernel.org +Cc: linux-pci@vger.kernel.org +Cc: Anthony Liguori +Cc: KarimAllah Ahmed +Signed-off-by: Juergen Gross +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/include/asm/xen/events.h | 11 ++++++ + arch/x86/pci/xen.c | 2 - + arch/x86/xen/enlighten.c | 21 ++++++++---- + arch/x86/xen/smp.c | 2 + + arch/x86/xen/time.c | 5 ++ + drivers/xen/events/events_base.c | 26 ++++++++++----- + drivers/xen/platform-pci.c | 64 ++++++++++++++++++++++++++++++++++++++ + include/xen/xen.h | 3 + + 8 files changed, 117 insertions(+), 17 deletions(-) + +--- a/arch/x86/include/asm/xen/events.h ++++ b/arch/x86/include/asm/xen/events.h +@@ -20,4 +20,15 @@ static inline int xen_irqs_disabled(stru + /* No need for a barrier -- XCHG is a barrier on x86. */ + #define xchg_xen_ulong(ptr, val) xchg((ptr), (val)) + ++extern int xen_have_vector_callback; ++ ++/* ++ * Events delivered via platform PCI interrupts are always ++ * routed to vcpu 0 and hence cannot be rebound. ++ */ ++static inline bool xen_support_evtchn_rebind(void) ++{ ++ return (!xen_hvm_domain() || xen_have_vector_callback); ++} ++ + #endif /* _ASM_X86_XEN_EVENTS_H */ +--- a/arch/x86/pci/xen.c ++++ b/arch/x86/pci/xen.c +@@ -447,7 +447,7 @@ void __init xen_msi_init(void) + + int __init pci_xen_hvm_init(void) + { +- if (!xen_feature(XENFEAT_hvm_pirqs)) ++ if (!xen_have_vector_callback || !xen_feature(XENFEAT_hvm_pirqs)) + return 0; + + #ifdef CONFIG_ACPI +--- a/arch/x86/xen/enlighten.c ++++ b/arch/x86/xen/enlighten.c +@@ -137,6 +137,8 @@ struct shared_info xen_dummy_shared_info + void *xen_initial_gdt; + + RESERVE_BRK(shared_info_page_brk, PAGE_SIZE); ++__read_mostly int xen_have_vector_callback; ++EXPORT_SYMBOL_GPL(xen_have_vector_callback); + + static int xen_cpu_up_prepare(unsigned int cpu); + static int xen_cpu_up_online(unsigned int cpu); +@@ -1521,7 +1523,10 @@ static void __init xen_pvh_early_guest_i + if (!xen_feature(XENFEAT_auto_translated_physmap)) + return; + +- BUG_ON(!xen_feature(XENFEAT_hvm_callback_vector)); ++ if (!xen_feature(XENFEAT_hvm_callback_vector)) ++ return; ++ ++ xen_have_vector_callback = 1; + + xen_pvh_early_cpu_init(0, false); + xen_pvh_set_cr_flags(0); +@@ -1860,7 +1865,9 @@ static int xen_cpu_up_prepare(unsigned i + xen_vcpu_setup(cpu); + } + +- if (xen_pv_domain() || xen_feature(XENFEAT_hvm_safe_pvclock)) ++ if (xen_pv_domain() || ++ (xen_have_vector_callback && ++ xen_feature(XENFEAT_hvm_safe_pvclock))) + xen_setup_timer(cpu); + + rc = xen_smp_intr_init(cpu); +@@ -1876,7 +1883,9 @@ static int xen_cpu_dead(unsigned int cpu + { + xen_smp_intr_free(cpu); + +- if (xen_pv_domain() || xen_feature(XENFEAT_hvm_safe_pvclock)) ++ if (xen_pv_domain() || ++ (xen_have_vector_callback && ++ xen_feature(XENFEAT_hvm_safe_pvclock))) + xen_teardown_timer(cpu); + + return 0; +@@ -1915,8 +1924,8 @@ static void __init xen_hvm_guest_init(vo + + xen_panic_handler_init(); + +- BUG_ON(!xen_feature(XENFEAT_hvm_callback_vector)); +- ++ if (xen_feature(XENFEAT_hvm_callback_vector)) ++ xen_have_vector_callback = 1; + xen_hvm_smp_init(); + WARN_ON(xen_cpuhp_setup()); + xen_unplug_emulated_devices(); +@@ -1954,7 +1963,7 @@ bool xen_hvm_need_lapic(void) + return false; + if (!xen_hvm_domain()) + return false; +- if (xen_feature(XENFEAT_hvm_pirqs)) ++ if (xen_feature(XENFEAT_hvm_pirqs) && xen_have_vector_callback) + return false; + return true; + } +--- a/arch/x86/xen/smp.c ++++ b/arch/x86/xen/smp.c +@@ -765,6 +765,8 @@ static void __init xen_hvm_smp_prepare_c + + void __init xen_hvm_smp_init(void) + { ++ if (!xen_have_vector_callback) ++ return; + smp_ops.smp_prepare_cpus = xen_hvm_smp_prepare_cpus; + smp_ops.smp_send_reschedule = xen_smp_send_reschedule; + smp_ops.cpu_die = xen_cpu_die; +--- a/arch/x86/xen/time.c ++++ b/arch/x86/xen/time.c +@@ -432,6 +432,11 @@ static void xen_hvm_setup_cpu_clockevent + + void __init xen_hvm_init_time_ops(void) + { ++ /* vector callback is needed otherwise we cannot receive interrupts ++ * on cpu > 0 and at this point we don't know how many cpus are ++ * available */ ++ if (!xen_have_vector_callback) ++ return; + if (!xen_feature(XENFEAT_hvm_safe_pvclock)) { + printk(KERN_INFO "Xen doesn't support pvclock on HVM," + "disable pv timer\n"); +--- a/drivers/xen/events/events_base.c ++++ b/drivers/xen/events/events_base.c +@@ -1314,6 +1314,9 @@ static int rebind_irq_to_cpu(unsigned ir + if (!VALID_EVTCHN(evtchn)) + return -1; + ++ if (!xen_support_evtchn_rebind()) ++ return -1; ++ + /* Send future instances of this interrupt to other vcpu. */ + bind_vcpu.port = evtchn; + bind_vcpu.vcpu = xen_vcpu_nr(tcpu); +@@ -1647,15 +1650,20 @@ void xen_callback_vector(void) + { + int rc; + uint64_t callback_via; +- +- callback_via = HVM_CALLBACK_VECTOR(HYPERVISOR_CALLBACK_VECTOR); +- rc = xen_set_callback_via(callback_via); +- BUG_ON(rc); +- pr_info("Xen HVM callback vector for event delivery is enabled\n"); +- /* in the restore case the vector has already been allocated */ +- if (!test_bit(HYPERVISOR_CALLBACK_VECTOR, used_vectors)) +- alloc_intr_gate(HYPERVISOR_CALLBACK_VECTOR, +- xen_hvm_callback_vector); ++ if (xen_have_vector_callback) { ++ callback_via = HVM_CALLBACK_VECTOR(HYPERVISOR_CALLBACK_VECTOR); ++ rc = xen_set_callback_via(callback_via); ++ if (rc) { ++ pr_err("Request for Xen HVM callback vector failed\n"); ++ xen_have_vector_callback = 0; ++ return; ++ } ++ pr_info("Xen HVM callback vector for event delivery is enabled\n"); ++ /* in the restore case the vector has already been allocated */ ++ if (!test_bit(HYPERVISOR_CALLBACK_VECTOR, used_vectors)) ++ alloc_intr_gate(HYPERVISOR_CALLBACK_VECTOR, ++ xen_hvm_callback_vector); ++ } + } + #else + void xen_callback_vector(void) {} +--- a/drivers/xen/platform-pci.c ++++ b/drivers/xen/platform-pci.c +@@ -42,6 +42,7 @@ + static unsigned long platform_mmio; + static unsigned long platform_mmio_alloc; + static unsigned long platform_mmiolen; ++static uint64_t callback_via; + + static unsigned long alloc_xen_mmio(unsigned long len) + { +@@ -54,6 +55,51 @@ static unsigned long alloc_xen_mmio(unsi + return addr; + } + ++static uint64_t get_callback_via(struct pci_dev *pdev) ++{ ++ u8 pin; ++ int irq; ++ ++ irq = pdev->irq; ++ if (irq < 16) ++ return irq; /* ISA IRQ */ ++ ++ pin = pdev->pin; ++ ++ /* We don't know the GSI. Specify the PCI INTx line instead. */ ++ return ((uint64_t)0x01 << 56) | /* PCI INTx identifier */ ++ ((uint64_t)pci_domain_nr(pdev->bus) << 32) | ++ ((uint64_t)pdev->bus->number << 16) | ++ ((uint64_t)(pdev->devfn & 0xff) << 8) | ++ ((uint64_t)(pin - 1) & 3); ++} ++ ++static irqreturn_t do_hvm_evtchn_intr(int irq, void *dev_id) ++{ ++ xen_hvm_evtchn_do_upcall(); ++ return IRQ_HANDLED; ++} ++ ++static int xen_allocate_irq(struct pci_dev *pdev) ++{ ++ return request_irq(pdev->irq, do_hvm_evtchn_intr, ++ IRQF_NOBALANCING | IRQF_TRIGGER_RISING, ++ "xen-platform-pci", pdev); ++} ++ ++static int platform_pci_resume(struct pci_dev *pdev) ++{ ++ int err; ++ if (xen_have_vector_callback) ++ return 0; ++ err = xen_set_callback_via(callback_via); ++ if (err) { ++ dev_err(&pdev->dev, "platform_pci_resume failure!\n"); ++ return err; ++ } ++ return 0; ++} ++ + static int platform_pci_probe(struct pci_dev *pdev, + const struct pci_device_id *ent) + { +@@ -92,6 +138,21 @@ static int platform_pci_probe(struct pci + platform_mmio = mmio_addr; + platform_mmiolen = mmio_len; + ++ if (!xen_have_vector_callback) { ++ ret = xen_allocate_irq(pdev); ++ if (ret) { ++ dev_warn(&pdev->dev, "request_irq failed err=%d\n", ret); ++ goto out; ++ } ++ callback_via = get_callback_via(pdev); ++ ret = xen_set_callback_via(callback_via); ++ if (ret) { ++ dev_warn(&pdev->dev, "Unable to set the evtchn callback " ++ "err=%d\n", ret); ++ goto out; ++ } ++ } ++ + max_nr_gframes = gnttab_max_grant_frames(); + grant_frames = alloc_xen_mmio(PAGE_SIZE * max_nr_gframes); + ret = gnttab_setup_auto_xlat_frames(grant_frames); +@@ -123,6 +184,9 @@ static struct pci_driver platform_driver + .name = DRV_NAME, + .probe = platform_pci_probe, + .id_table = platform_pci_tbl, ++#ifdef CONFIG_PM ++ .resume_early = platform_pci_resume, ++#endif + }; + + static int __init platform_pci_init(void) +--- a/include/xen/xen.h ++++ b/include/xen/xen.h +@@ -38,7 +38,8 @@ extern enum xen_domain_type xen_domain_t + */ + #include + #define xen_pvh_domain() (xen_pv_domain() && \ +- xen_feature(XENFEAT_auto_translated_physmap)) ++ xen_feature(XENFEAT_auto_translated_physmap) && \ ++ xen_have_vector_callback) + #else + #define xen_pvh_domain() (0) + #endif