From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 1028A139694 for ; Thu, 30 Mar 2017 18:18:01 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 60E5521C1EB; Thu, 30 Mar 2017 18:18:00 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 094D821C1EB for ; Thu, 30 Mar 2017 18:18:00 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id CC20534161D for ; Thu, 30 Mar 2017 18:17:58 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id EE0FA7300 for ; Thu, 30 Mar 2017 18:17:56 +0000 (UTC) From: "Mike Pagano" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Mike Pagano" Message-ID: <1490897867.81106172f4f12a8d54193305855bddefcb09ae71.mpagano@gentoo> Subject: [gentoo-commits] proj/linux-patches:4.10 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1006_linux-4.10.7.patch X-VCS-Directories: / X-VCS-Committer: mpagano X-VCS-Committer-Name: Mike Pagano X-VCS-Revision: 81106172f4f12a8d54193305855bddefcb09ae71 X-VCS-Branch: 4.10 Date: Thu, 30 Mar 2017 18:17:56 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Archives-Salt: c8233684-86e1-4fd2-886e-053816a90bfd X-Archives-Hash: cee0d6715401bbeaaa91c557f928bede commit: 81106172f4f12a8d54193305855bddefcb09ae71 Author: Mike Pagano gentoo org> AuthorDate: Thu Mar 30 18:17:47 2017 +0000 Commit: Mike Pagano gentoo org> CommitDate: Thu Mar 30 18:17:47 2017 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=81106172 Linux patch 4.10.7 0000_README | 4 + 1006_linux-4.10.7.patch | 5177 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 5181 insertions(+) diff --git a/0000_README b/0000_README index 014e9c4..02aad35 100644 --- a/0000_README +++ b/0000_README @@ -67,6 +67,10 @@ Patch: 1005_linux-4.10.6.patch From: http://www.kernel.org Desc: Linux 4.10.6 +Patch: 1006_linux-4.10.7.patch +From: http://www.kernel.org +Desc: Linux 4.10.7 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1006_linux-4.10.7.patch b/1006_linux-4.10.7.patch new file mode 100644 index 0000000..beafe8f --- /dev/null +++ b/1006_linux-4.10.7.patch @@ -0,0 +1,5177 @@ +diff --git a/Makefile b/Makefile +index 23b6d29cb6da..976e8d1a468a 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 10 +-SUBLEVEL = 6 ++SUBLEVEL = 7 + EXTRAVERSION = + NAME = Fearless Coyote + +diff --git a/arch/arm/boot/dts/sama5d2.dtsi b/arch/arm/boot/dts/sama5d2.dtsi +index ceb9783ff7e1..ff7eae833a6d 100644 +--- a/arch/arm/boot/dts/sama5d2.dtsi ++++ b/arch/arm/boot/dts/sama5d2.dtsi +@@ -266,7 +266,7 @@ + }; + + usb1: ohci@00400000 { +- compatible = "atmel,sama5d2-ohci", "usb-ohci"; ++ compatible = "atmel,at91rm9200-ohci", "usb-ohci"; + reg = <0x00400000 0x100000>; + interrupts = <41 IRQ_TYPE_LEVEL_HIGH 2>; + clocks = <&uhphs_clk>, <&uhphs_clk>, <&uhpck>; +diff --git a/arch/arm/mach-at91/pm.c b/arch/arm/mach-at91/pm.c +index b4332b727e9c..31dde8b6f2ea 100644 +--- a/arch/arm/mach-at91/pm.c ++++ b/arch/arm/mach-at91/pm.c +@@ -289,6 +289,22 @@ static void at91_ddr_standby(void) + at91_ramc_write(1, AT91_DDRSDRC_LPR, saved_lpr1); + } + ++static void sama5d3_ddr_standby(void) ++{ ++ u32 lpr0; ++ u32 saved_lpr0; ++ ++ saved_lpr0 = at91_ramc_read(0, AT91_DDRSDRC_LPR); ++ lpr0 = saved_lpr0 & ~AT91_DDRSDRC_LPCB; ++ lpr0 |= AT91_DDRSDRC_LPCB_POWER_DOWN; ++ ++ at91_ramc_write(0, AT91_DDRSDRC_LPR, lpr0); ++ ++ cpu_do_idle(); ++ ++ at91_ramc_write(0, AT91_DDRSDRC_LPR, saved_lpr0); ++} ++ + /* We manage both DDRAM/SDRAM controllers, we need more than one value to + * remember. + */ +@@ -323,7 +339,7 @@ static const struct of_device_id const ramc_ids[] __initconst = { + { .compatible = "atmel,at91rm9200-sdramc", .data = at91rm9200_standby }, + { .compatible = "atmel,at91sam9260-sdramc", .data = at91sam9_sdram_standby }, + { .compatible = "atmel,at91sam9g45-ddramc", .data = at91_ddr_standby }, +- { .compatible = "atmel,sama5d3-ddramc", .data = at91_ddr_standby }, ++ { .compatible = "atmel,sama5d3-ddramc", .data = sama5d3_ddr_standby }, + { /*sentinel*/ } + }; + +diff --git a/arch/arm64/kernel/kaslr.c b/arch/arm64/kernel/kaslr.c +index 769f24ef628c..d7e90d97f5c4 100644 +--- a/arch/arm64/kernel/kaslr.c ++++ b/arch/arm64/kernel/kaslr.c +@@ -131,11 +131,15 @@ u64 __init kaslr_early_init(u64 dt_phys, u64 modulo_offset) + /* + * The kernel Image should not extend across a 1GB/32MB/512MB alignment + * boundary (for 4KB/16KB/64KB granule kernels, respectively). If this +- * happens, increase the KASLR offset by the size of the kernel image. ++ * happens, increase the KASLR offset by the size of the kernel image ++ * rounded up by SWAPPER_BLOCK_SIZE. + */ + if ((((u64)_text + offset + modulo_offset) >> SWAPPER_TABLE_SHIFT) != +- (((u64)_end + offset + modulo_offset) >> SWAPPER_TABLE_SHIFT)) +- offset = (offset + (u64)(_end - _text)) & mask; ++ (((u64)_end + offset + modulo_offset) >> SWAPPER_TABLE_SHIFT)) { ++ u64 kimg_sz = _end - _text; ++ offset = (offset + round_up(kimg_sz, SWAPPER_BLOCK_SIZE)) ++ & mask; ++ } + + if (IS_ENABLED(CONFIG_KASAN)) + /* +diff --git a/arch/powerpc/kernel/idle_book3s.S b/arch/powerpc/kernel/idle_book3s.S +index 72dac0b58061..b350ac5e3111 100644 +--- a/arch/powerpc/kernel/idle_book3s.S ++++ b/arch/powerpc/kernel/idle_book3s.S +@@ -439,9 +439,23 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_300) + _GLOBAL(pnv_wakeup_tb_loss) + ld r1,PACAR1(r13) + /* +- * Before entering any idle state, the NVGPRs are saved in the stack +- * and they are restored before switching to the process context. Hence +- * until they are restored, they are free to be used. ++ * Before entering any idle state, the NVGPRs are saved in the stack. ++ * If there was a state loss, or PACA_NAPSTATELOST was set, then the ++ * NVGPRs are restored. If we are here, it is likely that state is lost, ++ * but not guaranteed -- neither ISA207 nor ISA300 tests to reach ++ * here are the same as the test to restore NVGPRS: ++ * PACA_THREAD_IDLE_STATE test for ISA207, PSSCR test for ISA300, ++ * and SRR1 test for restoring NVGPRs. ++ * ++ * We are about to clobber NVGPRs now, so set NAPSTATELOST to ++ * guarantee they will always be restored. This might be tightened ++ * with careful reading of specs (particularly for ISA300) but this ++ * is already a slow wakeup path and it's simpler to be safe. ++ */ ++ li r0,1 ++ stb r0,PACA_NAPSTATELOST(r13) ++ ++ /* + * + * Save SRR1 and LR in NVGPRs as they might be clobbered in + * opal_call() (called in CHECK_HMI_INTERRUPT). SRR1 is required +diff --git a/arch/x86/pci/xen.c b/arch/x86/pci/xen.c +index e1fb269c87af..292ab0364a89 100644 +--- a/arch/x86/pci/xen.c ++++ b/arch/x86/pci/xen.c +@@ -234,23 +234,14 @@ static int xen_hvm_setup_msi_irqs(struct pci_dev *dev, int nvec, int type) + return 1; + + for_each_pci_msi_entry(msidesc, dev) { +- __pci_read_msi_msg(msidesc, &msg); +- pirq = MSI_ADDR_EXT_DEST_ID(msg.address_hi) | +- ((msg.address_lo >> MSI_ADDR_DEST_ID_SHIFT) & 0xff); +- if (msg.data != XEN_PIRQ_MSI_DATA || +- xen_irq_from_pirq(pirq) < 0) { +- pirq = xen_allocate_pirq_msi(dev, msidesc); +- if (pirq < 0) { +- irq = -ENODEV; +- goto error; +- } +- xen_msi_compose_msg(dev, pirq, &msg); +- __pci_write_msi_msg(msidesc, &msg); +- dev_dbg(&dev->dev, "xen: msi bound to pirq=%d\n", pirq); +- } else { +- dev_dbg(&dev->dev, +- "xen: msi already bound to pirq=%d\n", pirq); ++ pirq = xen_allocate_pirq_msi(dev, msidesc); ++ if (pirq < 0) { ++ irq = -ENODEV; ++ goto error; + } ++ xen_msi_compose_msg(dev, pirq, &msg); ++ __pci_write_msi_msg(msidesc, &msg); ++ dev_dbg(&dev->dev, "xen: msi bound to pirq=%d\n", pirq); + irq = xen_bind_pirq_msi_to_irq(dev, msidesc, pirq, + (type == PCI_CAP_ID_MSI) ? nvec : 1, + (type == PCI_CAP_ID_MSIX) ? +diff --git a/block/blk-mq.c b/block/blk-mq.c +index c3400b5444a7..3b57e75098c3 100644 +--- a/block/blk-mq.c ++++ b/block/blk-mq.c +@@ -678,17 +678,8 @@ static void blk_mq_check_expired(struct blk_mq_hw_ctx *hctx, + { + struct blk_mq_timeout_data *data = priv; + +- if (!test_bit(REQ_ATOM_STARTED, &rq->atomic_flags)) { +- /* +- * If a request wasn't started before the queue was +- * marked dying, kill it here or it'll go unnoticed. +- */ +- if (unlikely(blk_queue_dying(rq->q))) { +- rq->errors = -EIO; +- blk_mq_end_request(rq, rq->errors); +- } ++ if (!test_bit(REQ_ATOM_STARTED, &rq->atomic_flags)) + return; +- } + + if (time_after_eq(jiffies, rq->deadline)) { + if (!blk_mark_rq_complete(rq)) +diff --git a/crypto/algif_hash.c b/crypto/algif_hash.c +index d19b09cdf284..54fc90e8339c 100644 +--- a/crypto/algif_hash.c ++++ b/crypto/algif_hash.c +@@ -245,7 +245,7 @@ static int hash_accept(struct socket *sock, struct socket *newsock, int flags) + struct alg_sock *ask = alg_sk(sk); + struct hash_ctx *ctx = ask->private; + struct ahash_request *req = &ctx->req; +- char state[crypto_ahash_statesize(crypto_ahash_reqtfm(req))]; ++ char state[crypto_ahash_statesize(crypto_ahash_reqtfm(req)) ? : 1]; + struct sock *sk2; + struct alg_sock *ask2; + struct hash_ctx *ctx2; +diff --git a/drivers/auxdisplay/img-ascii-lcd.c b/drivers/auxdisplay/img-ascii-lcd.c +index bf43b5d2aafc..83f1439e57fd 100644 +--- a/drivers/auxdisplay/img-ascii-lcd.c ++++ b/drivers/auxdisplay/img-ascii-lcd.c +@@ -218,6 +218,7 @@ static const struct of_device_id img_ascii_lcd_matches[] = { + { .compatible = "img,boston-lcd", .data = &boston_config }, + { .compatible = "mti,malta-lcd", .data = &malta_config }, + { .compatible = "mti,sead3-lcd", .data = &sead3_config }, ++ { /* sentinel */ } + }; + + /** +diff --git a/drivers/char/hw_random/amd-rng.c b/drivers/char/hw_random/amd-rng.c +index 4a99ac756f08..9959c762da2f 100644 +--- a/drivers/char/hw_random/amd-rng.c ++++ b/drivers/char/hw_random/amd-rng.c +@@ -55,6 +55,7 @@ MODULE_DEVICE_TABLE(pci, pci_tbl); + struct amd768_priv { + void __iomem *iobase; + struct pci_dev *pcidev; ++ u32 pmbase; + }; + + static int amd_rng_read(struct hwrng *rng, void *buf, size_t max, bool wait) +@@ -148,33 +149,58 @@ static int __init mod_init(void) + if (pmbase == 0) + return -EIO; + +- priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); ++ priv = kzalloc(sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + +- if (!devm_request_region(&pdev->dev, pmbase + PMBASE_OFFSET, +- PMBASE_SIZE, DRV_NAME)) { ++ if (!request_region(pmbase + PMBASE_OFFSET, PMBASE_SIZE, DRV_NAME)) { + dev_err(&pdev->dev, DRV_NAME " region 0x%x already in use!\n", + pmbase + 0xF0); +- return -EBUSY; ++ err = -EBUSY; ++ goto out; + } + +- priv->iobase = devm_ioport_map(&pdev->dev, pmbase + PMBASE_OFFSET, +- PMBASE_SIZE); ++ priv->iobase = ioport_map(pmbase + PMBASE_OFFSET, PMBASE_SIZE); + if (!priv->iobase) { + pr_err(DRV_NAME "Cannot map ioport\n"); +- return -ENOMEM; ++ err = -EINVAL; ++ goto err_iomap; + } + + amd_rng.priv = (unsigned long)priv; ++ priv->pmbase = pmbase; + priv->pcidev = pdev; + + pr_info(DRV_NAME " detected\n"); +- return devm_hwrng_register(&pdev->dev, &amd_rng); ++ err = hwrng_register(&amd_rng); ++ if (err) { ++ pr_err(DRV_NAME " registering failed (%d)\n", err); ++ goto err_hwrng; ++ } ++ return 0; ++ ++err_hwrng: ++ ioport_unmap(priv->iobase); ++err_iomap: ++ release_region(pmbase + PMBASE_OFFSET, PMBASE_SIZE); ++out: ++ kfree(priv); ++ return err; + } + + static void __exit mod_exit(void) + { ++ struct amd768_priv *priv; ++ ++ priv = (struct amd768_priv *)amd_rng.priv; ++ ++ hwrng_unregister(&amd_rng); ++ ++ ioport_unmap(priv->iobase); ++ ++ release_region(priv->pmbase + PMBASE_OFFSET, PMBASE_SIZE); ++ ++ kfree(priv); + } + + module_init(mod_init); +diff --git a/drivers/char/hw_random/geode-rng.c b/drivers/char/hw_random/geode-rng.c +index e7a245942029..e1d421a36a13 100644 +--- a/drivers/char/hw_random/geode-rng.c ++++ b/drivers/char/hw_random/geode-rng.c +@@ -31,6 +31,9 @@ + #include + #include + ++ ++#define PFX KBUILD_MODNAME ": " ++ + #define GEODE_RNG_DATA_REG 0x50 + #define GEODE_RNG_STATUS_REG 0x54 + +@@ -82,6 +85,7 @@ static struct hwrng geode_rng = { + + static int __init mod_init(void) + { ++ int err = -ENODEV; + struct pci_dev *pdev = NULL; + const struct pci_device_id *ent; + void __iomem *mem; +@@ -89,27 +93,43 @@ static int __init mod_init(void) + + for_each_pci_dev(pdev) { + ent = pci_match_id(pci_tbl, pdev); +- if (ent) { +- rng_base = pci_resource_start(pdev, 0); +- if (rng_base == 0) +- return -ENODEV; +- +- mem = devm_ioremap(&pdev->dev, rng_base, 0x58); +- if (!mem) +- return -ENOMEM; +- geode_rng.priv = (unsigned long)mem; +- +- pr_info("AMD Geode RNG detected\n"); +- return devm_hwrng_register(&pdev->dev, &geode_rng); +- } ++ if (ent) ++ goto found; + } +- + /* Device not found. */ +- return -ENODEV; ++ goto out; ++ ++found: ++ rng_base = pci_resource_start(pdev, 0); ++ if (rng_base == 0) ++ goto out; ++ err = -ENOMEM; ++ mem = ioremap(rng_base, 0x58); ++ if (!mem) ++ goto out; ++ geode_rng.priv = (unsigned long)mem; ++ ++ pr_info("AMD Geode RNG detected\n"); ++ err = hwrng_register(&geode_rng); ++ if (err) { ++ pr_err(PFX "RNG registering failed (%d)\n", ++ err); ++ goto err_unmap; ++ } ++out: ++ return err; ++ ++err_unmap: ++ iounmap(mem); ++ goto out; + } + + static void __exit mod_exit(void) + { ++ void __iomem *mem = (void __iomem *)geode_rng.priv; ++ ++ hwrng_unregister(&geode_rng); ++ iounmap(mem); + } + + module_init(mod_init); +diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c +index 87885d146dbb..a372fef7654b 100644 +--- a/drivers/char/ppdev.c ++++ b/drivers/char/ppdev.c +@@ -84,11 +84,14 @@ struct pp_struct { + struct ieee1284_info state; + struct ieee1284_info saved_state; + long default_inactivity; ++ int index; + }; + + /* should we use PARDEVICE_MAX here? */ + static struct device *devices[PARPORT_MAX]; + ++static DEFINE_IDA(ida_index); ++ + /* pp_struct.flags bitfields */ + #define PP_CLAIMED (1<<0) + #define PP_EXCL (1<<1) +@@ -290,7 +293,7 @@ static int register_device(int minor, struct pp_struct *pp) + struct pardevice *pdev = NULL; + char *name; + struct pardev_cb ppdev_cb; +- int rc = 0; ++ int rc = 0, index; + + name = kasprintf(GFP_KERNEL, CHRDEV "%x", minor); + if (name == NULL) +@@ -303,20 +306,23 @@ static int register_device(int minor, struct pp_struct *pp) + goto err; + } + ++ index = ida_simple_get(&ida_index, 0, 0, GFP_KERNEL); + memset(&ppdev_cb, 0, sizeof(ppdev_cb)); + ppdev_cb.irq_func = pp_irq; + ppdev_cb.flags = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0; + ppdev_cb.private = pp; +- pdev = parport_register_dev_model(port, name, &ppdev_cb, minor); ++ pdev = parport_register_dev_model(port, name, &ppdev_cb, index); + parport_put_port(port); + + if (!pdev) { + pr_warn("%s: failed to register device!\n", name); + rc = -ENXIO; ++ ida_simple_remove(&ida_index, index); + goto err; + } + + pp->pdev = pdev; ++ pp->index = index; + dev_dbg(&pdev->dev, "registered pardevice\n"); + err: + kfree(name); +@@ -755,6 +761,7 @@ static int pp_release(struct inode *inode, struct file *file) + + if (pp->pdev) { + parport_unregister_device(pp->pdev); ++ ida_simple_remove(&ida_index, pp->index); + pp->pdev = NULL; + pr_debug(CHRDEV "%x: unregistered pardevice\n", minor); + } +diff --git a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c +index fc75a335a7ce..8ca07fe8d3f3 100644 +--- a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c ++++ b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c +@@ -608,7 +608,7 @@ static SUNXI_CCU_M_WITH_MUX_GATE(hdmi_clk, "hdmi", lcd_ch1_parents, + 0x150, 0, 4, 24, 2, BIT(31), + CLK_SET_RATE_PARENT); + +-static SUNXI_CCU_GATE(hdmi_ddc_clk, "hdmi-ddc", "osc24M", 0x150, BIT(31), 0); ++static SUNXI_CCU_GATE(hdmi_ddc_clk, "hdmi-ddc", "osc24M", 0x150, BIT(30), 0); + + static SUNXI_CCU_GATE(ps_clk, "ps", "lcd1-ch1", 0x140, BIT(31), 0); + +diff --git a/drivers/clk/sunxi-ng/ccu_mp.c b/drivers/clk/sunxi-ng/ccu_mp.c +index ebb1b31568a5..ee7810429c30 100644 +--- a/drivers/clk/sunxi-ng/ccu_mp.c ++++ b/drivers/clk/sunxi-ng/ccu_mp.c +@@ -85,6 +85,10 @@ static unsigned long ccu_mp_recalc_rate(struct clk_hw *hw, + unsigned int m, p; + u32 reg; + ++ /* Adjust parent_rate according to pre-dividers */ ++ ccu_mux_helper_adjust_parent_for_prediv(&cmp->common, &cmp->mux, ++ -1, &parent_rate); ++ + reg = readl(cmp->common.base + cmp->common.reg); + + m = reg >> cmp->m.shift; +@@ -114,6 +118,10 @@ static int ccu_mp_set_rate(struct clk_hw *hw, unsigned long rate, + unsigned int m, p; + u32 reg; + ++ /* Adjust parent_rate according to pre-dividers */ ++ ccu_mux_helper_adjust_parent_for_prediv(&cmp->common, &cmp->mux, ++ -1, &parent_rate); ++ + max_m = cmp->m.max ?: 1 << cmp->m.width; + max_p = cmp->p.max ?: 1 << ((1 << cmp->p.width) - 1); + +diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c +index 061b165d632e..0af2229b09fb 100644 +--- a/drivers/cpufreq/cpufreq.c ++++ b/drivers/cpufreq/cpufreq.c +@@ -1190,6 +1190,9 @@ static int cpufreq_online(unsigned int cpu) + for_each_cpu(j, policy->related_cpus) + per_cpu(cpufreq_cpu_data, j) = policy; + write_unlock_irqrestore(&cpufreq_driver_lock, flags); ++ } else { ++ policy->min = policy->user_policy.min; ++ policy->max = policy->user_policy.max; + } + + if (cpufreq_driver->get && !cpufreq_driver->setpolicy) { +diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c +index c5adc8c9ac43..ae948b1da93a 100644 +--- a/drivers/cpuidle/sysfs.c ++++ b/drivers/cpuidle/sysfs.c +@@ -615,6 +615,18 @@ int cpuidle_add_sysfs(struct cpuidle_device *dev) + struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu); + int error; + ++ /* ++ * Return if cpu_device is not setup for this CPU. ++ * ++ * This could happen if the arch did not set up cpu_device ++ * since this CPU is not in cpu_present mask and the ++ * driver did not send a correct CPU mask during registration. ++ * Without this check we would end up passing bogus ++ * value for &cpu_dev->kobj in kobject_init_and_add() ++ */ ++ if (!cpu_dev) ++ return -ENODEV; ++ + kdev = kzalloc(sizeof(*kdev), GFP_KERNEL); + if (!kdev) + return -ENOMEM; +diff --git a/drivers/crypto/ccp/ccp-dev.c b/drivers/crypto/ccp/ccp-dev.c +index 511ab042b5e7..92d1c6959f08 100644 +--- a/drivers/crypto/ccp/ccp-dev.c ++++ b/drivers/crypto/ccp/ccp-dev.c +@@ -283,11 +283,14 @@ EXPORT_SYMBOL_GPL(ccp_version); + */ + int ccp_enqueue_cmd(struct ccp_cmd *cmd) + { +- struct ccp_device *ccp = ccp_get_device(); ++ struct ccp_device *ccp; + unsigned long flags; + unsigned int i; + int ret; + ++ /* Some commands might need to be sent to a specific device */ ++ ccp = cmd->ccp ? cmd->ccp : ccp_get_device(); ++ + if (!ccp) + return -ENODEV; + +diff --git a/drivers/crypto/ccp/ccp-dmaengine.c b/drivers/crypto/ccp/ccp-dmaengine.c +index e5d9278f4019..8d0eeb46d4a2 100644 +--- a/drivers/crypto/ccp/ccp-dmaengine.c ++++ b/drivers/crypto/ccp/ccp-dmaengine.c +@@ -390,6 +390,7 @@ static struct ccp_dma_desc *ccp_create_desc(struct dma_chan *dma_chan, + goto err; + + ccp_cmd = &cmd->ccp_cmd; ++ ccp_cmd->ccp = chan->ccp; + ccp_pt = &ccp_cmd->u.passthru_nomap; + ccp_cmd->flags = CCP_CMD_MAY_BACKLOG; + ccp_cmd->flags |= CCP_CMD_PASSTHRU_NO_DMA_MAP; +diff --git a/drivers/dax/dax.c b/drivers/dax/dax.c +index ed758b74ddf0..20ab6bf9d1c7 100644 +--- a/drivers/dax/dax.c ++++ b/drivers/dax/dax.c +@@ -427,6 +427,7 @@ static int __dax_dev_fault(struct dax_dev *dax_dev, struct vm_area_struct *vma, + int rc = VM_FAULT_SIGBUS; + phys_addr_t phys; + pfn_t pfn; ++ unsigned int fault_size = PAGE_SIZE; + + if (check_vma(dax_dev, vma, __func__)) + return VM_FAULT_SIGBUS; +@@ -437,6 +438,9 @@ static int __dax_dev_fault(struct dax_dev *dax_dev, struct vm_area_struct *vma, + return VM_FAULT_SIGBUS; + } + ++ if (fault_size != dax_region->align) ++ return VM_FAULT_SIGBUS; ++ + phys = pgoff_to_phys(dax_dev, vmf->pgoff, PAGE_SIZE); + if (phys == -1) { + dev_dbg(dev, "%s: phys_to_pgoff(%#lx) failed\n", __func__, +@@ -482,6 +486,7 @@ static int __dax_dev_pmd_fault(struct dax_dev *dax_dev, + phys_addr_t phys; + pgoff_t pgoff; + pfn_t pfn; ++ unsigned int fault_size = PMD_SIZE; + + if (check_vma(dax_dev, vma, __func__)) + return VM_FAULT_SIGBUS; +@@ -498,6 +503,16 @@ static int __dax_dev_pmd_fault(struct dax_dev *dax_dev, + return VM_FAULT_SIGBUS; + } + ++ if (fault_size < dax_region->align) ++ return VM_FAULT_SIGBUS; ++ else if (fault_size > dax_region->align) ++ return VM_FAULT_FALLBACK; ++ ++ /* if we are outside of the VMA */ ++ if (pmd_addr < vma->vm_start || ++ (pmd_addr + PMD_SIZE) > vma->vm_end) ++ return VM_FAULT_SIGBUS; ++ + pgoff = linear_page_index(vma, pmd_addr); + phys = pgoff_to_phys(dax_dev, pgoff, PMD_SIZE); + if (phys == -1) { +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +index 2534adaebe30..f48da3d6698d 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +@@ -424,6 +424,7 @@ static const struct pci_device_id pciidlist[] = { + {0x1002, 0x6985, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12}, + {0x1002, 0x6986, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12}, + {0x1002, 0x6987, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12}, ++ {0x1002, 0x6995, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12}, + {0x1002, 0x699F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12}, + + {0, 0, 0} +diff --git a/drivers/gpu/drm/amd/amdgpu/si_dpm.c b/drivers/gpu/drm/amd/amdgpu/si_dpm.c +index 9a5ccae06b6c..054c9c29536d 100644 +--- a/drivers/gpu/drm/amd/amdgpu/si_dpm.c ++++ b/drivers/gpu/drm/amd/amdgpu/si_dpm.c +@@ -3498,9 +3498,13 @@ static void si_apply_state_adjust_rules(struct amdgpu_device *adev, + max_sclk = 75000; + } + } else if (adev->asic_type == CHIP_OLAND) { +- if ((adev->pdev->device == 0x6604) && +- (adev->pdev->subsystem_vendor == 0x1028) && +- (adev->pdev->subsystem_device == 0x066F)) { ++ if ((adev->pdev->revision == 0xC7) || ++ (adev->pdev->revision == 0x80) || ++ (adev->pdev->revision == 0x81) || ++ (adev->pdev->revision == 0x83) || ++ (adev->pdev->revision == 0x87) || ++ (adev->pdev->device == 0x6604) || ++ (adev->pdev->device == 0x6605)) { + max_sclk = 75000; + } + } +diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c +index 55e7372ea0a0..205251fae539 100644 +--- a/drivers/gpu/drm/drm_atomic_helper.c ++++ b/drivers/gpu/drm/drm_atomic_helper.c +@@ -1389,6 +1389,15 @@ static int stall_checks(struct drm_crtc *crtc, bool nonblock) + return ret < 0 ? ret : 0; + } + ++void release_crtc_commit(struct completion *completion) ++{ ++ struct drm_crtc_commit *commit = container_of(completion, ++ typeof(*commit), ++ flip_done); ++ ++ drm_crtc_commit_put(commit); ++} ++ + /** + * drm_atomic_helper_setup_commit - setup possibly nonblocking commit + * @state: new modeset state to be committed +@@ -1481,6 +1490,8 @@ int drm_atomic_helper_setup_commit(struct drm_atomic_state *state, + } + + crtc_state->event->base.completion = &commit->flip_done; ++ crtc_state->event->base.completion_release = release_crtc_commit; ++ drm_crtc_commit_get(commit); + } + + return 0; +diff --git a/drivers/gpu/drm/drm_fops.c b/drivers/gpu/drm/drm_fops.c +index 5d96de40b63f..30c20f90520a 100644 +--- a/drivers/gpu/drm/drm_fops.c ++++ b/drivers/gpu/drm/drm_fops.c +@@ -689,8 +689,8 @@ void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e) + assert_spin_locked(&dev->event_lock); + + if (e->completion) { +- /* ->completion might disappear as soon as it signalled. */ + complete_all(e->completion); ++ e->completion_release(e->completion); + e->completion = NULL; + } + +diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c +index f405b07d0381..740996f9bdd4 100644 +--- a/drivers/hid/hid-sony.c ++++ b/drivers/hid/hid-sony.c +@@ -2632,6 +2632,8 @@ static int sony_input_configured(struct hid_device *hdev, + sony_leds_remove(sc); + if (sc->quirks & SONY_BATTERY_SUPPORT) + sony_battery_remove(sc); ++ if (sc->touchpad) ++ sony_unregister_touchpad(sc); + sony_cancel_work_sync(sc); + kfree(sc->output_report_dmabuf); + sony_remove_dev_list(sc); +diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c +index be34547cdb68..1606e7f08f4b 100644 +--- a/drivers/hv/channel.c ++++ b/drivers/hv/channel.c +@@ -506,12 +506,15 @@ int vmbus_teardown_gpadl(struct vmbus_channel *channel, u32 gpadl_handle) + + wait_for_completion(&info->waitevent); + +- if (channel->rescind) { +- ret = -ENODEV; +- goto post_msg_err; +- } +- + post_msg_err: ++ /* ++ * If the channel has been rescinded; ++ * we will be awakened by the rescind ++ * handler; set the error code to zero so we don't leak memory. ++ */ ++ if (channel->rescind) ++ ret = 0; ++ + spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags); + list_del(&info->msglistentry); + spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags); +diff --git a/drivers/hv/channel_mgmt.c b/drivers/hv/channel_mgmt.c +index 0af7e39006c8..a58cd102af1b 100644 +--- a/drivers/hv/channel_mgmt.c ++++ b/drivers/hv/channel_mgmt.c +@@ -779,6 +779,7 @@ static void vmbus_onoffer(struct vmbus_channel_message_header *hdr) + /* Allocate the channel object and save this offer. */ + newchannel = alloc_channel(); + if (!newchannel) { ++ vmbus_release_relid(offer->child_relid); + pr_err("Unable to allocate channel object\n"); + return; + } +diff --git a/drivers/hwtracing/intel_th/core.c b/drivers/hwtracing/intel_th/core.c +index cdd9b3b26195..7563eceeaaea 100644 +--- a/drivers/hwtracing/intel_th/core.c ++++ b/drivers/hwtracing/intel_th/core.c +@@ -221,8 +221,10 @@ static int intel_th_output_activate(struct intel_th_device *thdev) + else + intel_th_trace_enable(thdev); + +- if (ret) ++ if (ret) { + pm_runtime_put(&thdev->dev); ++ module_put(thdrv->driver.owner); ++ } + + return ret; + } +diff --git a/drivers/iio/adc/ti_am335x_adc.c b/drivers/iio/adc/ti_am335x_adc.c +index ad9dec30bb30..4282ceca3d8f 100644 +--- a/drivers/iio/adc/ti_am335x_adc.c ++++ b/drivers/iio/adc/ti_am335x_adc.c +@@ -169,7 +169,9 @@ static irqreturn_t tiadc_irq_h(int irq, void *private) + { + struct iio_dev *indio_dev = private; + struct tiadc_device *adc_dev = iio_priv(indio_dev); +- unsigned int status, config; ++ unsigned int status, config, adc_fsm; ++ unsigned short count = 0; ++ + status = tiadc_readl(adc_dev, REG_IRQSTATUS); + + /* +@@ -183,6 +185,15 @@ static irqreturn_t tiadc_irq_h(int irq, void *private) + tiadc_writel(adc_dev, REG_CTRL, config); + tiadc_writel(adc_dev, REG_IRQSTATUS, IRQENB_FIFO1OVRRUN + | IRQENB_FIFO1UNDRFLW | IRQENB_FIFO1THRES); ++ ++ /* wait for idle state. ++ * ADC needs to finish the current conversion ++ * before disabling the module ++ */ ++ do { ++ adc_fsm = tiadc_readl(adc_dev, REG_ADCFSM); ++ } while (adc_fsm != 0x10 && count++ < 100); ++ + tiadc_writel(adc_dev, REG_CTRL, (config | CNTRLREG_TSCSSENB)); + return IRQ_HANDLED; + } else if (status & IRQENB_FIFO1THRES) { +diff --git a/drivers/iio/common/hid-sensors/hid-sensor-trigger.c b/drivers/iio/common/hid-sensors/hid-sensor-trigger.c +index a3cce3a38300..ecf592d69043 100644 +--- a/drivers/iio/common/hid-sensors/hid-sensor-trigger.c ++++ b/drivers/iio/common/hid-sensors/hid-sensor-trigger.c +@@ -51,8 +51,6 @@ static int _hid_sensor_power_state(struct hid_sensor_common *st, bool state) + st->report_state.report_id, + st->report_state.index, + HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM); +- +- poll_value = hid_sensor_read_poll_value(st); + } else { + int val; + +@@ -89,7 +87,9 @@ static int _hid_sensor_power_state(struct hid_sensor_common *st, bool state) + sensor_hub_get_feature(st->hsdev, st->power_state.report_id, + st->power_state.index, + sizeof(state_val), &state_val); +- if (state && poll_value) ++ if (state) ++ poll_value = hid_sensor_read_poll_value(st); ++ if (poll_value > 0) + msleep_interruptible(poll_value * 2); + + return 0; +diff --git a/drivers/iio/magnetometer/ak8974.c b/drivers/iio/magnetometer/ak8974.c +index ce09d771c1fb..75f83424903b 100644 +--- a/drivers/iio/magnetometer/ak8974.c ++++ b/drivers/iio/magnetometer/ak8974.c +@@ -767,7 +767,7 @@ static int ak8974_probe(struct i2c_client *i2c, + return ret; + } + +-static int __exit ak8974_remove(struct i2c_client *i2c) ++static int ak8974_remove(struct i2c_client *i2c) + { + struct iio_dev *indio_dev = i2c_get_clientdata(i2c); + struct ak8974 *ak8974 = iio_priv(indio_dev); +@@ -849,7 +849,7 @@ static struct i2c_driver ak8974_driver = { + .of_match_table = of_match_ptr(ak8974_of_match), + }, + .probe = ak8974_probe, +- .remove = __exit_p(ak8974_remove), ++ .remove = ak8974_remove, + .id_table = ak8974_id, + }; + module_i2c_driver(ak8974_driver); +diff --git a/drivers/input/joystick/iforce/iforce-usb.c b/drivers/input/joystick/iforce/iforce-usb.c +index d96aa27dfcdc..db64adfbe1af 100644 +--- a/drivers/input/joystick/iforce/iforce-usb.c ++++ b/drivers/input/joystick/iforce/iforce-usb.c +@@ -141,6 +141,9 @@ static int iforce_usb_probe(struct usb_interface *intf, + + interface = intf->cur_altsetting; + ++ if (interface->desc.bNumEndpoints < 2) ++ return -ENODEV; ++ + epirq = &interface->endpoint[0].desc; + epout = &interface->endpoint[1].desc; + +diff --git a/drivers/input/misc/cm109.c b/drivers/input/misc/cm109.c +index 9cc6d057c302..23c191a2a071 100644 +--- a/drivers/input/misc/cm109.c ++++ b/drivers/input/misc/cm109.c +@@ -700,6 +700,10 @@ static int cm109_usb_probe(struct usb_interface *intf, + int error = -ENOMEM; + + interface = intf->cur_altsetting; ++ ++ if (interface->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + endpoint = &interface->endpoint[0].desc; + + if (!usb_endpoint_is_int_in(endpoint)) +diff --git a/drivers/input/misc/ims-pcu.c b/drivers/input/misc/ims-pcu.c +index 9c0ea36913b4..f4e8fbec6a94 100644 +--- a/drivers/input/misc/ims-pcu.c ++++ b/drivers/input/misc/ims-pcu.c +@@ -1667,6 +1667,10 @@ static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pc + return -EINVAL; + + alt = pcu->ctrl_intf->cur_altsetting; ++ ++ if (alt->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + pcu->ep_ctrl = &alt->endpoint[0].desc; + pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl); + +diff --git a/drivers/input/misc/yealink.c b/drivers/input/misc/yealink.c +index 79c964c075f1..6e7ff9561d92 100644 +--- a/drivers/input/misc/yealink.c ++++ b/drivers/input/misc/yealink.c +@@ -875,6 +875,10 @@ static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id) + int ret, pipe, i; + + interface = intf->cur_altsetting; ++ ++ if (interface->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + endpoint = &interface->endpoint[0].desc; + if (!usb_endpoint_is_int_in(endpoint)) + return -ENODEV; +diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c +index 328edc8c8786..2a0f9e79bf69 100644 +--- a/drivers/input/mouse/alps.c ++++ b/drivers/input/mouse/alps.c +@@ -1282,10 +1282,8 @@ static int alps_decode_ss4_v2(struct alps_fields *f, + /* handle buttons */ + if (pkt_id == SS4_PACKET_ID_STICK) { + f->ts_left = !!(SS4_BTN_V2(p) & 0x01); +- if (!(priv->flags & ALPS_BUTTONPAD)) { +- f->ts_right = !!(SS4_BTN_V2(p) & 0x02); +- f->ts_middle = !!(SS4_BTN_V2(p) & 0x04); +- } ++ f->ts_right = !!(SS4_BTN_V2(p) & 0x02); ++ f->ts_middle = !!(SS4_BTN_V2(p) & 0x04); + } else { + f->left = !!(SS4_BTN_V2(p) & 0x01); + if (!(priv->flags & ALPS_BUTTONPAD)) { +@@ -2462,14 +2460,34 @@ static int alps_update_device_area_ss4_v2(unsigned char otp[][4], + int num_y_electrode; + int x_pitch, y_pitch, x_phys, y_phys; + +- num_x_electrode = SS4_NUMSENSOR_XOFFSET + (otp[1][0] & 0x0F); +- num_y_electrode = SS4_NUMSENSOR_YOFFSET + ((otp[1][0] >> 4) & 0x0F); ++ if (IS_SS4PLUS_DEV(priv->dev_id)) { ++ num_x_electrode = ++ SS4PLUS_NUMSENSOR_XOFFSET + (otp[0][2] & 0x0F); ++ num_y_electrode = ++ SS4PLUS_NUMSENSOR_YOFFSET + ((otp[0][2] >> 4) & 0x0F); ++ ++ priv->x_max = ++ (num_x_electrode - 1) * SS4PLUS_COUNT_PER_ELECTRODE; ++ priv->y_max = ++ (num_y_electrode - 1) * SS4PLUS_COUNT_PER_ELECTRODE; + +- priv->x_max = (num_x_electrode - 1) * SS4_COUNT_PER_ELECTRODE; +- priv->y_max = (num_y_electrode - 1) * SS4_COUNT_PER_ELECTRODE; ++ x_pitch = (otp[0][1] & 0x0F) + SS4PLUS_MIN_PITCH_MM; ++ y_pitch = ((otp[0][1] >> 4) & 0x0F) + SS4PLUS_MIN_PITCH_MM; + +- x_pitch = ((otp[1][2] >> 2) & 0x07) + SS4_MIN_PITCH_MM; +- y_pitch = ((otp[1][2] >> 5) & 0x07) + SS4_MIN_PITCH_MM; ++ } else { ++ num_x_electrode = ++ SS4_NUMSENSOR_XOFFSET + (otp[1][0] & 0x0F); ++ num_y_electrode = ++ SS4_NUMSENSOR_YOFFSET + ((otp[1][0] >> 4) & 0x0F); ++ ++ priv->x_max = ++ (num_x_electrode - 1) * SS4_COUNT_PER_ELECTRODE; ++ priv->y_max = ++ (num_y_electrode - 1) * SS4_COUNT_PER_ELECTRODE; ++ ++ x_pitch = ((otp[1][2] >> 2) & 0x07) + SS4_MIN_PITCH_MM; ++ y_pitch = ((otp[1][2] >> 5) & 0x07) + SS4_MIN_PITCH_MM; ++ } + + x_phys = x_pitch * (num_x_electrode - 1); /* In 0.1 mm units */ + y_phys = y_pitch * (num_y_electrode - 1); /* In 0.1 mm units */ +@@ -2485,7 +2503,10 @@ static int alps_update_btn_info_ss4_v2(unsigned char otp[][4], + { + unsigned char is_btnless; + +- is_btnless = (otp[1][1] >> 3) & 0x01; ++ if (IS_SS4PLUS_DEV(priv->dev_id)) ++ is_btnless = (otp[1][0] >> 1) & 0x01; ++ else ++ is_btnless = (otp[1][1] >> 3) & 0x01; + + if (is_btnless) + priv->flags |= ALPS_BUTTONPAD; +@@ -2493,6 +2514,21 @@ static int alps_update_btn_info_ss4_v2(unsigned char otp[][4], + return 0; + } + ++static int alps_update_dual_info_ss4_v2(unsigned char otp[][4], ++ struct alps_data *priv) ++{ ++ bool is_dual = false; ++ ++ if (IS_SS4PLUS_DEV(priv->dev_id)) ++ is_dual = (otp[0][0] >> 4) & 0x01; ++ ++ if (is_dual) ++ priv->flags |= ALPS_DUALPOINT | ++ ALPS_DUALPOINT_WITH_PRESSURE; ++ ++ return 0; ++} ++ + static int alps_set_defaults_ss4_v2(struct psmouse *psmouse, + struct alps_data *priv) + { +@@ -2508,6 +2544,8 @@ static int alps_set_defaults_ss4_v2(struct psmouse *psmouse, + + alps_update_btn_info_ss4_v2(otp, priv); + ++ alps_update_dual_info_ss4_v2(otp, priv); ++ + return 0; + } + +@@ -2753,10 +2791,6 @@ static int alps_set_protocol(struct psmouse *psmouse, + if (alps_set_defaults_ss4_v2(psmouse, priv)) + return -EIO; + +- if (priv->fw_ver[1] == 0x1) +- priv->flags |= ALPS_DUALPOINT | +- ALPS_DUALPOINT_WITH_PRESSURE; +- + break; + } + +@@ -2827,10 +2861,7 @@ static int alps_identify(struct psmouse *psmouse, struct alps_data *priv) + ec[2] >= 0x90 && ec[2] <= 0x9d) { + protocol = &alps_v3_protocol_data; + } else if (e7[0] == 0x73 && e7[1] == 0x03 && +- e7[2] == 0x14 && ec[1] == 0x02) { +- protocol = &alps_v8_protocol_data; +- } else if (e7[0] == 0x73 && e7[1] == 0x03 && +- e7[2] == 0x28 && ec[1] == 0x01) { ++ (e7[2] == 0x14 || e7[2] == 0x28)) { + protocol = &alps_v8_protocol_data; + } else { + psmouse_dbg(psmouse, +@@ -2840,7 +2871,8 @@ static int alps_identify(struct psmouse *psmouse, struct alps_data *priv) + } + + if (priv) { +- /* Save the Firmware version */ ++ /* Save Device ID and Firmware version */ ++ memcpy(priv->dev_id, e7, 3); + memcpy(priv->fw_ver, ec, 3); + error = alps_set_protocol(psmouse, priv, protocol); + if (error) +diff --git a/drivers/input/mouse/alps.h b/drivers/input/mouse/alps.h +index 6d279aa27cb9..4334f2805d93 100644 +--- a/drivers/input/mouse/alps.h ++++ b/drivers/input/mouse/alps.h +@@ -54,6 +54,16 @@ enum SS4_PACKET_ID { + + #define SS4_MASK_NORMAL_BUTTONS 0x07 + ++#define SS4PLUS_COUNT_PER_ELECTRODE 128 ++#define SS4PLUS_NUMSENSOR_XOFFSET 16 ++#define SS4PLUS_NUMSENSOR_YOFFSET 5 ++#define SS4PLUS_MIN_PITCH_MM 37 ++ ++#define IS_SS4PLUS_DEV(_b) (((_b[0]) == 0x73) && \ ++ ((_b[1]) == 0x03) && \ ++ ((_b[2]) == 0x28) \ ++ ) ++ + #define SS4_IS_IDLE_V2(_b) (((_b[0]) == 0x18) && \ + ((_b[1]) == 0x10) && \ + ((_b[2]) == 0x00) && \ +@@ -283,6 +293,7 @@ struct alps_data { + int addr_command; + u16 proto_version; + u8 byte0, mask0; ++ u8 dev_id[3]; + u8 fw_ver[3]; + int flags; + int x_max; +diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c +index 1e1d0ad406f2..a26f44c28d82 100644 +--- a/drivers/input/mouse/elan_i2c_core.c ++++ b/drivers/input/mouse/elan_i2c_core.c +@@ -218,17 +218,19 @@ static int elan_query_product(struct elan_tp_data *data) + + static int elan_check_ASUS_special_fw(struct elan_tp_data *data) + { +- if (data->ic_type != 0x0E) +- return false; +- +- switch (data->product_id) { +- case 0x05 ... 0x07: +- case 0x09: +- case 0x13: ++ if (data->ic_type == 0x0E) { ++ switch (data->product_id) { ++ case 0x05 ... 0x07: ++ case 0x09: ++ case 0x13: ++ return true; ++ } ++ } else if (data->ic_type == 0x08 && data->product_id == 0x26) { ++ /* ASUS EeeBook X205TA */ + return true; +- default: +- return false; + } ++ ++ return false; + } + + static int __elan_initialize(struct elan_tp_data *data) +diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h +index a7618776705a..27ae2a0ef1b9 100644 +--- a/drivers/input/serio/i8042-x86ia64io.h ++++ b/drivers/input/serio/i8042-x86ia64io.h +@@ -120,6 +120,13 @@ static const struct dmi_system_id __initconst i8042_dmi_noloop_table[] = { + }, + }, + { ++ /* Dell Embedded Box PC 3000 */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), ++ DMI_MATCH(DMI_PRODUCT_NAME, "Embedded Box PC 3000"), ++ }, ++ }, ++ { + /* OQO Model 01 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "OQO"), +diff --git a/drivers/input/tablet/hanwang.c b/drivers/input/tablet/hanwang.c +index cd852059b99e..df4bea96d7ed 100644 +--- a/drivers/input/tablet/hanwang.c ++++ b/drivers/input/tablet/hanwang.c +@@ -340,6 +340,9 @@ static int hanwang_probe(struct usb_interface *intf, const struct usb_device_id + int error; + int i; + ++ if (intf->cur_altsetting->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + hanwang = kzalloc(sizeof(struct hanwang), GFP_KERNEL); + input_dev = input_allocate_device(); + if (!hanwang || !input_dev) { +diff --git a/drivers/input/tablet/kbtab.c b/drivers/input/tablet/kbtab.c +index e850d7e8afbc..4d9d64908b59 100644 +--- a/drivers/input/tablet/kbtab.c ++++ b/drivers/input/tablet/kbtab.c +@@ -122,6 +122,9 @@ static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *i + struct input_dev *input_dev; + int error = -ENOMEM; + ++ if (intf->cur_altsetting->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + kbtab = kzalloc(sizeof(struct kbtab), GFP_KERNEL); + input_dev = input_allocate_device(); + if (!kbtab || !input_dev) +diff --git a/drivers/input/touchscreen/sur40.c b/drivers/input/touchscreen/sur40.c +index aefb6e11f88a..4c0eecae065c 100644 +--- a/drivers/input/touchscreen/sur40.c ++++ b/drivers/input/touchscreen/sur40.c +@@ -527,6 +527,9 @@ static int sur40_probe(struct usb_interface *interface, + if (iface_desc->desc.bInterfaceClass != 0xFF) + return -ENODEV; + ++ if (iface_desc->desc.bNumEndpoints < 5) ++ return -ENODEV; ++ + /* Use endpoint #4 (0x86). */ + endpoint = &iface_desc->endpoint[4].desc; + if (endpoint->bEndpointAddress != TOUCH_ENDPOINT) +diff --git a/drivers/iommu/exynos-iommu.c b/drivers/iommu/exynos-iommu.c +index 57ba0d3091ea..318cc878d0ca 100644 +--- a/drivers/iommu/exynos-iommu.c ++++ b/drivers/iommu/exynos-iommu.c +@@ -509,7 +509,13 @@ static void sysmmu_tlb_invalidate_flpdcache(struct sysmmu_drvdata *data, + spin_lock_irqsave(&data->lock, flags); + if (data->active && data->version >= MAKE_MMU_VER(3, 3)) { + clk_enable(data->clk_master); +- __sysmmu_tlb_invalidate_entry(data, iova, 1); ++ if (sysmmu_block(data)) { ++ if (data->version >= MAKE_MMU_VER(5, 0)) ++ __sysmmu_tlb_invalidate(data); ++ else ++ __sysmmu_tlb_invalidate_entry(data, iova, 1); ++ sysmmu_unblock(data); ++ } + clk_disable(data->clk_master); + } + spin_unlock_irqrestore(&data->lock, flags); +diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c +index 23eead3cf77c..dfeb3808bc62 100644 +--- a/drivers/iommu/intel-iommu.c ++++ b/drivers/iommu/intel-iommu.c +@@ -915,7 +915,7 @@ static struct intel_iommu *device_to_iommu(struct device *dev, u8 *bus, u8 *devf + * which we used for the IOMMU lookup. Strictly speaking + * we could do this for all PCI devices; we only need to + * get the BDF# from the scope table for ACPI matches. */ +- if (pdev->is_virtfn) ++ if (pdev && pdev->is_virtfn) + goto got_pdev; + + *bus = drhd->devices[i].bus; +diff --git a/drivers/media/usb/dvb-usb/dvb-usb-firmware.c b/drivers/media/usb/dvb-usb/dvb-usb-firmware.c +index ab9866024ec7..04033efe7ad5 100644 +--- a/drivers/media/usb/dvb-usb/dvb-usb-firmware.c ++++ b/drivers/media/usb/dvb-usb/dvb-usb-firmware.c +@@ -36,16 +36,18 @@ static int usb_cypress_writemem(struct usb_device *udev,u16 addr,u8 *data, u8 le + int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type) + { + struct hexline *hx; +- u8 reset; +- int ret,pos=0; ++ u8 *buf; ++ int ret, pos = 0; ++ u16 cpu_cs_register = cypress[type].cpu_cs_register; + +- hx = kmalloc(sizeof(*hx), GFP_KERNEL); +- if (!hx) ++ buf = kmalloc(sizeof(*hx), GFP_KERNEL); ++ if (!buf) + return -ENOMEM; ++ hx = (struct hexline *)buf; + + /* stop the CPU */ +- reset = 1; +- if ((ret = usb_cypress_writemem(udev,cypress[type].cpu_cs_register,&reset,1)) != 1) ++ buf[0] = 1; ++ if (usb_cypress_writemem(udev, cpu_cs_register, buf, 1) != 1) + err("could not stop the USB controller CPU."); + + while ((ret = dvb_usb_get_hexline(fw, hx, &pos)) > 0) { +@@ -61,21 +63,21 @@ int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw + } + if (ret < 0) { + err("firmware download failed at %d with %d",pos,ret); +- kfree(hx); ++ kfree(buf); + return ret; + } + + if (ret == 0) { + /* restart the CPU */ +- reset = 0; +- if (ret || usb_cypress_writemem(udev,cypress[type].cpu_cs_register,&reset,1) != 1) { ++ buf[0] = 0; ++ if (usb_cypress_writemem(udev, cpu_cs_register, buf, 1) != 1) { + err("could not restart the USB controller CPU."); + ret = -EINVAL; + } + } else + ret = -EIO; + +- kfree(hx); ++ kfree(buf); + + return ret; + } +diff --git a/drivers/misc/mei/bus-fixup.c b/drivers/misc/mei/bus-fixup.c +index 3600c9993a98..29f2daed37e0 100644 +--- a/drivers/misc/mei/bus-fixup.c ++++ b/drivers/misc/mei/bus-fixup.c +@@ -112,11 +112,9 @@ struct mkhi_msg { + + static int mei_osver(struct mei_cl_device *cldev) + { +- int ret; + const size_t size = sizeof(struct mkhi_msg_hdr) + + sizeof(struct mkhi_fwcaps) + + sizeof(struct mei_os_ver); +- size_t length = 8; + char buf[size]; + struct mkhi_msg *req; + struct mkhi_fwcaps *fwcaps; +@@ -137,15 +135,7 @@ static int mei_osver(struct mei_cl_device *cldev) + os_ver = (struct mei_os_ver *)fwcaps->data; + os_ver->os_type = OSTYPE_LINUX; + +- ret = __mei_cl_send(cldev->cl, buf, size, mode); +- if (ret < 0) +- return ret; +- +- ret = __mei_cl_recv(cldev->cl, buf, length, 0); +- if (ret < 0) +- return ret; +- +- return 0; ++ return __mei_cl_send(cldev->cl, buf, size, mode); + } + + static void mei_mkhi_fix(struct mei_cl_device *cldev) +@@ -160,7 +150,7 @@ static void mei_mkhi_fix(struct mei_cl_device *cldev) + return; + + ret = mei_osver(cldev); +- if (ret) ++ if (ret < 0) + dev_err(&cldev->dev, "OS version command failed %d\n", ret); + + mei_cldev_disable(cldev); +diff --git a/drivers/misc/mei/init.c b/drivers/misc/mei/init.c +index 41e5760a6886..a13abc8fa1bc 100644 +--- a/drivers/misc/mei/init.c ++++ b/drivers/misc/mei/init.c +@@ -124,8 +124,6 @@ int mei_reset(struct mei_device *dev) + + mei_clear_interrupts(dev); + +- mei_synchronize_irq(dev); +- + /* we're already in reset, cancel the init timer + * if the reset was called due the hbm protocol error + * we need to call it before hw start +@@ -304,6 +302,9 @@ static void mei_reset_work(struct work_struct *work) + container_of(work, struct mei_device, reset_work); + int ret; + ++ mei_clear_interrupts(dev); ++ mei_synchronize_irq(dev); ++ + mutex_lock(&dev->device_lock); + + ret = mei_reset(dev); +@@ -328,6 +329,9 @@ void mei_stop(struct mei_device *dev) + + mei_cancel_work(dev); + ++ mei_clear_interrupts(dev); ++ mei_synchronize_irq(dev); ++ + mutex_lock(&dev->device_lock); + + dev->dev_state = MEI_DEV_POWER_DOWN; +diff --git a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c +index cb1698f268f1..7f4927a05be0 100644 +--- a/drivers/mmc/core/block.c ++++ b/drivers/mmc/core/block.c +@@ -1791,6 +1791,7 @@ int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req) + ret = mmc_blk_issue_flush(mq, req); + } else { + ret = mmc_blk_issue_rw_rq(mq, req); ++ card->host->context_info.is_waiting_last_req = false; + } + + out: +diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c +index 0fccca075e29..4ede0904602c 100644 +--- a/drivers/mmc/core/mmc.c ++++ b/drivers/mmc/core/mmc.c +@@ -1706,7 +1706,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, + err = mmc_select_hs400(card); + if (err) + goto free_card; +- } else { ++ } else if (!mmc_card_hs400es(card)) { + /* Select the desired bus width optionally */ + err = mmc_select_bus_width(card); + if (err > 0 && mmc_card_hs(card)) { +diff --git a/drivers/mmc/host/sdhci-of-arasan.c b/drivers/mmc/host/sdhci-of-arasan.c +index 410a55b1c25f..1cfd7f900339 100644 +--- a/drivers/mmc/host/sdhci-of-arasan.c ++++ b/drivers/mmc/host/sdhci-of-arasan.c +@@ -28,13 +28,9 @@ + #include "sdhci-pltfm.h" + #include + +-#define SDHCI_ARASAN_CLK_CTRL_OFFSET 0x2c + #define SDHCI_ARASAN_VENDOR_REGISTER 0x78 + + #define VENDOR_ENHANCED_STROBE BIT(0) +-#define CLK_CTRL_TIMEOUT_SHIFT 16 +-#define CLK_CTRL_TIMEOUT_MASK (0xf << CLK_CTRL_TIMEOUT_SHIFT) +-#define CLK_CTRL_TIMEOUT_MIN_EXP 13 + + #define PHY_CLK_TOO_SLOW_HZ 400000 + +@@ -163,15 +159,15 @@ static int sdhci_arasan_syscon_write(struct sdhci_host *host, + + static unsigned int sdhci_arasan_get_timeout_clock(struct sdhci_host *host) + { +- u32 div; + unsigned long freq; + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); + +- div = readl(host->ioaddr + SDHCI_ARASAN_CLK_CTRL_OFFSET); +- div = (div & CLK_CTRL_TIMEOUT_MASK) >> CLK_CTRL_TIMEOUT_SHIFT; ++ /* SDHCI timeout clock is in kHz */ ++ freq = DIV_ROUND_UP(clk_get_rate(pltfm_host->clk), 1000); + +- freq = clk_get_rate(pltfm_host->clk); +- freq /= 1 << (CLK_CTRL_TIMEOUT_MIN_EXP + div); ++ /* or in MHz */ ++ if (host->caps & SDHCI_TIMEOUT_CLK_UNIT) ++ freq = DIV_ROUND_UP(freq, 1000); + + return freq; + } +diff --git a/drivers/mmc/host/sdhci-of-at91.c b/drivers/mmc/host/sdhci-of-at91.c +index 2f9ad213377a..7fd964256faa 100644 +--- a/drivers/mmc/host/sdhci-of-at91.c ++++ b/drivers/mmc/host/sdhci-of-at91.c +@@ -85,11 +85,30 @@ static void sdhci_at91_set_clock(struct sdhci_host *host, unsigned int clock) + sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL); + } + ++/* ++ * In this specific implementation of the SDHCI controller, the power register ++ * needs to have a valid voltage set even when the power supply is managed by ++ * an external regulator. ++ */ ++static void sdhci_at91_set_power(struct sdhci_host *host, unsigned char mode, ++ unsigned short vdd) ++{ ++ if (!IS_ERR(host->mmc->supply.vmmc)) { ++ struct mmc_host *mmc = host->mmc; ++ ++ spin_unlock_irq(&host->lock); ++ mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd); ++ spin_lock_irq(&host->lock); ++ } ++ sdhci_set_power_noreg(host, mode, vdd); ++} ++ + static const struct sdhci_ops sdhci_at91_sama5d2_ops = { + .set_clock = sdhci_at91_set_clock, + .set_bus_width = sdhci_set_bus_width, + .reset = sdhci_reset, + .set_uhs_signaling = sdhci_set_uhs_signaling, ++ .set_power = sdhci_at91_set_power, + }; + + static const struct sdhci_pltfm_data soc_data_sama5d2 = { +diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c +index 1a72d32af07f..e977048a8428 100644 +--- a/drivers/mmc/host/sdhci-pci-core.c ++++ b/drivers/mmc/host/sdhci-pci-core.c +@@ -452,6 +452,8 @@ static void sdhci_intel_set_power(struct sdhci_host *host, unsigned char mode, + if (mode == MMC_POWER_OFF) + return; + ++ spin_unlock_irq(&host->lock); ++ + /* + * Bus power might not enable after D3 -> D0 transition due to the + * present state not yet having propagated. Retry for up to 2ms. +@@ -464,6 +466,8 @@ static void sdhci_intel_set_power(struct sdhci_host *host, unsigned char mode, + reg |= SDHCI_POWER_ON; + sdhci_writeb(host, reg, SDHCI_POWER_CONTROL); + } ++ ++ spin_lock_irq(&host->lock); + } + + static const struct sdhci_ops sdhci_intel_byt_ops = { +diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c +index 0def99590d16..d0819d18ad08 100644 +--- a/drivers/mmc/host/sdhci.c ++++ b/drivers/mmc/host/sdhci.c +@@ -1362,7 +1362,9 @@ void sdhci_enable_clk(struct sdhci_host *host, u16 clk) + return; + } + timeout--; +- mdelay(1); ++ spin_unlock_irq(&host->lock); ++ usleep_range(900, 1100); ++ spin_lock_irq(&host->lock); + } + + clk |= SDHCI_CLOCK_CARD_EN; +diff --git a/drivers/mmc/host/ushc.c b/drivers/mmc/host/ushc.c +index d2c386f09d69..1d843357422e 100644 +--- a/drivers/mmc/host/ushc.c ++++ b/drivers/mmc/host/ushc.c +@@ -426,6 +426,9 @@ static int ushc_probe(struct usb_interface *intf, const struct usb_device_id *id + struct ushc_data *ushc; + int ret; + ++ if (intf->cur_altsetting->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + mmc = mmc_alloc_host(sizeof(struct ushc_data), &intf->dev); + if (mmc == NULL) + return -ENOMEM; +diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-common.h b/drivers/net/ethernet/amd/xgbe/xgbe-common.h +index 8a280e7d66bd..127adbeefb10 100644 +--- a/drivers/net/ethernet/amd/xgbe/xgbe-common.h ++++ b/drivers/net/ethernet/amd/xgbe/xgbe-common.h +@@ -984,29 +984,29 @@ + #define XP_ECC_CNT1_DESC_DED_WIDTH 8 + #define XP_ECC_CNT1_DESC_SEC_INDEX 0 + #define XP_ECC_CNT1_DESC_SEC_WIDTH 8 +-#define XP_ECC_IER_DESC_DED_INDEX 0 ++#define XP_ECC_IER_DESC_DED_INDEX 5 + #define XP_ECC_IER_DESC_DED_WIDTH 1 +-#define XP_ECC_IER_DESC_SEC_INDEX 1 ++#define XP_ECC_IER_DESC_SEC_INDEX 4 + #define XP_ECC_IER_DESC_SEC_WIDTH 1 +-#define XP_ECC_IER_RX_DED_INDEX 2 ++#define XP_ECC_IER_RX_DED_INDEX 3 + #define XP_ECC_IER_RX_DED_WIDTH 1 +-#define XP_ECC_IER_RX_SEC_INDEX 3 ++#define XP_ECC_IER_RX_SEC_INDEX 2 + #define XP_ECC_IER_RX_SEC_WIDTH 1 +-#define XP_ECC_IER_TX_DED_INDEX 4 ++#define XP_ECC_IER_TX_DED_INDEX 1 + #define XP_ECC_IER_TX_DED_WIDTH 1 +-#define XP_ECC_IER_TX_SEC_INDEX 5 ++#define XP_ECC_IER_TX_SEC_INDEX 0 + #define XP_ECC_IER_TX_SEC_WIDTH 1 +-#define XP_ECC_ISR_DESC_DED_INDEX 0 ++#define XP_ECC_ISR_DESC_DED_INDEX 5 + #define XP_ECC_ISR_DESC_DED_WIDTH 1 +-#define XP_ECC_ISR_DESC_SEC_INDEX 1 ++#define XP_ECC_ISR_DESC_SEC_INDEX 4 + #define XP_ECC_ISR_DESC_SEC_WIDTH 1 +-#define XP_ECC_ISR_RX_DED_INDEX 2 ++#define XP_ECC_ISR_RX_DED_INDEX 3 + #define XP_ECC_ISR_RX_DED_WIDTH 1 +-#define XP_ECC_ISR_RX_SEC_INDEX 3 ++#define XP_ECC_ISR_RX_SEC_INDEX 2 + #define XP_ECC_ISR_RX_SEC_WIDTH 1 +-#define XP_ECC_ISR_TX_DED_INDEX 4 ++#define XP_ECC_ISR_TX_DED_INDEX 1 + #define XP_ECC_ISR_TX_DED_WIDTH 1 +-#define XP_ECC_ISR_TX_SEC_INDEX 5 ++#define XP_ECC_ISR_TX_SEC_INDEX 0 + #define XP_ECC_ISR_TX_SEC_WIDTH 1 + #define XP_I2C_MUTEX_BUSY_INDEX 31 + #define XP_I2C_MUTEX_BUSY_WIDTH 1 +@@ -1148,8 +1148,8 @@ + #define RX_PACKET_ATTRIBUTES_CSUM_DONE_WIDTH 1 + #define RX_PACKET_ATTRIBUTES_VLAN_CTAG_INDEX 1 + #define RX_PACKET_ATTRIBUTES_VLAN_CTAG_WIDTH 1 +-#define RX_PACKET_ATTRIBUTES_INCOMPLETE_INDEX 2 +-#define RX_PACKET_ATTRIBUTES_INCOMPLETE_WIDTH 1 ++#define RX_PACKET_ATTRIBUTES_LAST_INDEX 2 ++#define RX_PACKET_ATTRIBUTES_LAST_WIDTH 1 + #define RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_INDEX 3 + #define RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_WIDTH 1 + #define RX_PACKET_ATTRIBUTES_CONTEXT_INDEX 4 +@@ -1158,6 +1158,8 @@ + #define RX_PACKET_ATTRIBUTES_RX_TSTAMP_WIDTH 1 + #define RX_PACKET_ATTRIBUTES_RSS_HASH_INDEX 6 + #define RX_PACKET_ATTRIBUTES_RSS_HASH_WIDTH 1 ++#define RX_PACKET_ATTRIBUTES_FIRST_INDEX 7 ++#define RX_PACKET_ATTRIBUTES_FIRST_WIDTH 1 + + #define RX_NORMAL_DESC0_OVT_INDEX 0 + #define RX_NORMAL_DESC0_OVT_WIDTH 16 +diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-dev.c b/drivers/net/ethernet/amd/xgbe/xgbe-dev.c +index 937f37a5dcb2..24a687ce4388 100644 +--- a/drivers/net/ethernet/amd/xgbe/xgbe-dev.c ++++ b/drivers/net/ethernet/amd/xgbe/xgbe-dev.c +@@ -1896,10 +1896,15 @@ static int xgbe_dev_read(struct xgbe_channel *channel) + + /* Get the header length */ + if (XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, FD)) { ++ XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, ++ FIRST, 1); + rdata->rx.hdr_len = XGMAC_GET_BITS_LE(rdesc->desc2, + RX_NORMAL_DESC2, HL); + if (rdata->rx.hdr_len) + pdata->ext_stats.rx_split_header_packets++; ++ } else { ++ XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, ++ FIRST, 0); + } + + /* Get the RSS hash */ +@@ -1922,19 +1927,16 @@ static int xgbe_dev_read(struct xgbe_channel *channel) + } + } + +- /* Get the packet length */ +- rdata->rx.len = XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, PL); +- +- if (!XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, LD)) { +- /* Not all the data has been transferred for this packet */ +- XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, +- INCOMPLETE, 1); ++ /* Not all the data has been transferred for this packet */ ++ if (!XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, LD)) + return 0; +- } + + /* This is the last of the data for this packet */ + XGMAC_SET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, +- INCOMPLETE, 0); ++ LAST, 1); ++ ++ /* Get the packet length */ ++ rdata->rx.len = XGMAC_GET_BITS_LE(rdesc->desc3, RX_NORMAL_DESC3, PL); + + /* Set checksum done indicator as appropriate */ + if (netdev->features & NETIF_F_RXCSUM) +diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c +index 742e5d1b5da4..36fd1a158251 100644 +--- a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c ++++ b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c +@@ -1973,13 +1973,12 @@ static struct sk_buff *xgbe_create_skb(struct xgbe_prv_data *pdata, + { + struct sk_buff *skb; + u8 *packet; +- unsigned int copy_len; + + skb = napi_alloc_skb(napi, rdata->rx.hdr.dma_len); + if (!skb) + return NULL; + +- /* Start with the header buffer which may contain just the header ++ /* Pull in the header buffer which may contain just the header + * or the header plus data + */ + dma_sync_single_range_for_cpu(pdata->dev, rdata->rx.hdr.dma_base, +@@ -1988,30 +1987,49 @@ static struct sk_buff *xgbe_create_skb(struct xgbe_prv_data *pdata, + + packet = page_address(rdata->rx.hdr.pa.pages) + + rdata->rx.hdr.pa.pages_offset; +- copy_len = (rdata->rx.hdr_len) ? rdata->rx.hdr_len : len; +- copy_len = min(rdata->rx.hdr.dma_len, copy_len); +- skb_copy_to_linear_data(skb, packet, copy_len); +- skb_put(skb, copy_len); +- +- len -= copy_len; +- if (len) { +- /* Add the remaining data as a frag */ +- dma_sync_single_range_for_cpu(pdata->dev, +- rdata->rx.buf.dma_base, +- rdata->rx.buf.dma_off, +- rdata->rx.buf.dma_len, +- DMA_FROM_DEVICE); +- +- skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, +- rdata->rx.buf.pa.pages, +- rdata->rx.buf.pa.pages_offset, +- len, rdata->rx.buf.dma_len); +- rdata->rx.buf.pa.pages = NULL; +- } ++ skb_copy_to_linear_data(skb, packet, len); ++ skb_put(skb, len); + + return skb; + } + ++static unsigned int xgbe_rx_buf1_len(struct xgbe_ring_data *rdata, ++ struct xgbe_packet_data *packet) ++{ ++ /* Always zero if not the first descriptor */ ++ if (!XGMAC_GET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, FIRST)) ++ return 0; ++ ++ /* First descriptor with split header, return header length */ ++ if (rdata->rx.hdr_len) ++ return rdata->rx.hdr_len; ++ ++ /* First descriptor but not the last descriptor and no split header, ++ * so the full buffer was used ++ */ ++ if (!XGMAC_GET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, LAST)) ++ return rdata->rx.hdr.dma_len; ++ ++ /* First descriptor and last descriptor and no split header, so ++ * calculate how much of the buffer was used ++ */ ++ return min_t(unsigned int, rdata->rx.hdr.dma_len, rdata->rx.len); ++} ++ ++static unsigned int xgbe_rx_buf2_len(struct xgbe_ring_data *rdata, ++ struct xgbe_packet_data *packet, ++ unsigned int len) ++{ ++ /* Always the full buffer if not the last descriptor */ ++ if (!XGMAC_GET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, LAST)) ++ return rdata->rx.buf.dma_len; ++ ++ /* Last descriptor so calculate how much of the buffer was used ++ * for the last bit of data ++ */ ++ return rdata->rx.len - len; ++} ++ + static int xgbe_tx_poll(struct xgbe_channel *channel) + { + struct xgbe_prv_data *pdata = channel->pdata; +@@ -2094,8 +2112,8 @@ static int xgbe_rx_poll(struct xgbe_channel *channel, int budget) + struct napi_struct *napi; + struct sk_buff *skb; + struct skb_shared_hwtstamps *hwtstamps; +- unsigned int incomplete, error, context_next, context; +- unsigned int len, rdesc_len, max_len; ++ unsigned int last, error, context_next, context; ++ unsigned int len, buf1_len, buf2_len, max_len; + unsigned int received = 0; + int packet_count = 0; + +@@ -2105,7 +2123,7 @@ static int xgbe_rx_poll(struct xgbe_channel *channel, int budget) + if (!ring) + return 0; + +- incomplete = 0; ++ last = 0; + context_next = 0; + + napi = (pdata->per_channel_irq) ? &channel->napi : &pdata->napi; +@@ -2139,9 +2157,8 @@ static int xgbe_rx_poll(struct xgbe_channel *channel, int budget) + received++; + ring->cur++; + +- incomplete = XGMAC_GET_BITS(packet->attributes, +- RX_PACKET_ATTRIBUTES, +- INCOMPLETE); ++ last = XGMAC_GET_BITS(packet->attributes, RX_PACKET_ATTRIBUTES, ++ LAST); + context_next = XGMAC_GET_BITS(packet->attributes, + RX_PACKET_ATTRIBUTES, + CONTEXT_NEXT); +@@ -2150,7 +2167,7 @@ static int xgbe_rx_poll(struct xgbe_channel *channel, int budget) + CONTEXT); + + /* Earlier error, just drain the remaining data */ +- if ((incomplete || context_next) && error) ++ if ((!last || context_next) && error) + goto read_again; + + if (error || packet->errors) { +@@ -2162,16 +2179,22 @@ static int xgbe_rx_poll(struct xgbe_channel *channel, int budget) + } + + if (!context) { +- /* Length is cumulative, get this descriptor's length */ +- rdesc_len = rdata->rx.len - len; +- len += rdesc_len; ++ /* Get the data length in the descriptor buffers */ ++ buf1_len = xgbe_rx_buf1_len(rdata, packet); ++ len += buf1_len; ++ buf2_len = xgbe_rx_buf2_len(rdata, packet, len); ++ len += buf2_len; + +- if (rdesc_len && !skb) { ++ if (!skb) { + skb = xgbe_create_skb(pdata, napi, rdata, +- rdesc_len); +- if (!skb) ++ buf1_len); ++ if (!skb) { + error = 1; +- } else if (rdesc_len) { ++ goto skip_data; ++ } ++ } ++ ++ if (buf2_len) { + dma_sync_single_range_for_cpu(pdata->dev, + rdata->rx.buf.dma_base, + rdata->rx.buf.dma_off, +@@ -2181,13 +2204,14 @@ static int xgbe_rx_poll(struct xgbe_channel *channel, int budget) + skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, + rdata->rx.buf.pa.pages, + rdata->rx.buf.pa.pages_offset, +- rdesc_len, ++ buf2_len, + rdata->rx.buf.dma_len); + rdata->rx.buf.pa.pages = NULL; + } + } + +- if (incomplete || context_next) ++skip_data: ++ if (!last || context_next) + goto read_again; + + if (!skb) +@@ -2245,7 +2269,7 @@ static int xgbe_rx_poll(struct xgbe_channel *channel, int budget) + } + + /* Check if we need to save state before leaving */ +- if (received && (incomplete || context_next)) { ++ if (received && (!last || context_next)) { + rdata = XGBE_GET_DESC_DATA(ring, ring->cur); + rdata->state_saved = 1; + rdata->state.skb = skb; +diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.c b/drivers/net/ethernet/broadcom/genet/bcmgenet.c +index f92896835d2a..3789bed26716 100644 +--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.c ++++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.c +@@ -3395,7 +3395,8 @@ static int bcmgenet_suspend(struct device *d) + + bcmgenet_netif_stop(dev); + +- phy_suspend(priv->phydev); ++ if (!device_may_wakeup(d)) ++ phy_suspend(priv->phydev); + + netif_device_detach(dev); + +@@ -3492,7 +3493,8 @@ static int bcmgenet_resume(struct device *d) + + netif_device_attach(dev); + +- phy_resume(priv->phydev); ++ if (!device_may_wakeup(d)) ++ phy_resume(priv->phydev); + + if (priv->eee.eee_enabled) + bcmgenet_eee_enable_set(dev, true); +diff --git a/drivers/net/ethernet/broadcom/genet/bcmmii.c b/drivers/net/ethernet/broadcom/genet/bcmmii.c +index e87607621e62..2f9281936f0e 100644 +--- a/drivers/net/ethernet/broadcom/genet/bcmmii.c ++++ b/drivers/net/ethernet/broadcom/genet/bcmmii.c +@@ -220,20 +220,6 @@ void bcmgenet_phy_power_set(struct net_device *dev, bool enable) + udelay(60); + } + +-static void bcmgenet_internal_phy_setup(struct net_device *dev) +-{ +- struct bcmgenet_priv *priv = netdev_priv(dev); +- u32 reg; +- +- /* Power up PHY */ +- bcmgenet_phy_power_set(dev, true); +- /* enable APD */ +- reg = bcmgenet_ext_readl(priv, EXT_EXT_PWR_MGMT); +- reg |= EXT_PWR_DN_EN_LD; +- bcmgenet_ext_writel(priv, reg, EXT_EXT_PWR_MGMT); +- bcmgenet_mii_reset(dev); +-} +- + static void bcmgenet_moca_phy_setup(struct bcmgenet_priv *priv) + { + u32 reg; +@@ -281,7 +267,6 @@ int bcmgenet_mii_config(struct net_device *dev) + + if (priv->internal_phy) { + phy_name = "internal PHY"; +- bcmgenet_internal_phy_setup(dev); + } else if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) { + phy_name = "MoCA"; + bcmgenet_moca_phy_setup(priv); +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c +index caa837e5e2b9..a380353a78c2 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c +@@ -361,6 +361,8 @@ static int mlx5_internal_err_ret_value(struct mlx5_core_dev *dev, u16 op, + case MLX5_CMD_OP_QUERY_VPORT_COUNTER: + case MLX5_CMD_OP_ALLOC_Q_COUNTER: + case MLX5_CMD_OP_QUERY_Q_COUNTER: ++ case MLX5_CMD_OP_SET_RATE_LIMIT: ++ case MLX5_CMD_OP_QUERY_RATE_LIMIT: + case MLX5_CMD_OP_ALLOC_PD: + case MLX5_CMD_OP_ALLOC_UAR: + case MLX5_CMD_OP_CONFIG_INT_MODERATION: +@@ -497,6 +499,8 @@ const char *mlx5_command_str(int command) + MLX5_COMMAND_STR_CASE(ALLOC_Q_COUNTER); + MLX5_COMMAND_STR_CASE(DEALLOC_Q_COUNTER); + MLX5_COMMAND_STR_CASE(QUERY_Q_COUNTER); ++ MLX5_COMMAND_STR_CASE(SET_RATE_LIMIT); ++ MLX5_COMMAND_STR_CASE(QUERY_RATE_LIMIT); + MLX5_COMMAND_STR_CASE(ALLOC_PD); + MLX5_COMMAND_STR_CASE(DEALLOC_PD); + MLX5_COMMAND_STR_CASE(ALLOC_UAR); +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en.h b/drivers/net/ethernet/mellanox/mlx5/core/en.h +index c69a1f827b65..41db47050991 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en.h ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en.h +@@ -921,10 +921,6 @@ void mlx5e_destroy_netdev(struct mlx5_core_dev *mdev, struct mlx5e_priv *priv); + int mlx5e_attach_netdev(struct mlx5_core_dev *mdev, struct net_device *netdev); + void mlx5e_detach_netdev(struct mlx5_core_dev *mdev, struct net_device *netdev); + u32 mlx5e_choose_lro_timeout(struct mlx5_core_dev *mdev, u32 wanted_timeout); +-void mlx5e_add_vxlan_port(struct net_device *netdev, +- struct udp_tunnel_info *ti); +-void mlx5e_del_vxlan_port(struct net_device *netdev, +- struct udp_tunnel_info *ti); + + int mlx5e_get_offload_stats(int attr_id, const struct net_device *dev, + void *sp); +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +index 9d9c64927372..a501d823e87d 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +@@ -3055,8 +3055,8 @@ static int mlx5e_get_vf_stats(struct net_device *dev, + vf_stats); + } + +-void mlx5e_add_vxlan_port(struct net_device *netdev, +- struct udp_tunnel_info *ti) ++static void mlx5e_add_vxlan_port(struct net_device *netdev, ++ struct udp_tunnel_info *ti) + { + struct mlx5e_priv *priv = netdev_priv(netdev); + +@@ -3069,8 +3069,8 @@ void mlx5e_add_vxlan_port(struct net_device *netdev, + mlx5e_vxlan_queue_work(priv, ti->sa_family, be16_to_cpu(ti->port), 1); + } + +-void mlx5e_del_vxlan_port(struct net_device *netdev, +- struct udp_tunnel_info *ti) ++static void mlx5e_del_vxlan_port(struct net_device *netdev, ++ struct udp_tunnel_info *ti) + { + struct mlx5e_priv *priv = netdev_priv(netdev); + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c +index 850378893b25..871ff3b51293 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c +@@ -394,8 +394,6 @@ static const struct net_device_ops mlx5e_netdev_ops_rep = { + .ndo_get_phys_port_name = mlx5e_rep_get_phys_port_name, + .ndo_setup_tc = mlx5e_rep_ndo_setup_tc, + .ndo_get_stats64 = mlx5e_rep_get_stats, +- .ndo_udp_tunnel_add = mlx5e_add_vxlan_port, +- .ndo_udp_tunnel_del = mlx5e_del_vxlan_port, + .ndo_has_offload_stats = mlx5e_has_offload_stats, + .ndo_get_offload_stats = mlx5e_get_offload_stats, + }; +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c +index e3b88bbb9dcf..b1939a1d4815 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c +@@ -603,6 +603,10 @@ static inline void mlx5e_build_rx_skb(struct mlx5_cqe64 *cqe, + if (lro_num_seg > 1) { + mlx5e_lro_update_hdr(skb, cqe, cqe_bcnt); + skb_shinfo(skb)->gso_size = DIV_ROUND_UP(cqe_bcnt, lro_num_seg); ++ /* Subtract one since we already counted this as one ++ * "regular" packet in mlx5e_complete_rx_cqe() ++ */ ++ rq->stats.packets += lro_num_seg - 1; + rq->stats.lro_packets++; + rq->stats.lro_bytes += cqe_bcnt; + } +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c b/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +index 2ebbe80d8126..cc718814c378 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +@@ -128,6 +128,23 @@ mlx5e_tc_add_nic_flow(struct mlx5e_priv *priv, + return rule; + } + ++static void mlx5e_tc_del_nic_flow(struct mlx5e_priv *priv, ++ struct mlx5e_tc_flow *flow) ++{ ++ struct mlx5_fc *counter = NULL; ++ ++ if (!IS_ERR(flow->rule)) { ++ counter = mlx5_flow_rule_counter(flow->rule); ++ mlx5_del_flow_rules(flow->rule); ++ mlx5_fc_destroy(priv->mdev, counter); ++ } ++ ++ if (!mlx5e_tc_num_filters(priv) && (priv->fs.tc.t)) { ++ mlx5_destroy_flow_table(priv->fs.tc.t); ++ priv->fs.tc.t = NULL; ++ } ++} ++ + static struct mlx5_flow_handle * + mlx5e_tc_add_fdb_flow(struct mlx5e_priv *priv, + struct mlx5_flow_spec *spec, +@@ -144,7 +161,24 @@ mlx5e_tc_add_fdb_flow(struct mlx5e_priv *priv, + } + + static void mlx5e_detach_encap(struct mlx5e_priv *priv, +- struct mlx5e_tc_flow *flow) { ++ struct mlx5e_tc_flow *flow); ++ ++static void mlx5e_tc_del_fdb_flow(struct mlx5e_priv *priv, ++ struct mlx5e_tc_flow *flow) ++{ ++ struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; ++ ++ mlx5_eswitch_del_offloaded_rule(esw, flow->rule, flow->attr); ++ ++ mlx5_eswitch_del_vlan_action(esw, flow->attr); ++ ++ if (flow->attr->action & MLX5_FLOW_CONTEXT_ACTION_ENCAP) ++ mlx5e_detach_encap(priv, flow); ++} ++ ++static void mlx5e_detach_encap(struct mlx5e_priv *priv, ++ struct mlx5e_tc_flow *flow) ++{ + struct list_head *next = flow->encap.next; + + list_del(&flow->encap); +@@ -169,24 +203,11 @@ static void mlx5e_tc_del_flow(struct mlx5e_priv *priv, + struct mlx5e_tc_flow *flow) + { + struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; +- struct mlx5_fc *counter = NULL; +- +- if (!IS_ERR(flow->rule)) { +- counter = mlx5_flow_rule_counter(flow->rule); +- mlx5_del_flow_rules(flow->rule); +- mlx5_fc_destroy(priv->mdev, counter); +- } +- +- if (esw && esw->mode == SRIOV_OFFLOADS) { +- mlx5_eswitch_del_vlan_action(esw, flow->attr); +- if (flow->attr->action & MLX5_FLOW_CONTEXT_ACTION_ENCAP) +- mlx5e_detach_encap(priv, flow); +- } + +- if (!mlx5e_tc_num_filters(priv) && (priv->fs.tc.t)) { +- mlx5_destroy_flow_table(priv->fs.tc.t); +- priv->fs.tc.t = NULL; +- } ++ if (esw && esw->mode == SRIOV_OFFLOADS) ++ mlx5e_tc_del_fdb_flow(priv, flow); ++ else ++ mlx5e_tc_del_nic_flow(priv, flow); + } + + static void parse_vxlan_attr(struct mlx5_flow_spec *spec, +@@ -243,12 +264,15 @@ static int parse_tunnel_attr(struct mlx5e_priv *priv, + skb_flow_dissector_target(f->dissector, + FLOW_DISSECTOR_KEY_ENC_PORTS, + f->mask); ++ struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; ++ struct net_device *up_dev = mlx5_eswitch_get_uplink_netdev(esw); ++ struct mlx5e_priv *up_priv = netdev_priv(up_dev); + + /* Full udp dst port must be given */ + if (memchr_inv(&mask->dst, 0xff, sizeof(mask->dst))) + goto vxlan_match_offload_err; + +- if (mlx5e_vxlan_lookup_port(priv, be16_to_cpu(key->dst)) && ++ if (mlx5e_vxlan_lookup_port(up_priv, be16_to_cpu(key->dst)) && + MLX5_CAP_ESW(priv->mdev, vxlan_encap_decap)) + parse_vxlan_attr(spec, f); + else { +@@ -806,6 +830,8 @@ static int mlx5e_attach_encap(struct mlx5e_priv *priv, + struct mlx5_esw_flow_attr *attr) + { + struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; ++ struct net_device *up_dev = mlx5_eswitch_get_uplink_netdev(esw); ++ struct mlx5e_priv *up_priv = netdev_priv(up_dev); + unsigned short family = ip_tunnel_info_af(tun_info); + struct ip_tunnel_key *key = &tun_info->key; + struct mlx5_encap_info info; +@@ -828,7 +854,7 @@ static int mlx5e_attach_encap(struct mlx5e_priv *priv, + return -EOPNOTSUPP; + } + +- if (mlx5e_vxlan_lookup_port(priv, be16_to_cpu(key->tp_dst)) && ++ if (mlx5e_vxlan_lookup_port(up_priv, be16_to_cpu(key->tp_dst)) && + MLX5_CAP_ESW(priv->mdev, vxlan_encap_decap)) { + info.tp_dst = key->tp_dst; + info.tun_id = tunnel_id_to_key32(key->tun_id); +@@ -953,14 +979,16 @@ static int parse_tc_fdb_actions(struct mlx5e_priv *priv, struct tcf_exts *exts, + } + + if (is_tcf_vlan(a)) { +- if (tcf_vlan_action(a) == VLAN_F_POP) { ++ if (tcf_vlan_action(a) == TCA_VLAN_ACT_POP) { + attr->action |= MLX5_FLOW_CONTEXT_ACTION_VLAN_POP; +- } else if (tcf_vlan_action(a) == VLAN_F_PUSH) { ++ } else if (tcf_vlan_action(a) == TCA_VLAN_ACT_PUSH) { + if (tcf_vlan_push_proto(a) != htons(ETH_P_8021Q)) + return -EOPNOTSUPP; + + attr->action |= MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH; + attr->vlan = tcf_vlan_push_vid(a); ++ } else { /* action is TCA_VLAN_ACT_MODIFY */ ++ return -EOPNOTSUPP; + } + continue; + } +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c +index cfb68371c397..574311018e6f 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_tx.c +@@ -272,15 +272,18 @@ static netdev_tx_t mlx5e_sq_xmit(struct mlx5e_sq *sq, struct sk_buff *skb) + sq->stats.tso_bytes += skb->len - ihs; + } + ++ sq->stats.packets += skb_shinfo(skb)->gso_segs; + num_bytes = skb->len + (skb_shinfo(skb)->gso_segs - 1) * ihs; + } else { + bf = sq->bf_budget && + !skb->xmit_more && + !skb_shinfo(skb)->nr_frags; + ihs = mlx5e_get_inline_hdr_size(sq, skb, bf); ++ sq->stats.packets++; + num_bytes = max_t(unsigned int, skb->len, ETH_ZLEN); + } + ++ sq->stats.bytes += num_bytes; + wi->num_bytes = num_bytes; + + if (skb_vlan_tag_present(skb)) { +@@ -377,8 +380,6 @@ static netdev_tx_t mlx5e_sq_xmit(struct mlx5e_sq *sq, struct sk_buff *skb) + if (bf) + sq->bf_budget--; + +- sq->stats.packets++; +- sq->stats.bytes += num_bytes; + return NETDEV_TX_OK; + + dma_unmap_wqe_err: +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/eswitch.h b/drivers/net/ethernet/mellanox/mlx5/core/eswitch.h +index 8661dd3f542c..b5967df1eeaa 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/eswitch.h ++++ b/drivers/net/ethernet/mellanox/mlx5/core/eswitch.h +@@ -201,6 +201,7 @@ struct mlx5_esw_offload { + struct mlx5_eswitch_rep *vport_reps; + DECLARE_HASHTABLE(encap_tbl, 8); + u8 inline_mode; ++ u64 num_flows; + }; + + struct mlx5_eswitch { +@@ -263,6 +264,11 @@ struct mlx5_flow_handle * + mlx5_eswitch_add_offloaded_rule(struct mlx5_eswitch *esw, + struct mlx5_flow_spec *spec, + struct mlx5_esw_flow_attr *attr); ++void ++mlx5_eswitch_del_offloaded_rule(struct mlx5_eswitch *esw, ++ struct mlx5_flow_handle *rule, ++ struct mlx5_esw_flow_attr *attr); ++ + struct mlx5_flow_handle * + mlx5_eswitch_create_vport_rx_rule(struct mlx5_eswitch *esw, int vport, u32 tirn); + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c +index 595f7c7383b3..7bce2bdbb79b 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c +@@ -93,10 +93,27 @@ mlx5_eswitch_add_offloaded_rule(struct mlx5_eswitch *esw, + spec, &flow_act, dest, i); + if (IS_ERR(rule)) + mlx5_fc_destroy(esw->dev, counter); ++ else ++ esw->offloads.num_flows++; + + return rule; + } + ++void ++mlx5_eswitch_del_offloaded_rule(struct mlx5_eswitch *esw, ++ struct mlx5_flow_handle *rule, ++ struct mlx5_esw_flow_attr *attr) ++{ ++ struct mlx5_fc *counter = NULL; ++ ++ if (!IS_ERR(rule)) { ++ counter = mlx5_flow_rule_counter(rule); ++ mlx5_del_flow_rules(rule); ++ mlx5_fc_destroy(esw->dev, counter); ++ esw->offloads.num_flows--; ++ } ++} ++ + static int esw_set_global_vlan_pop(struct mlx5_eswitch *esw, u8 val) + { + struct mlx5_eswitch_rep *rep; +@@ -905,6 +922,11 @@ int mlx5_devlink_eswitch_inline_mode_set(struct devlink *devlink, u8 mode) + MLX5_CAP_INLINE_MODE_VPORT_CONTEXT) + return -EOPNOTSUPP; + ++ if (esw->offloads.num_flows > 0) { ++ esw_warn(dev, "Can't set inline mode when flows are configured\n"); ++ return -EOPNOTSUPP; ++ } ++ + err = esw_inline_mode_from_devlink(mode, &mlx5_mode); + if (err) + goto out; +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c +index 3c315eb8d270..4aca265d9c14 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c +@@ -87,7 +87,7 @@ static struct mlx5_profile profile[] = { + [2] = { + .mask = MLX5_PROF_MASK_QP_SIZE | + MLX5_PROF_MASK_MR_CACHE, +- .log_max_qp = 17, ++ .log_max_qp = 18, + .mr_cache[0] = { + .size = 500, + .limit = 250 +diff --git a/drivers/net/ethernet/ti/Kconfig b/drivers/net/ethernet/ti/Kconfig +index 296c8efd0038..bd0af5974a75 100644 +--- a/drivers/net/ethernet/ti/Kconfig ++++ b/drivers/net/ethernet/ti/Kconfig +@@ -76,7 +76,7 @@ config TI_CPSW + config TI_CPTS + tristate "TI Common Platform Time Sync (CPTS) Support" + depends on TI_CPSW || TI_KEYSTONE_NETCP +- imply PTP_1588_CLOCK ++ depends on PTP_1588_CLOCK + ---help--- + This driver supports the Common Platform Time Sync unit of + the CPSW Ethernet Switch and Keystone 2 1g/10g Switch Subsystem. +diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c +index 24d5272cdce5..0d519a9582ca 100644 +--- a/drivers/net/usb/qmi_wwan.c ++++ b/drivers/net/usb/qmi_wwan.c +@@ -924,6 +924,8 @@ static const struct usb_device_id products[] = { + {QMI_FIXED_INTF(0x413c, 0x81a9, 8)}, /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card */ + {QMI_FIXED_INTF(0x413c, 0x81b1, 8)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card */ + {QMI_FIXED_INTF(0x413c, 0x81b3, 8)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */ ++ {QMI_FIXED_INTF(0x413c, 0x81b6, 8)}, /* Dell Wireless 5811e */ ++ {QMI_FIXED_INTF(0x413c, 0x81b6, 10)}, /* Dell Wireless 5811e */ + {QMI_FIXED_INTF(0x03f0, 0x4e1d, 8)}, /* HP lt4111 LTE/EV-DO/HSPA+ Gobi 4G Module */ + {QMI_FIXED_INTF(0x22de, 0x9061, 3)}, /* WeTelecom WPD-600N */ + {QMI_FIXED_INTF(0x1e0e, 0x9001, 5)}, /* SIMCom 7230E */ +diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c +index 682aac0a2267..921fef275ea4 100644 +--- a/drivers/net/vrf.c ++++ b/drivers/net/vrf.c +@@ -462,8 +462,10 @@ static void vrf_rt6_release(struct net_device *dev, struct net_vrf *vrf) + } + + if (rt6_local) { +- if (rt6_local->rt6i_idev) ++ if (rt6_local->rt6i_idev) { + in6_dev_put(rt6_local->rt6i_idev); ++ rt6_local->rt6i_idev = NULL; ++ } + + dst = &rt6_local->dst; + dev_put(dst->dev); +diff --git a/drivers/net/wireless/ath/ath10k/hw.c b/drivers/net/wireless/ath/ath10k/hw.c +index 33fb26833cd0..d9f37ee4bfdd 100644 +--- a/drivers/net/wireless/ath/ath10k/hw.c ++++ b/drivers/net/wireless/ath/ath10k/hw.c +@@ -51,7 +51,7 @@ const struct ath10k_hw_regs qca6174_regs = { + .rtc_soc_base_address = 0x00000800, + .rtc_wmac_base_address = 0x00001000, + .soc_core_base_address = 0x0003a000, +- .wlan_mac_base_address = 0x00020000, ++ .wlan_mac_base_address = 0x00010000, + .ce_wrapper_base_address = 0x00034000, + .ce0_base_address = 0x00034400, + .ce1_base_address = 0x00034800, +diff --git a/drivers/net/wireless/marvell/mwifiex/pcie.c b/drivers/net/wireless/marvell/mwifiex/pcie.c +index 4db07da81d8d..6d724c61cc7a 100644 +--- a/drivers/net/wireless/marvell/mwifiex/pcie.c ++++ b/drivers/net/wireless/marvell/mwifiex/pcie.c +@@ -2742,6 +2742,21 @@ static void mwifiex_pcie_device_dump(struct mwifiex_adapter *adapter) + schedule_work(&pcie_work); + } + ++static void mwifiex_pcie_free_buffers(struct mwifiex_adapter *adapter) ++{ ++ struct pcie_service_card *card = adapter->card; ++ const struct mwifiex_pcie_card_reg *reg = card->pcie.reg; ++ ++ if (reg->sleep_cookie) ++ mwifiex_pcie_delete_sleep_cookie_buf(adapter); ++ ++ mwifiex_pcie_delete_cmdrsp_buf(adapter); ++ mwifiex_pcie_delete_evtbd_ring(adapter); ++ mwifiex_pcie_delete_rxbd_ring(adapter); ++ mwifiex_pcie_delete_txbd_ring(adapter); ++ card->cmdrsp_buf = NULL; ++} ++ + /* + * This function initializes the PCI-E host memory space, WCB rings, etc. + * +@@ -2853,13 +2868,6 @@ static int mwifiex_pcie_init(struct mwifiex_adapter *adapter) + + /* + * This function cleans up the allocated card buffers. +- * +- * The following are freed by this function - +- * - TXBD ring buffers +- * - RXBD ring buffers +- * - Event BD ring buffers +- * - Command response ring buffer +- * - Sleep cookie buffer + */ + static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter) + { +@@ -2875,6 +2883,8 @@ static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter) + "Failed to write driver not-ready signature\n"); + } + ++ mwifiex_pcie_free_buffers(adapter); ++ + if (pdev) { + pci_iounmap(pdev, card->pci_mmap); + pci_iounmap(pdev, card->pci_mmap1); +@@ -3115,10 +3125,7 @@ static void mwifiex_pcie_up_dev(struct mwifiex_adapter *adapter) + pci_iounmap(pdev, card->pci_mmap1); + } + +-/* This function cleans up the PCI-E host memory space. +- * Some code is extracted from mwifiex_unregister_dev() +- * +- */ ++/* This function cleans up the PCI-E host memory space. */ + static void mwifiex_pcie_down_dev(struct mwifiex_adapter *adapter) + { + struct pcie_service_card *card = adapter->card; +@@ -3130,14 +3137,7 @@ static void mwifiex_pcie_down_dev(struct mwifiex_adapter *adapter) + adapter->seq_num = 0; + adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K; + +- if (reg->sleep_cookie) +- mwifiex_pcie_delete_sleep_cookie_buf(adapter); +- +- mwifiex_pcie_delete_cmdrsp_buf(adapter); +- mwifiex_pcie_delete_evtbd_ring(adapter); +- mwifiex_pcie_delete_rxbd_ring(adapter); +- mwifiex_pcie_delete_txbd_ring(adapter); +- card->cmdrsp_buf = NULL; ++ mwifiex_pcie_free_buffers(adapter); + } + + static struct mwifiex_if_ops pcie_ops = { +diff --git a/drivers/parport/share.c b/drivers/parport/share.c +index 3308427ed9f7..4399de34054a 100644 +--- a/drivers/parport/share.c ++++ b/drivers/parport/share.c +@@ -939,8 +939,10 @@ parport_register_dev_model(struct parport *port, const char *name, + * pardevice fields. -arca + */ + port->ops->init_state(par_dev, par_dev->state); +- port->proc_device = par_dev; +- parport_device_proc_register(par_dev); ++ if (!test_and_set_bit(PARPORT_DEVPROC_REGISTERED, &port->devflags)) { ++ port->proc_device = par_dev; ++ parport_device_proc_register(par_dev); ++ } + + return par_dev; + +diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c +index 245fbe2f1696..6e620242a600 100644 +--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c ++++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c +@@ -4658,7 +4658,6 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) + struct MPT3SAS_DEVICE *sas_device_priv_data; + u32 response_code = 0; + unsigned long flags; +- unsigned int sector_sz; + + mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); + scmd = _scsih_scsi_lookup_get_clear(ioc, smid); +@@ -4717,20 +4716,6 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) + } + + xfer_cnt = le32_to_cpu(mpi_reply->TransferCount); +- +- /* In case of bogus fw or device, we could end up having +- * unaligned partial completion. We can force alignment here, +- * then scsi-ml does not need to handle this misbehavior. +- */ +- sector_sz = scmd->device->sector_size; +- if (unlikely(scmd->request->cmd_type == REQ_TYPE_FS && sector_sz && +- xfer_cnt % sector_sz)) { +- sdev_printk(KERN_INFO, scmd->device, +- "unaligned partial completion avoided (xfer_cnt=%u, sector_sz=%u)\n", +- xfer_cnt, sector_sz); +- xfer_cnt = round_down(xfer_cnt, sector_sz); +- } +- + scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt); + if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) + log_info = le32_to_cpu(mpi_reply->IOCLogInfo); +diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c +index 1f5d92a25a49..1ee57619c95e 100644 +--- a/drivers/scsi/sd.c ++++ b/drivers/scsi/sd.c +@@ -1790,6 +1790,8 @@ static int sd_done(struct scsi_cmnd *SCpnt) + { + int result = SCpnt->result; + unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt); ++ unsigned int sector_size = SCpnt->device->sector_size; ++ unsigned int resid; + struct scsi_sense_hdr sshdr; + struct scsi_disk *sdkp = scsi_disk(SCpnt->request->rq_disk); + struct request *req = SCpnt->request; +@@ -1820,6 +1822,21 @@ static int sd_done(struct scsi_cmnd *SCpnt) + scsi_set_resid(SCpnt, blk_rq_bytes(req)); + } + break; ++ default: ++ /* ++ * In case of bogus fw or device, we could end up having ++ * an unaligned partial completion. Check this here and force ++ * alignment. ++ */ ++ resid = scsi_get_resid(SCpnt); ++ if (resid & (sector_size - 1)) { ++ sd_printk(KERN_INFO, sdkp, ++ "Unaligned partial completion (resid=%u, sector_sz=%u)\n", ++ resid, sector_size); ++ resid = min(scsi_bufflen(SCpnt), ++ round_up(resid, sector_size)); ++ scsi_set_resid(SCpnt, resid); ++ } + } + + if (result) { +diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c +index f03692ec5520..8fb309a0ff6b 100644 +--- a/drivers/usb/class/usbtmc.c ++++ b/drivers/usb/class/usbtmc.c +@@ -1381,7 +1381,7 @@ static int usbtmc_probe(struct usb_interface *intf, + + dev_dbg(&intf->dev, "%s called\n", __func__); + +- data = kmalloc(sizeof(*data), GFP_KERNEL); ++ data = kzalloc(sizeof(*data), GFP_KERNEL); + if (!data) + return -ENOMEM; + +@@ -1444,6 +1444,13 @@ static int usbtmc_probe(struct usb_interface *intf, + break; + } + } ++ ++ if (!data->bulk_out || !data->bulk_in) { ++ dev_err(&intf->dev, "bulk endpoints not found\n"); ++ retcode = -ENODEV; ++ goto err_put; ++ } ++ + /* Find int endpoint */ + for (n = 0; n < iface_desc->desc.bNumEndpoints; n++) { + endpoint = &iface_desc->endpoint[n].desc; +@@ -1469,8 +1476,10 @@ static int usbtmc_probe(struct usb_interface *intf, + if (data->iin_ep_present) { + /* allocate int urb */ + data->iin_urb = usb_alloc_urb(0, GFP_KERNEL); +- if (!data->iin_urb) ++ if (!data->iin_urb) { ++ retcode = -ENOMEM; + goto error_register; ++ } + + /* Protect interrupt in endpoint data until iin_urb is freed */ + kref_get(&data->kref); +@@ -1478,8 +1487,10 @@ static int usbtmc_probe(struct usb_interface *intf, + /* allocate buffer for interrupt in */ + data->iin_buffer = kmalloc(data->iin_wMaxPacketSize, + GFP_KERNEL); +- if (!data->iin_buffer) ++ if (!data->iin_buffer) { ++ retcode = -ENOMEM; + goto error_register; ++ } + + /* fill interrupt urb */ + usb_fill_int_urb(data->iin_urb, data->usb_dev, +@@ -1512,6 +1523,7 @@ static int usbtmc_probe(struct usb_interface *intf, + sysfs_remove_group(&intf->dev.kobj, &capability_attr_grp); + sysfs_remove_group(&intf->dev.kobj, &data_attr_grp); + usbtmc_free_int(data); ++err_put: + kref_put(&data->kref, usbtmc_delete); + return retcode; + } +diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c +index 25dbd8c7aec7..4be52c602e9b 100644 +--- a/drivers/usb/core/config.c ++++ b/drivers/usb/core/config.c +@@ -280,6 +280,16 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, + + /* + * Adjust bInterval for quirked devices. ++ */ ++ /* ++ * This quirk fixes bIntervals reported in ms. ++ */ ++ if (to_usb_device(ddev)->quirks & ++ USB_QUIRK_LINEAR_FRAME_INTR_BINTERVAL) { ++ n = clamp(fls(d->bInterval) + 3, i, j); ++ i = j = n; ++ } ++ /* + * This quirk fixes bIntervals reported in + * linear microframes. + */ +diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c +index a56c75e09786..48fbf523d186 100644 +--- a/drivers/usb/core/hub.c ++++ b/drivers/usb/core/hub.c +@@ -4275,7 +4275,7 @@ static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev) + struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + int connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN; + +- if (!udev->usb2_hw_lpm_capable) ++ if (!udev->usb2_hw_lpm_capable || !udev->bos) + return; + + if (hub) +diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c +index 24f9f98968a5..96b21b0dac1e 100644 +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -170,6 +170,14 @@ static const struct usb_device_id usb_quirk_list[] = { + /* M-Systems Flash Disk Pioneers */ + { USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME }, + ++ /* Baum Vario Ultra */ ++ { USB_DEVICE(0x0904, 0x6101), .driver_info = ++ USB_QUIRK_LINEAR_FRAME_INTR_BINTERVAL }, ++ { USB_DEVICE(0x0904, 0x6102), .driver_info = ++ USB_QUIRK_LINEAR_FRAME_INTR_BINTERVAL }, ++ { USB_DEVICE(0x0904, 0x6103), .driver_info = ++ USB_QUIRK_LINEAR_FRAME_INTR_BINTERVAL }, ++ + /* Keytouch QWERTY Panel keyboard */ + { USB_DEVICE(0x0926, 0x3333), .driver_info = + USB_QUIRK_CONFIG_INTF_STRINGS }, +diff --git a/drivers/usb/gadget/function/f_acm.c b/drivers/usb/gadget/function/f_acm.c +index a30766ca4226..5e3828d9dac7 100644 +--- a/drivers/usb/gadget/function/f_acm.c ++++ b/drivers/usb/gadget/function/f_acm.c +@@ -535,13 +535,15 @@ static int acm_notify_serial_state(struct f_acm *acm) + { + struct usb_composite_dev *cdev = acm->port.func.config->cdev; + int status; ++ __le16 serial_state; + + spin_lock(&acm->lock); + if (acm->notify_req) { + dev_dbg(&cdev->gadget->dev, "acm ttyGS%d serial state %04x\n", + acm->port_num, acm->serial_state); ++ serial_state = cpu_to_le16(acm->serial_state); + status = acm_cdc_notify(acm, USB_CDC_NOTIFY_SERIAL_STATE, +- 0, &acm->serial_state, sizeof(acm->serial_state)); ++ 0, &serial_state, sizeof(acm->serial_state)); + } else { + acm->pending = true; + status = 0; +diff --git a/drivers/usb/gadget/function/f_uvc.c b/drivers/usb/gadget/function/f_uvc.c +index 29b41b5dee04..c7689d05356c 100644 +--- a/drivers/usb/gadget/function/f_uvc.c ++++ b/drivers/usb/gadget/function/f_uvc.c +@@ -625,7 +625,7 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f) + uvc_ss_streaming_comp.bMaxBurst = opts->streaming_maxburst; + uvc_ss_streaming_comp.wBytesPerInterval = + cpu_to_le16(max_packet_size * max_packet_mult * +- opts->streaming_maxburst); ++ (opts->streaming_maxburst + 1)); + + /* Allocate endpoints. */ + ep = usb_ep_autoconfig(cdev->gadget, &uvc_control_ep); +diff --git a/drivers/usb/misc/idmouse.c b/drivers/usb/misc/idmouse.c +index debc1fd74b0d..dc9328fd8030 100644 +--- a/drivers/usb/misc/idmouse.c ++++ b/drivers/usb/misc/idmouse.c +@@ -346,6 +346,9 @@ static int idmouse_probe(struct usb_interface *interface, + if (iface_desc->desc.bInterfaceClass != 0x0A) + return -ENODEV; + ++ if (iface_desc->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + /* allocate memory for our device state and initialize it */ + dev = kzalloc(sizeof(*dev), GFP_KERNEL); + if (dev == NULL) +diff --git a/drivers/usb/misc/lvstest.c b/drivers/usb/misc/lvstest.c +index 77176511658f..d3d124753266 100644 +--- a/drivers/usb/misc/lvstest.c ++++ b/drivers/usb/misc/lvstest.c +@@ -366,6 +366,10 @@ static int lvs_rh_probe(struct usb_interface *intf, + + hdev = interface_to_usbdev(intf); + desc = intf->cur_altsetting; ++ ++ if (desc->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + endpoint = &desc->endpoint[0].desc; + + /* valid only for SS root hub */ +diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c +index 356d312add57..9ff66525924e 100644 +--- a/drivers/usb/misc/uss720.c ++++ b/drivers/usb/misc/uss720.c +@@ -708,6 +708,11 @@ static int uss720_probe(struct usb_interface *intf, + + interface = intf->cur_altsetting; + ++ if (interface->desc.bNumEndpoints < 3) { ++ usb_put_dev(usbdev); ++ return -ENODEV; ++ } ++ + /* + * Allocate parport interface + */ +diff --git a/drivers/usb/musb/musb_cppi41.c b/drivers/usb/musb/musb_cppi41.c +index 16363852c034..cac3b21a720b 100644 +--- a/drivers/usb/musb/musb_cppi41.c ++++ b/drivers/usb/musb/musb_cppi41.c +@@ -231,8 +231,27 @@ static void cppi41_dma_callback(void *private_data) + transferred < cppi41_channel->packet_sz) + cppi41_channel->prog_len = 0; + +- if (cppi41_channel->is_tx) +- empty = musb_is_tx_fifo_empty(hw_ep); ++ if (cppi41_channel->is_tx) { ++ u8 type; ++ ++ if (is_host_active(musb)) ++ type = hw_ep->out_qh->type; ++ else ++ type = hw_ep->ep_in.type; ++ ++ if (type == USB_ENDPOINT_XFER_ISOC) ++ /* ++ * Don't use the early-TX-interrupt workaround below ++ * for Isoch transfter. Since Isoch are periodic ++ * transfer, by the time the next transfer is ++ * scheduled, the current one should be done already. ++ * ++ * This avoids audio playback underrun issue. ++ */ ++ empty = true; ++ else ++ empty = musb_is_tx_fifo_empty(hw_ep); ++ } + + if (!cppi41_channel->is_tx || empty) { + cppi41_trans_done(cppi41_channel); +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index 42cc72e54c05..af67a0de6b5d 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -233,6 +233,14 @@ static void option_instat_callback(struct urb *urb); + #define BANDRICH_PRODUCT_1012 0x1012 + + #define QUALCOMM_VENDOR_ID 0x05C6 ++/* These Quectel products use Qualcomm's vendor ID */ ++#define QUECTEL_PRODUCT_UC20 0x9003 ++#define QUECTEL_PRODUCT_UC15 0x9090 ++ ++#define QUECTEL_VENDOR_ID 0x2c7c ++/* These Quectel products use Quectel's vendor ID */ ++#define QUECTEL_PRODUCT_EC21 0x0121 ++#define QUECTEL_PRODUCT_EC25 0x0125 + + #define CMOTECH_VENDOR_ID 0x16d8 + #define CMOTECH_PRODUCT_6001 0x6001 +@@ -1161,7 +1169,14 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */ + { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x0023)}, /* ONYX 3G device */ + { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x9000)}, /* SIMCom SIM5218 */ +- { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x9003), /* Quectel UC20 */ ++ /* Quectel products using Qualcomm vendor ID */ ++ { USB_DEVICE(QUALCOMM_VENDOR_ID, QUECTEL_PRODUCT_UC15)}, ++ { USB_DEVICE(QUALCOMM_VENDOR_ID, QUECTEL_PRODUCT_UC20), ++ .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, ++ /* Quectel products using Quectel vendor ID */ ++ { USB_DEVICE(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC21), ++ .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, ++ { USB_DEVICE(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC25), + .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, + { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6001) }, + { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_300) }, +diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c +index 696458db7e3c..38b3f0d8cd58 100644 +--- a/drivers/usb/serial/qcserial.c ++++ b/drivers/usb/serial/qcserial.c +@@ -169,6 +169,8 @@ static const struct usb_device_id id_table[] = { + {DEVICE_SWI(0x413c, 0x81a9)}, /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card */ + {DEVICE_SWI(0x413c, 0x81b1)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card */ + {DEVICE_SWI(0x413c, 0x81b3)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */ ++ {DEVICE_SWI(0x413c, 0x81b5)}, /* Dell Wireless 5811e QDL */ ++ {DEVICE_SWI(0x413c, 0x81b6)}, /* Dell Wireless 5811e QDL */ + + /* Huawei devices */ + {DEVICE_HWI(0x03f0, 0x581d)}, /* HP lt4112 LTE/HSPA+ Gobi 4G Modem (Huawei me906e) */ +diff --git a/drivers/usb/wusbcore/wa-hc.c b/drivers/usb/wusbcore/wa-hc.c +index 252c7bd9218a..d01496fd27fe 100644 +--- a/drivers/usb/wusbcore/wa-hc.c ++++ b/drivers/usb/wusbcore/wa-hc.c +@@ -39,6 +39,9 @@ int wa_create(struct wahc *wa, struct usb_interface *iface, + int result; + struct device *dev = &iface->dev; + ++ if (iface->cur_altsetting->desc.bNumEndpoints < 3) ++ return -ENODEV; ++ + result = wa_rpipes_create(wa); + if (result < 0) + goto error_rpipes_create; +diff --git a/drivers/uwb/hwa-rc.c b/drivers/uwb/hwa-rc.c +index 0aa6c3c29d17..35a1e777b449 100644 +--- a/drivers/uwb/hwa-rc.c ++++ b/drivers/uwb/hwa-rc.c +@@ -823,6 +823,9 @@ static int hwarc_probe(struct usb_interface *iface, + struct hwarc *hwarc; + struct device *dev = &iface->dev; + ++ if (iface->cur_altsetting->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + result = -ENOMEM; + uwb_rc = uwb_rc_alloc(); + if (uwb_rc == NULL) { +diff --git a/drivers/uwb/i1480/dfu/usb.c b/drivers/uwb/i1480/dfu/usb.c +index 2bfc846ac071..6345e85822a4 100644 +--- a/drivers/uwb/i1480/dfu/usb.c ++++ b/drivers/uwb/i1480/dfu/usb.c +@@ -362,6 +362,9 @@ int i1480_usb_probe(struct usb_interface *iface, const struct usb_device_id *id) + result); + } + ++ if (iface->cur_altsetting->desc.bNumEndpoints < 1) ++ return -ENODEV; ++ + result = -ENOMEM; + i1480_usb = kzalloc(sizeof(*i1480_usb), GFP_KERNEL); + if (i1480_usb == NULL) { +diff --git a/drivers/vfio/vfio.c b/drivers/vfio/vfio.c +index 9901c4671e2f..6e10325596b6 100644 +--- a/drivers/vfio/vfio.c ++++ b/drivers/vfio/vfio.c +@@ -403,6 +403,7 @@ static void vfio_group_release(struct kref *kref) + struct iommu_group *iommu_group = group->iommu_group; + + WARN_ON(!list_empty(&group->device_list)); ++ WARN_ON(group->notifier.head); + + list_for_each_entry_safe(unbound, tmp, + &group->unbound_list, unbound_next) { +@@ -1573,6 +1574,10 @@ static int vfio_group_fops_open(struct inode *inode, struct file *filep) + return -EBUSY; + } + ++ /* Warn if previous user didn't cleanup and re-init to drop them */ ++ if (WARN_ON(group->notifier.head)) ++ BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier); ++ + filep->private_data = group; + + return 0; +@@ -1584,9 +1589,6 @@ static int vfio_group_fops_release(struct inode *inode, struct file *filep) + + filep->private_data = NULL; + +- /* Any user didn't unregister? */ +- WARN_ON(group->notifier.head); +- + vfio_group_try_dissolve_container(group); + + atomic_dec(&group->opened); +diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c +index a44f5627b82a..f4daadff8a6c 100644 +--- a/drivers/video/console/fbcon.c ++++ b/drivers/video/console/fbcon.c +@@ -1165,6 +1165,8 @@ static void fbcon_free_font(struct display *p, bool freefont) + p->userfont = 0; + } + ++static void set_vc_hi_font(struct vc_data *vc, bool set); ++ + static void fbcon_deinit(struct vc_data *vc) + { + struct display *p = &fb_display[vc->vc_num]; +@@ -1200,6 +1202,9 @@ static void fbcon_deinit(struct vc_data *vc) + if (free_font) + vc->vc_font.data = NULL; + ++ if (vc->vc_hi_font_mask) ++ set_vc_hi_font(vc, false); ++ + if (!con_is_bound(&fb_con)) + fbcon_exit(); + +@@ -2436,32 +2441,10 @@ static int fbcon_get_font(struct vc_data *vc, struct console_font *font) + return 0; + } + +-static int fbcon_do_set_font(struct vc_data *vc, int w, int h, +- const u8 * data, int userfont) ++/* set/clear vc_hi_font_mask and update vc attrs accordingly */ ++static void set_vc_hi_font(struct vc_data *vc, bool set) + { +- struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]]; +- struct fbcon_ops *ops = info->fbcon_par; +- struct display *p = &fb_display[vc->vc_num]; +- int resize; +- int cnt; +- char *old_data = NULL; +- +- if (con_is_visible(vc) && softback_lines) +- fbcon_set_origin(vc); +- +- resize = (w != vc->vc_font.width) || (h != vc->vc_font.height); +- if (p->userfont) +- old_data = vc->vc_font.data; +- if (userfont) +- cnt = FNTCHARCNT(data); +- else +- cnt = 256; +- vc->vc_font.data = (void *)(p->fontdata = data); +- if ((p->userfont = userfont)) +- REFCOUNT(data)++; +- vc->vc_font.width = w; +- vc->vc_font.height = h; +- if (vc->vc_hi_font_mask && cnt == 256) { ++ if (!set) { + vc->vc_hi_font_mask = 0; + if (vc->vc_can_do_color) { + vc->vc_complement_mask >>= 1; +@@ -2484,7 +2467,7 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h, + ((c & 0xfe00) >> 1) | (c & 0xff); + vc->vc_attr >>= 1; + } +- } else if (!vc->vc_hi_font_mask && cnt == 512) { ++ } else { + vc->vc_hi_font_mask = 0x100; + if (vc->vc_can_do_color) { + vc->vc_complement_mask <<= 1; +@@ -2516,8 +2499,38 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h, + } else + vc->vc_video_erase_char = c & ~0x100; + } +- + } ++} ++ ++static int fbcon_do_set_font(struct vc_data *vc, int w, int h, ++ const u8 * data, int userfont) ++{ ++ struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]]; ++ struct fbcon_ops *ops = info->fbcon_par; ++ struct display *p = &fb_display[vc->vc_num]; ++ int resize; ++ int cnt; ++ char *old_data = NULL; ++ ++ if (con_is_visible(vc) && softback_lines) ++ fbcon_set_origin(vc); ++ ++ resize = (w != vc->vc_font.width) || (h != vc->vc_font.height); ++ if (p->userfont) ++ old_data = vc->vc_font.data; ++ if (userfont) ++ cnt = FNTCHARCNT(data); ++ else ++ cnt = 256; ++ vc->vc_font.data = (void *)(p->fontdata = data); ++ if ((p->userfont = userfont)) ++ REFCOUNT(data)++; ++ vc->vc_font.width = w; ++ vc->vc_font.height = h; ++ if (vc->vc_hi_font_mask && cnt == 256) ++ set_vc_hi_font(vc, false); ++ else if (!vc->vc_hi_font_mask && cnt == 512) ++ set_vc_hi_font(vc, true); + + if (resize) { + int cols, rows; +diff --git a/drivers/xen/xen-acpi-processor.c b/drivers/xen/xen-acpi-processor.c +index 4ce10bcca18b..4b857463a2b4 100644 +--- a/drivers/xen/xen-acpi-processor.c ++++ b/drivers/xen/xen-acpi-processor.c +@@ -27,10 +27,10 @@ + #include + #include + #include ++#include + #include + #include + #include +-#include + #include + #include + +@@ -466,15 +466,33 @@ static int xen_upload_processor_pm_data(void) + return rc; + } + +-static int xen_acpi_processor_resume(struct notifier_block *nb, +- unsigned long action, void *data) ++static void xen_acpi_processor_resume_worker(struct work_struct *dummy) + { ++ int rc; ++ + bitmap_zero(acpi_ids_done, nr_acpi_bits); +- return xen_upload_processor_pm_data(); ++ ++ rc = xen_upload_processor_pm_data(); ++ if (rc != 0) ++ pr_info("ACPI data upload failed, error = %d\n", rc); ++} ++ ++static void xen_acpi_processor_resume(void) ++{ ++ static DECLARE_WORK(wq, xen_acpi_processor_resume_worker); ++ ++ /* ++ * xen_upload_processor_pm_data() calls non-atomic code. ++ * However, the context for xen_acpi_processor_resume is syscore ++ * with only the boot CPU online and in an atomic context. ++ * ++ * So defer the upload for some point safer. ++ */ ++ schedule_work(&wq); + } + +-struct notifier_block xen_acpi_processor_resume_nb = { +- .notifier_call = xen_acpi_processor_resume, ++static struct syscore_ops xap_syscore_ops = { ++ .resume = xen_acpi_processor_resume, + }; + + static int __init xen_acpi_processor_init(void) +@@ -527,7 +545,7 @@ static int __init xen_acpi_processor_init(void) + if (rc) + goto err_unregister; + +- xen_resume_notifier_register(&xen_acpi_processor_resume_nb); ++ register_syscore_ops(&xap_syscore_ops); + + return 0; + err_unregister: +@@ -544,7 +562,7 @@ static void __exit xen_acpi_processor_exit(void) + { + int i; + +- xen_resume_notifier_unregister(&xen_acpi_processor_resume_nb); ++ unregister_syscore_ops(&xap_syscore_ops); + kfree(acpi_ids_done); + kfree(acpi_id_present); + kfree(acpi_id_cst_present); +diff --git a/fs/crypto/crypto.c b/fs/crypto/crypto.c +index ac8e4f6a3773..3c2ca312c251 100644 +--- a/fs/crypto/crypto.c ++++ b/fs/crypto/crypto.c +@@ -394,7 +394,6 @@ EXPORT_SYMBOL(fscrypt_zeroout_range); + static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags) + { + struct dentry *dir; +- struct fscrypt_info *ci; + int dir_has_key, cached_with_key; + + if (flags & LOOKUP_RCU) +@@ -406,18 +405,11 @@ static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags) + return 0; + } + +- ci = d_inode(dir)->i_crypt_info; +- if (ci && ci->ci_keyring_key && +- (ci->ci_keyring_key->flags & ((1 << KEY_FLAG_INVALIDATED) | +- (1 << KEY_FLAG_REVOKED) | +- (1 << KEY_FLAG_DEAD)))) +- ci = NULL; +- + /* this should eventually be an flag in d_flags */ + spin_lock(&dentry->d_lock); + cached_with_key = dentry->d_flags & DCACHE_ENCRYPTED_WITH_KEY; + spin_unlock(&dentry->d_lock); +- dir_has_key = (ci != NULL); ++ dir_has_key = (d_inode(dir)->i_crypt_info != NULL); + dput(dir); + + /* +diff --git a/fs/crypto/fname.c b/fs/crypto/fname.c +index 56ad9d195f18..8af4d5224bdd 100644 +--- a/fs/crypto/fname.c ++++ b/fs/crypto/fname.c +@@ -350,7 +350,7 @@ int fscrypt_setup_filename(struct inode *dir, const struct qstr *iname, + fname->disk_name.len = iname->len; + return 0; + } +- ret = fscrypt_get_crypt_info(dir); ++ ret = fscrypt_get_encryption_info(dir); + if (ret && ret != -EOPNOTSUPP) + return ret; + +diff --git a/fs/crypto/fscrypt_private.h b/fs/crypto/fscrypt_private.h +index aeab032d7d35..b7b9b566bd86 100644 +--- a/fs/crypto/fscrypt_private.h ++++ b/fs/crypto/fscrypt_private.h +@@ -67,7 +67,6 @@ struct fscrypt_info { + u8 ci_filename_mode; + u8 ci_flags; + struct crypto_skcipher *ci_ctfm; +- struct key *ci_keyring_key; + u8 ci_master_key[FS_KEY_DESCRIPTOR_SIZE]; + }; + +@@ -87,7 +86,4 @@ struct fscrypt_completion_result { + /* crypto.c */ + int fscrypt_initialize(unsigned int cop_flags); + +-/* keyinfo.c */ +-extern int fscrypt_get_crypt_info(struct inode *); +- + #endif /* _FSCRYPT_PRIVATE_H */ +diff --git a/fs/crypto/keyinfo.c b/fs/crypto/keyinfo.c +index 95cd4c3b06c3..6df6ad3af432 100644 +--- a/fs/crypto/keyinfo.c ++++ b/fs/crypto/keyinfo.c +@@ -99,6 +99,7 @@ static int validate_user_key(struct fscrypt_info *crypt_info, + kfree(full_key_descriptor); + if (IS_ERR(keyring_key)) + return PTR_ERR(keyring_key); ++ down_read(&keyring_key->sem); + + if (keyring_key->type != &key_type_logon) { + printk_once(KERN_WARNING +@@ -106,11 +107,9 @@ static int validate_user_key(struct fscrypt_info *crypt_info, + res = -ENOKEY; + goto out; + } +- down_read(&keyring_key->sem); + ukp = user_key_payload(keyring_key); + if (ukp->datalen != sizeof(struct fscrypt_key)) { + res = -EINVAL; +- up_read(&keyring_key->sem); + goto out; + } + master_key = (struct fscrypt_key *)ukp->data; +@@ -121,17 +120,11 @@ static int validate_user_key(struct fscrypt_info *crypt_info, + "%s: key size incorrect: %d\n", + __func__, master_key->size); + res = -ENOKEY; +- up_read(&keyring_key->sem); + goto out; + } + res = derive_key_aes(ctx->nonce, master_key->raw, raw_key); +- up_read(&keyring_key->sem); +- if (res) +- goto out; +- +- crypt_info->ci_keyring_key = keyring_key; +- return 0; + out: ++ up_read(&keyring_key->sem); + key_put(keyring_key); + return res; + } +@@ -173,12 +166,11 @@ static void put_crypt_info(struct fscrypt_info *ci) + if (!ci) + return; + +- key_put(ci->ci_keyring_key); + crypto_free_skcipher(ci->ci_ctfm); + kmem_cache_free(fscrypt_info_cachep, ci); + } + +-int fscrypt_get_crypt_info(struct inode *inode) ++int fscrypt_get_encryption_info(struct inode *inode) + { + struct fscrypt_info *crypt_info; + struct fscrypt_context ctx; +@@ -188,21 +180,15 @@ int fscrypt_get_crypt_info(struct inode *inode) + u8 *raw_key = NULL; + int res; + ++ if (inode->i_crypt_info) ++ return 0; ++ + res = fscrypt_initialize(inode->i_sb->s_cop->flags); + if (res) + return res; + + if (!inode->i_sb->s_cop->get_context) + return -EOPNOTSUPP; +-retry: +- crypt_info = ACCESS_ONCE(inode->i_crypt_info); +- if (crypt_info) { +- if (!crypt_info->ci_keyring_key || +- key_validate(crypt_info->ci_keyring_key) == 0) +- return 0; +- fscrypt_put_encryption_info(inode, crypt_info); +- goto retry; +- } + + res = inode->i_sb->s_cop->get_context(inode, &ctx, sizeof(ctx)); + if (res < 0) { +@@ -230,7 +216,6 @@ int fscrypt_get_crypt_info(struct inode *inode) + crypt_info->ci_data_mode = ctx.contents_encryption_mode; + crypt_info->ci_filename_mode = ctx.filenames_encryption_mode; + crypt_info->ci_ctfm = NULL; +- crypt_info->ci_keyring_key = NULL; + memcpy(crypt_info->ci_master_key, ctx.master_key_descriptor, + sizeof(crypt_info->ci_master_key)); + +@@ -286,14 +271,8 @@ int fscrypt_get_crypt_info(struct inode *inode) + if (res) + goto out; + +- kzfree(raw_key); +- raw_key = NULL; +- if (cmpxchg(&inode->i_crypt_info, NULL, crypt_info) != NULL) { +- put_crypt_info(crypt_info); +- goto retry; +- } +- return 0; +- ++ if (cmpxchg(&inode->i_crypt_info, NULL, crypt_info) == NULL) ++ crypt_info = NULL; + out: + if (res == -ENOKEY) + res = 0; +@@ -301,6 +280,7 @@ int fscrypt_get_crypt_info(struct inode *inode) + kzfree(raw_key); + return res; + } ++EXPORT_SYMBOL(fscrypt_get_encryption_info); + + void fscrypt_put_encryption_info(struct inode *inode, struct fscrypt_info *ci) + { +@@ -318,17 +298,3 @@ void fscrypt_put_encryption_info(struct inode *inode, struct fscrypt_info *ci) + put_crypt_info(ci); + } + EXPORT_SYMBOL(fscrypt_put_encryption_info); +- +-int fscrypt_get_encryption_info(struct inode *inode) +-{ +- struct fscrypt_info *ci = inode->i_crypt_info; +- +- if (!ci || +- (ci->ci_keyring_key && +- (ci->ci_keyring_key->flags & ((1 << KEY_FLAG_INVALIDATED) | +- (1 << KEY_FLAG_REVOKED) | +- (1 << KEY_FLAG_DEAD))))) +- return fscrypt_get_crypt_info(inode); +- return 0; +-} +-EXPORT_SYMBOL(fscrypt_get_encryption_info); +diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c +index 627ace344739..b6a38ecbca00 100644 +--- a/fs/ext4/inline.c ++++ b/fs/ext4/inline.c +@@ -1167,10 +1167,9 @@ static int ext4_finish_convert_inline_dir(handle_t *handle, + set_buffer_uptodate(dir_block); + err = ext4_handle_dirty_dirent_node(handle, inode, dir_block); + if (err) +- goto out; ++ return err; + set_buffer_verified(dir_block); +-out: +- return err; ++ return ext4_mark_inode_dirty(handle, inode); + } + + static int ext4_convert_inline_data_nolock(handle_t *handle, +diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c +index c40bd55b6400..7b5a683defe6 100644 +--- a/fs/ext4/xattr.c ++++ b/fs/ext4/xattr.c +@@ -131,31 +131,26 @@ static __le32 ext4_xattr_block_csum(struct inode *inode, + } + + static int ext4_xattr_block_csum_verify(struct inode *inode, +- sector_t block_nr, +- struct ext4_xattr_header *hdr) ++ struct buffer_head *bh) + { +- if (ext4_has_metadata_csum(inode->i_sb) && +- (hdr->h_checksum != ext4_xattr_block_csum(inode, block_nr, hdr))) +- return 0; +- return 1; +-} +- +-static void ext4_xattr_block_csum_set(struct inode *inode, +- sector_t block_nr, +- struct ext4_xattr_header *hdr) +-{ +- if (!ext4_has_metadata_csum(inode->i_sb)) +- return; ++ struct ext4_xattr_header *hdr = BHDR(bh); ++ int ret = 1; + +- hdr->h_checksum = ext4_xattr_block_csum(inode, block_nr, hdr); ++ if (ext4_has_metadata_csum(inode->i_sb)) { ++ lock_buffer(bh); ++ ret = (hdr->h_checksum == ext4_xattr_block_csum(inode, ++ bh->b_blocknr, hdr)); ++ unlock_buffer(bh); ++ } ++ return ret; + } + +-static inline int ext4_handle_dirty_xattr_block(handle_t *handle, +- struct inode *inode, +- struct buffer_head *bh) ++static void ext4_xattr_block_csum_set(struct inode *inode, ++ struct buffer_head *bh) + { +- ext4_xattr_block_csum_set(inode, bh->b_blocknr, BHDR(bh)); +- return ext4_handle_dirty_metadata(handle, inode, bh); ++ if (ext4_has_metadata_csum(inode->i_sb)) ++ BHDR(bh)->h_checksum = ext4_xattr_block_csum(inode, ++ bh->b_blocknr, BHDR(bh)); + } + + static inline const struct xattr_handler * +@@ -233,7 +228,7 @@ ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh) + if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) || + BHDR(bh)->h_blocks != cpu_to_le32(1)) + return -EFSCORRUPTED; +- if (!ext4_xattr_block_csum_verify(inode, bh->b_blocknr, BHDR(bh))) ++ if (!ext4_xattr_block_csum_verify(inode, bh)) + return -EFSBADCRC; + error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size, + bh->b_data); +@@ -615,23 +610,22 @@ ext4_xattr_release_block(handle_t *handle, struct inode *inode, + } + } + ++ ext4_xattr_block_csum_set(inode, bh); + /* + * Beware of this ugliness: Releasing of xattr block references + * from different inodes can race and so we have to protect + * from a race where someone else frees the block (and releases + * its journal_head) before we are done dirtying the buffer. In + * nojournal mode this race is harmless and we actually cannot +- * call ext4_handle_dirty_xattr_block() with locked buffer as ++ * call ext4_handle_dirty_metadata() with locked buffer as + * that function can call sync_dirty_buffer() so for that case + * we handle the dirtying after unlocking the buffer. + */ + if (ext4_handle_valid(handle)) +- error = ext4_handle_dirty_xattr_block(handle, inode, +- bh); ++ error = ext4_handle_dirty_metadata(handle, inode, bh); + unlock_buffer(bh); + if (!ext4_handle_valid(handle)) +- error = ext4_handle_dirty_xattr_block(handle, inode, +- bh); ++ error = ext4_handle_dirty_metadata(handle, inode, bh); + if (IS_SYNC(inode)) + ext4_handle_sync(handle); + dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1)); +@@ -860,13 +854,14 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode, + ext4_xattr_cache_insert(ext4_mb_cache, + bs->bh); + } ++ ext4_xattr_block_csum_set(inode, bs->bh); + unlock_buffer(bs->bh); + if (error == -EFSCORRUPTED) + goto bad_block; + if (!error) +- error = ext4_handle_dirty_xattr_block(handle, +- inode, +- bs->bh); ++ error = ext4_handle_dirty_metadata(handle, ++ inode, ++ bs->bh); + if (error) + goto cleanup; + goto inserted; +@@ -964,10 +959,11 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode, + ce->e_reusable = 0; + ea_bdebug(new_bh, "reusing; refcount now=%d", + ref); ++ ext4_xattr_block_csum_set(inode, new_bh); + unlock_buffer(new_bh); +- error = ext4_handle_dirty_xattr_block(handle, +- inode, +- new_bh); ++ error = ext4_handle_dirty_metadata(handle, ++ inode, ++ new_bh); + if (error) + goto cleanup_dquot; + } +@@ -1017,11 +1013,12 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode, + goto getblk_failed; + } + memcpy(new_bh->b_data, s->base, new_bh->b_size); ++ ext4_xattr_block_csum_set(inode, new_bh); + set_buffer_uptodate(new_bh); + unlock_buffer(new_bh); + ext4_xattr_cache_insert(ext4_mb_cache, new_bh); +- error = ext4_handle_dirty_xattr_block(handle, +- inode, new_bh); ++ error = ext4_handle_dirty_metadata(handle, inode, ++ new_bh); + if (error) + goto cleanup; + } +diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c +index a097048ed1a3..bdc3afad4a8c 100644 +--- a/fs/jbd2/journal.c ++++ b/fs/jbd2/journal.c +@@ -1125,10 +1125,8 @@ static journal_t *journal_init_common(struct block_device *bdev, + + /* Set up a default-sized revoke table for the new mount. */ + err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH); +- if (err) { +- kfree(journal); +- return NULL; +- } ++ if (err) ++ goto err_cleanup; + + spin_lock_init(&journal->j_history_lock); + +@@ -1145,23 +1143,25 @@ static journal_t *journal_init_common(struct block_device *bdev, + journal->j_wbufsize = n; + journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *), + GFP_KERNEL); +- if (!journal->j_wbuf) { +- kfree(journal); +- return NULL; +- } ++ if (!journal->j_wbuf) ++ goto err_cleanup; + + bh = getblk_unmovable(journal->j_dev, start, journal->j_blocksize); + if (!bh) { + pr_err("%s: Cannot get buffer for journal superblock\n", + __func__); +- kfree(journal->j_wbuf); +- kfree(journal); +- return NULL; ++ goto err_cleanup; + } + journal->j_sb_buffer = bh; + journal->j_superblock = (journal_superblock_t *)bh->b_data; + + return journal; ++ ++err_cleanup: ++ kfree(journal->j_wbuf); ++ jbd2_journal_destroy_revoke(journal); ++ kfree(journal); ++ return NULL; + } + + /* jbd2_journal_init_dev and jbd2_journal_init_inode: +diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c +index cfc38b552118..f9aefcda5854 100644 +--- a/fs/jbd2/revoke.c ++++ b/fs/jbd2/revoke.c +@@ -280,6 +280,7 @@ int jbd2_journal_init_revoke(journal_t *journal, int hash_size) + + fail1: + jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]); ++ journal->j_revoke_table[0] = NULL; + fail0: + return -ENOMEM; + } +diff --git a/include/drm/drmP.h b/include/drm/drmP.h +index 9c4ee144b5f6..1871ca60e079 100644 +--- a/include/drm/drmP.h ++++ b/include/drm/drmP.h +@@ -360,6 +360,7 @@ struct drm_ioctl_desc { + /* Event queued up for userspace to read */ + struct drm_pending_event { + struct completion *completion; ++ void (*completion_release)(struct completion *completion); + struct drm_event *event; + struct dma_fence *fence; + struct list_head link; +diff --git a/include/linux/ccp.h b/include/linux/ccp.h +index c71dd8fa5764..c41b8d99dd0e 100644 +--- a/include/linux/ccp.h ++++ b/include/linux/ccp.h +@@ -556,7 +556,7 @@ enum ccp_engine { + * struct ccp_cmd - CCP operation request + * @entry: list element (ccp driver use only) + * @work: work element used for callbacks (ccp driver use only) +- * @ccp: CCP device to be run on (ccp driver use only) ++ * @ccp: CCP device to be run on + * @ret: operation return code (ccp driver use only) + * @flags: cmd processing flags + * @engine: CCP operation to perform +diff --git a/include/linux/iio/sw_device.h b/include/linux/iio/sw_device.h +index 23ca41515527..fa7931933067 100644 +--- a/include/linux/iio/sw_device.h ++++ b/include/linux/iio/sw_device.h +@@ -62,7 +62,7 @@ void iio_swd_group_init_type_name(struct iio_sw_device *d, + const char *name, + struct config_item_type *type) + { +-#ifdef CONFIG_CONFIGFS_FS ++#if IS_ENABLED(CONFIG_CONFIGFS_FS) + config_group_init_type_name(&d->group, name, type); + #endif + } +diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h +index 27914672602d..bdef8b7d4305 100644 +--- a/include/linux/netdevice.h ++++ b/include/linux/netdevice.h +@@ -330,6 +330,7 @@ struct napi_struct { + + enum { + NAPI_STATE_SCHED, /* Poll is scheduled */ ++ NAPI_STATE_MISSED, /* reschedule a napi */ + NAPI_STATE_DISABLE, /* Disable pending */ + NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */ + NAPI_STATE_HASHED, /* In NAPI hash (busy polling possible) */ +@@ -338,12 +339,13 @@ enum { + }; + + enum { +- NAPIF_STATE_SCHED = (1UL << NAPI_STATE_SCHED), +- NAPIF_STATE_DISABLE = (1UL << NAPI_STATE_DISABLE), +- NAPIF_STATE_NPSVC = (1UL << NAPI_STATE_NPSVC), +- NAPIF_STATE_HASHED = (1UL << NAPI_STATE_HASHED), +- NAPIF_STATE_NO_BUSY_POLL = (1UL << NAPI_STATE_NO_BUSY_POLL), +- NAPIF_STATE_IN_BUSY_POLL = (1UL << NAPI_STATE_IN_BUSY_POLL), ++ NAPIF_STATE_SCHED = BIT(NAPI_STATE_SCHED), ++ NAPIF_STATE_MISSED = BIT(NAPI_STATE_MISSED), ++ NAPIF_STATE_DISABLE = BIT(NAPI_STATE_DISABLE), ++ NAPIF_STATE_NPSVC = BIT(NAPI_STATE_NPSVC), ++ NAPIF_STATE_HASHED = BIT(NAPI_STATE_HASHED), ++ NAPIF_STATE_NO_BUSY_POLL = BIT(NAPI_STATE_NO_BUSY_POLL), ++ NAPIF_STATE_IN_BUSY_POLL = BIT(NAPI_STATE_IN_BUSY_POLL), + }; + + enum gro_result { +@@ -413,20 +415,7 @@ static inline bool napi_disable_pending(struct napi_struct *n) + return test_bit(NAPI_STATE_DISABLE, &n->state); + } + +-/** +- * napi_schedule_prep - check if NAPI can be scheduled +- * @n: NAPI context +- * +- * Test if NAPI routine is already running, and if not mark +- * it as running. This is used as a condition variable to +- * insure only one NAPI poll instance runs. We also make +- * sure there is no pending NAPI disable. +- */ +-static inline bool napi_schedule_prep(struct napi_struct *n) +-{ +- return !napi_disable_pending(n) && +- !test_and_set_bit(NAPI_STATE_SCHED, &n->state); +-} ++bool napi_schedule_prep(struct napi_struct *n); + + /** + * napi_schedule - schedule NAPI poll +diff --git a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h +index 1d0043dc34e4..de2a722fe3cf 100644 +--- a/include/linux/usb/quirks.h ++++ b/include/linux/usb/quirks.h +@@ -50,4 +50,10 @@ + /* device can't handle Link Power Management */ + #define USB_QUIRK_NO_LPM BIT(10) + ++/* ++ * Device reports its bInterval as linear frames instead of the ++ * USB 2.0 calculation. ++ */ ++#define USB_QUIRK_LINEAR_FRAME_INTR_BINTERVAL BIT(11) ++ + #endif /* __LINUX_USB_QUIRKS_H */ +diff --git a/kernel/audit.c b/kernel/audit.c +index 6e399bb69d7c..ba4481d20fa1 100644 +--- a/kernel/audit.c ++++ b/kernel/audit.c +@@ -54,6 +54,10 @@ + #include + #include + #include ++#include ++#include ++#include ++#include + + #include + +@@ -90,13 +94,34 @@ static u32 audit_default; + /* If auditing cannot proceed, audit_failure selects what happens. */ + static u32 audit_failure = AUDIT_FAIL_PRINTK; + +-/* +- * If audit records are to be written to the netlink socket, audit_pid +- * contains the pid of the auditd process and audit_nlk_portid contains +- * the portid to use to send netlink messages to that process. ++/* private audit network namespace index */ ++static unsigned int audit_net_id; ++ ++/** ++ * struct audit_net - audit private network namespace data ++ * @sk: communication socket ++ */ ++struct audit_net { ++ struct sock *sk; ++}; ++ ++/** ++ * struct auditd_connection - kernel/auditd connection state ++ * @pid: auditd PID ++ * @portid: netlink portid ++ * @net: the associated network namespace ++ * @lock: spinlock to protect write access ++ * ++ * Description: ++ * This struct is RCU protected; you must either hold the RCU lock for reading ++ * or the included spinlock for writing. + */ +-int audit_pid; +-static __u32 audit_nlk_portid; ++static struct auditd_connection { ++ int pid; ++ u32 portid; ++ struct net *net; ++ spinlock_t lock; ++} auditd_conn; + + /* If audit_rate_limit is non-zero, limit the rate of sending audit records + * to that number per second. This prevents DoS attacks, but results in +@@ -123,10 +148,6 @@ u32 audit_sig_sid = 0; + */ + static atomic_t audit_lost = ATOMIC_INIT(0); + +-/* The netlink socket. */ +-static struct sock *audit_sock; +-static unsigned int audit_net_id; +- + /* Hash for inode-based rules */ + struct list_head audit_inode_hash[AUDIT_INODE_BUCKETS]; + +@@ -139,6 +160,7 @@ static LIST_HEAD(audit_freelist); + + /* queue msgs to send via kauditd_task */ + static struct sk_buff_head audit_queue; ++static void kauditd_hold_skb(struct sk_buff *skb); + /* queue msgs due to temporary unicast send problems */ + static struct sk_buff_head audit_retry_queue; + /* queue msgs waiting for new auditd connection */ +@@ -192,6 +214,43 @@ struct audit_reply { + struct sk_buff *skb; + }; + ++/** ++ * auditd_test_task - Check to see if a given task is an audit daemon ++ * @task: the task to check ++ * ++ * Description: ++ * Return 1 if the task is a registered audit daemon, 0 otherwise. ++ */ ++int auditd_test_task(const struct task_struct *task) ++{ ++ int rc; ++ ++ rcu_read_lock(); ++ rc = (auditd_conn.pid && task->tgid == auditd_conn.pid ? 1 : 0); ++ rcu_read_unlock(); ++ ++ return rc; ++} ++ ++/** ++ * audit_get_sk - Return the audit socket for the given network namespace ++ * @net: the destination network namespace ++ * ++ * Description: ++ * Returns the sock pointer if valid, NULL otherwise. The caller must ensure ++ * that a reference is held for the network namespace while the sock is in use. ++ */ ++static struct sock *audit_get_sk(const struct net *net) ++{ ++ struct audit_net *aunet; ++ ++ if (!net) ++ return NULL; ++ ++ aunet = net_generic(net, audit_net_id); ++ return aunet->sk; ++} ++ + static void audit_set_portid(struct audit_buffer *ab, __u32 portid) + { + if (ab) { +@@ -210,9 +269,7 @@ void audit_panic(const char *message) + pr_err("%s\n", message); + break; + case AUDIT_FAIL_PANIC: +- /* test audit_pid since printk is always losey, why bother? */ +- if (audit_pid) +- panic("audit: %s\n", message); ++ panic("audit: %s\n", message); + break; + } + } +@@ -370,21 +427,87 @@ static int audit_set_failure(u32 state) + return audit_do_config_change("audit_failure", &audit_failure, state); + } + +-/* +- * For one reason or another this nlh isn't getting delivered to the userspace +- * audit daemon, just send it to printk. ++/** ++ * auditd_set - Set/Reset the auditd connection state ++ * @pid: auditd PID ++ * @portid: auditd netlink portid ++ * @net: auditd network namespace pointer ++ * ++ * Description: ++ * This function will obtain and drop network namespace references as ++ * necessary. ++ */ ++static void auditd_set(int pid, u32 portid, struct net *net) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&auditd_conn.lock, flags); ++ auditd_conn.pid = pid; ++ auditd_conn.portid = portid; ++ if (auditd_conn.net) ++ put_net(auditd_conn.net); ++ if (net) ++ auditd_conn.net = get_net(net); ++ else ++ auditd_conn.net = NULL; ++ spin_unlock_irqrestore(&auditd_conn.lock, flags); ++} ++ ++/** ++ * auditd_reset - Disconnect the auditd connection ++ * ++ * Description: ++ * Break the auditd/kauditd connection and move all the queued records into the ++ * hold queue in case auditd reconnects. ++ */ ++static void auditd_reset(void) ++{ ++ struct sk_buff *skb; ++ ++ /* if it isn't already broken, break the connection */ ++ rcu_read_lock(); ++ if (auditd_conn.pid) ++ auditd_set(0, 0, NULL); ++ rcu_read_unlock(); ++ ++ /* flush all of the main and retry queues to the hold queue */ ++ while ((skb = skb_dequeue(&audit_retry_queue))) ++ kauditd_hold_skb(skb); ++ while ((skb = skb_dequeue(&audit_queue))) ++ kauditd_hold_skb(skb); ++} ++ ++/** ++ * kauditd_print_skb - Print the audit record to the ring buffer ++ * @skb: audit record ++ * ++ * Whatever the reason, this packet may not make it to the auditd connection ++ * so write it via printk so the information isn't completely lost. + */ + static void kauditd_printk_skb(struct sk_buff *skb) + { + struct nlmsghdr *nlh = nlmsg_hdr(skb); + char *data = nlmsg_data(nlh); + +- if (nlh->nlmsg_type != AUDIT_EOE) { +- if (printk_ratelimit()) +- pr_notice("type=%d %s\n", nlh->nlmsg_type, data); +- else +- audit_log_lost("printk limit exceeded"); +- } ++ if (nlh->nlmsg_type != AUDIT_EOE && printk_ratelimit()) ++ pr_notice("type=%d %s\n", nlh->nlmsg_type, data); ++} ++ ++/** ++ * kauditd_rehold_skb - Handle a audit record send failure in the hold queue ++ * @skb: audit record ++ * ++ * Description: ++ * This should only be used by the kauditd_thread when it fails to flush the ++ * hold queue. ++ */ ++static void kauditd_rehold_skb(struct sk_buff *skb) ++{ ++ /* put the record back in the queue at the same place */ ++ skb_queue_head(&audit_hold_queue, skb); ++ ++ /* fail the auditd connection */ ++ auditd_reset(); + } + + /** +@@ -421,6 +544,9 @@ static void kauditd_hold_skb(struct sk_buff *skb) + /* we have no other options - drop the message */ + audit_log_lost("kauditd hold queue overflow"); + kfree_skb(skb); ++ ++ /* fail the auditd connection */ ++ auditd_reset(); + } + + /** +@@ -441,51 +567,122 @@ static void kauditd_retry_skb(struct sk_buff *skb) + } + + /** +- * auditd_reset - Disconnect the auditd connection ++ * auditd_send_unicast_skb - Send a record via unicast to auditd ++ * @skb: audit record + * + * Description: +- * Break the auditd/kauditd connection and move all the records in the retry +- * queue into the hold queue in case auditd reconnects. The audit_cmd_mutex +- * must be held when calling this function. ++ * Send a skb to the audit daemon, returns positive/zero values on success and ++ * negative values on failure; in all cases the skb will be consumed by this ++ * function. If the send results in -ECONNREFUSED the connection with auditd ++ * will be reset. This function may sleep so callers should not hold any locks ++ * where this would cause a problem. + */ +-static void auditd_reset(void) ++static int auditd_send_unicast_skb(struct sk_buff *skb) + { +- struct sk_buff *skb; +- +- /* break the connection */ +- if (audit_sock) { +- sock_put(audit_sock); +- audit_sock = NULL; ++ int rc; ++ u32 portid; ++ struct net *net; ++ struct sock *sk; ++ ++ /* NOTE: we can't call netlink_unicast while in the RCU section so ++ * take a reference to the network namespace and grab local ++ * copies of the namespace, the sock, and the portid; the ++ * namespace and sock aren't going to go away while we hold a ++ * reference and if the portid does become invalid after the RCU ++ * section netlink_unicast() should safely return an error */ ++ ++ rcu_read_lock(); ++ if (!auditd_conn.pid) { ++ rcu_read_unlock(); ++ rc = -ECONNREFUSED; ++ goto err; + } +- audit_pid = 0; +- audit_nlk_portid = 0; ++ net = auditd_conn.net; ++ get_net(net); ++ sk = audit_get_sk(net); ++ portid = auditd_conn.portid; ++ rcu_read_unlock(); + +- /* flush all of the retry queue to the hold queue */ +- while ((skb = skb_dequeue(&audit_retry_queue))) +- kauditd_hold_skb(skb); ++ rc = netlink_unicast(sk, skb, portid, 0); ++ put_net(net); ++ if (rc < 0) ++ goto err; ++ ++ return rc; ++ ++err: ++ if (rc == -ECONNREFUSED) ++ auditd_reset(); ++ return rc; + } + + /** +- * kauditd_send_unicast_skb - Send a record via unicast to auditd +- * @skb: audit record ++ * kauditd_send_queue - Helper for kauditd_thread to flush skb queues ++ * @sk: the sending sock ++ * @portid: the netlink destination ++ * @queue: the skb queue to process ++ * @retry_limit: limit on number of netlink unicast failures ++ * @skb_hook: per-skb hook for additional processing ++ * @err_hook: hook called if the skb fails the netlink unicast send ++ * ++ * Description: ++ * Run through the given queue and attempt to send the audit records to auditd, ++ * returns zero on success, negative values on failure. It is up to the caller ++ * to ensure that the @sk is valid for the duration of this function. ++ * + */ +-static int kauditd_send_unicast_skb(struct sk_buff *skb) ++static int kauditd_send_queue(struct sock *sk, u32 portid, ++ struct sk_buff_head *queue, ++ unsigned int retry_limit, ++ void (*skb_hook)(struct sk_buff *skb), ++ void (*err_hook)(struct sk_buff *skb)) + { +- int rc; ++ int rc = 0; ++ struct sk_buff *skb; ++ static unsigned int failed = 0; + +- /* if we know nothing is connected, don't even try the netlink call */ +- if (!audit_pid) +- return -ECONNREFUSED; ++ /* NOTE: kauditd_thread takes care of all our locking, we just use ++ * the netlink info passed to us (e.g. sk and portid) */ ++ ++ while ((skb = skb_dequeue(queue))) { ++ /* call the skb_hook for each skb we touch */ ++ if (skb_hook) ++ (*skb_hook)(skb); ++ ++ /* can we send to anyone via unicast? */ ++ if (!sk) { ++ if (err_hook) ++ (*err_hook)(skb); ++ continue; ++ } + +- /* get an extra skb reference in case we fail to send */ +- skb_get(skb); +- rc = netlink_unicast(audit_sock, skb, audit_nlk_portid, 0); +- if (rc >= 0) { +- consume_skb(skb); +- rc = 0; ++ /* grab an extra skb reference in case of error */ ++ skb_get(skb); ++ rc = netlink_unicast(sk, skb, portid, 0); ++ if (rc < 0) { ++ /* fatal failure for our queue flush attempt? */ ++ if (++failed >= retry_limit || ++ rc == -ECONNREFUSED || rc == -EPERM) { ++ /* yes - error processing for the queue */ ++ sk = NULL; ++ if (err_hook) ++ (*err_hook)(skb); ++ if (!skb_hook) ++ goto out; ++ /* keep processing with the skb_hook */ ++ continue; ++ } else ++ /* no - requeue to preserve ordering */ ++ skb_queue_head(queue, skb); ++ } else { ++ /* it worked - drop the extra reference and continue */ ++ consume_skb(skb); ++ failed = 0; ++ } + } + +- return rc; ++out: ++ return (rc >= 0 ? 0 : rc); + } + + /* +@@ -493,16 +690,19 @@ static int kauditd_send_unicast_skb(struct sk_buff *skb) + * @skb: audit record + * + * Description: +- * This function doesn't consume an skb as might be expected since it has to +- * copy it anyways. ++ * Write a multicast message to anyone listening in the initial network ++ * namespace. This function doesn't consume an skb as might be expected since ++ * it has to copy it anyways. + */ + static void kauditd_send_multicast_skb(struct sk_buff *skb) + { + struct sk_buff *copy; +- struct audit_net *aunet = net_generic(&init_net, audit_net_id); +- struct sock *sock = aunet->nlsk; ++ struct sock *sock = audit_get_sk(&init_net); + struct nlmsghdr *nlh; + ++ /* NOTE: we are not taking an additional reference for init_net since ++ * we don't have to worry about it going away */ ++ + if (!netlink_has_listeners(sock, AUDIT_NLGRP_READLOG)) + return; + +@@ -526,149 +726,75 @@ static void kauditd_send_multicast_skb(struct sk_buff *skb) + } + + /** +- * kauditd_wake_condition - Return true when it is time to wake kauditd_thread +- * +- * Description: +- * This function is for use by the wait_event_freezable() call in +- * kauditd_thread(). ++ * kauditd_thread - Worker thread to send audit records to userspace ++ * @dummy: unused + */ +-static int kauditd_wake_condition(void) +-{ +- static int pid_last = 0; +- int rc; +- int pid = audit_pid; +- +- /* wake on new messages or a change in the connected auditd */ +- rc = skb_queue_len(&audit_queue) || (pid && pid != pid_last); +- if (rc) +- pid_last = pid; +- +- return rc; +-} +- + static int kauditd_thread(void *dummy) + { + int rc; +- int auditd = 0; +- int reschedule = 0; +- struct sk_buff *skb; +- struct nlmsghdr *nlh; ++ u32 portid = 0; ++ struct net *net = NULL; ++ struct sock *sk = NULL; + + #define UNICAST_RETRIES 5 +-#define AUDITD_BAD(x,y) \ +- ((x) == -ECONNREFUSED || (x) == -EPERM || ++(y) >= UNICAST_RETRIES) +- +- /* NOTE: we do invalidate the auditd connection flag on any sending +- * errors, but we only "restore" the connection flag at specific places +- * in the loop in order to help ensure proper ordering of audit +- * records */ + + set_freezable(); + while (!kthread_should_stop()) { +- /* NOTE: possible area for future improvement is to look at +- * the hold and retry queues, since only this thread +- * has access to these queues we might be able to do +- * our own queuing and skip some/all of the locking */ +- +- /* NOTE: it might be a fun experiment to split the hold and +- * retry queue handling to another thread, but the +- * synchronization issues and other overhead might kill +- * any performance gains */ ++ /* NOTE: see the lock comments in auditd_send_unicast_skb() */ ++ rcu_read_lock(); ++ if (!auditd_conn.pid) { ++ rcu_read_unlock(); ++ goto main_queue; ++ } ++ net = auditd_conn.net; ++ get_net(net); ++ sk = audit_get_sk(net); ++ portid = auditd_conn.portid; ++ rcu_read_unlock(); + + /* attempt to flush the hold queue */ +- while (auditd && (skb = skb_dequeue(&audit_hold_queue))) { +- rc = kauditd_send_unicast_skb(skb); +- if (rc) { +- /* requeue to the same spot */ +- skb_queue_head(&audit_hold_queue, skb); +- +- auditd = 0; +- if (AUDITD_BAD(rc, reschedule)) { +- mutex_lock(&audit_cmd_mutex); +- auditd_reset(); +- mutex_unlock(&audit_cmd_mutex); +- reschedule = 0; +- } +- } else +- /* we were able to send successfully */ +- reschedule = 0; ++ rc = kauditd_send_queue(sk, portid, ++ &audit_hold_queue, UNICAST_RETRIES, ++ NULL, kauditd_rehold_skb); ++ if (rc < 0) { ++ sk = NULL; ++ goto main_queue; + } + + /* attempt to flush the retry queue */ +- while (auditd && (skb = skb_dequeue(&audit_retry_queue))) { +- rc = kauditd_send_unicast_skb(skb); +- if (rc) { +- auditd = 0; +- if (AUDITD_BAD(rc, reschedule)) { +- kauditd_hold_skb(skb); +- mutex_lock(&audit_cmd_mutex); +- auditd_reset(); +- mutex_unlock(&audit_cmd_mutex); +- reschedule = 0; +- } else +- /* temporary problem (we hope), queue +- * to the same spot and retry */ +- skb_queue_head(&audit_retry_queue, skb); +- } else +- /* we were able to send successfully */ +- reschedule = 0; ++ rc = kauditd_send_queue(sk, portid, ++ &audit_retry_queue, UNICAST_RETRIES, ++ NULL, kauditd_hold_skb); ++ if (rc < 0) { ++ sk = NULL; ++ goto main_queue; + } + +- /* standard queue processing, try to be as quick as possible */ +-quick_loop: +- skb = skb_dequeue(&audit_queue); +- if (skb) { +- /* setup the netlink header, see the comments in +- * kauditd_send_multicast_skb() for length quirks */ +- nlh = nlmsg_hdr(skb); +- nlh->nlmsg_len = skb->len - NLMSG_HDRLEN; +- +- /* attempt to send to any multicast listeners */ +- kauditd_send_multicast_skb(skb); +- +- /* attempt to send to auditd, queue on failure */ +- if (auditd) { +- rc = kauditd_send_unicast_skb(skb); +- if (rc) { +- auditd = 0; +- if (AUDITD_BAD(rc, reschedule)) { +- mutex_lock(&audit_cmd_mutex); +- auditd_reset(); +- mutex_unlock(&audit_cmd_mutex); +- reschedule = 0; +- } +- +- /* move to the retry queue */ +- kauditd_retry_skb(skb); +- } else +- /* everything is working so go fast! */ +- goto quick_loop; +- } else if (reschedule) +- /* we are currently having problems, move to +- * the retry queue */ +- kauditd_retry_skb(skb); +- else +- /* dump the message via printk and hold it */ +- kauditd_hold_skb(skb); +- } else { +- /* we have flushed the backlog so wake everyone */ +- wake_up(&audit_backlog_wait); +- +- /* if everything is okay with auditd (if present), go +- * to sleep until there is something new in the queue +- * or we have a change in the connected auditd; +- * otherwise simply reschedule to give things a chance +- * to recover */ +- if (reschedule) { +- set_current_state(TASK_INTERRUPTIBLE); +- schedule(); +- } else +- wait_event_freezable(kauditd_wait, +- kauditd_wake_condition()); +- +- /* update the auditd connection status */ +- auditd = (audit_pid ? 1 : 0); ++main_queue: ++ /* process the main queue - do the multicast send and attempt ++ * unicast, dump failed record sends to the retry queue; if ++ * sk == NULL due to previous failures we will just do the ++ * multicast send and move the record to the retry queue */ ++ kauditd_send_queue(sk, portid, &audit_queue, 1, ++ kauditd_send_multicast_skb, ++ kauditd_retry_skb); ++ ++ /* drop our netns reference, no auditd sends past this line */ ++ if (net) { ++ put_net(net); ++ net = NULL; + } ++ sk = NULL; ++ ++ /* we have processed all the queues so wake everyone */ ++ wake_up(&audit_backlog_wait); ++ ++ /* NOTE: we want to wake up if there is anything on the queue, ++ * regardless of if an auditd is connected, as we need to ++ * do the multicast send and rotate records from the ++ * main queue to the retry/hold queues */ ++ wait_event_freezable(kauditd_wait, ++ (skb_queue_len(&audit_queue) ? 1 : 0)); + } + + return 0; +@@ -678,17 +804,16 @@ int audit_send_list(void *_dest) + { + struct audit_netlink_list *dest = _dest; + struct sk_buff *skb; +- struct net *net = dest->net; +- struct audit_net *aunet = net_generic(net, audit_net_id); ++ struct sock *sk = audit_get_sk(dest->net); + + /* wait for parent to finish and send an ACK */ + mutex_lock(&audit_cmd_mutex); + mutex_unlock(&audit_cmd_mutex); + + while ((skb = __skb_dequeue(&dest->q)) != NULL) +- netlink_unicast(aunet->nlsk, skb, dest->portid, 0); ++ netlink_unicast(sk, skb, dest->portid, 0); + +- put_net(net); ++ put_net(dest->net); + kfree(dest); + + return 0; +@@ -722,16 +847,15 @@ struct sk_buff *audit_make_reply(__u32 portid, int seq, int type, int done, + static int audit_send_reply_thread(void *arg) + { + struct audit_reply *reply = (struct audit_reply *)arg; +- struct net *net = reply->net; +- struct audit_net *aunet = net_generic(net, audit_net_id); ++ struct sock *sk = audit_get_sk(reply->net); + + mutex_lock(&audit_cmd_mutex); + mutex_unlock(&audit_cmd_mutex); + + /* Ignore failure. It'll only happen if the sender goes away, + because our timeout is set to infinite. */ +- netlink_unicast(aunet->nlsk , reply->skb, reply->portid, 0); +- put_net(net); ++ netlink_unicast(sk, reply->skb, reply->portid, 0); ++ put_net(reply->net); + kfree(reply); + return 0; + } +@@ -949,12 +1073,12 @@ static int audit_set_feature(struct sk_buff *skb) + + static int audit_replace(pid_t pid) + { +- struct sk_buff *skb = audit_make_reply(0, 0, AUDIT_REPLACE, 0, 0, +- &pid, sizeof(pid)); ++ struct sk_buff *skb; + ++ skb = audit_make_reply(0, 0, AUDIT_REPLACE, 0, 0, &pid, sizeof(pid)); + if (!skb) + return -ENOMEM; +- return netlink_unicast(audit_sock, skb, audit_nlk_portid, 0); ++ return auditd_send_unicast_skb(skb); + } + + static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh) +@@ -981,7 +1105,9 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh) + memset(&s, 0, sizeof(s)); + s.enabled = audit_enabled; + s.failure = audit_failure; +- s.pid = audit_pid; ++ rcu_read_lock(); ++ s.pid = auditd_conn.pid; ++ rcu_read_unlock(); + s.rate_limit = audit_rate_limit; + s.backlog_limit = audit_backlog_limit; + s.lost = atomic_read(&audit_lost); +@@ -1014,30 +1140,44 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh) + * from the initial pid namespace, but something + * to keep in mind if this changes */ + int new_pid = s.pid; ++ pid_t auditd_pid; + pid_t requesting_pid = task_tgid_vnr(current); + +- if ((!new_pid) && (requesting_pid != audit_pid)) { +- audit_log_config_change("audit_pid", new_pid, audit_pid, 0); ++ /* test the auditd connection */ ++ audit_replace(requesting_pid); ++ ++ rcu_read_lock(); ++ auditd_pid = auditd_conn.pid; ++ /* only the current auditd can unregister itself */ ++ if ((!new_pid) && (requesting_pid != auditd_pid)) { ++ rcu_read_unlock(); ++ audit_log_config_change("audit_pid", new_pid, ++ auditd_pid, 0); + return -EACCES; + } +- if (audit_pid && new_pid && +- audit_replace(requesting_pid) != -ECONNREFUSED) { +- audit_log_config_change("audit_pid", new_pid, audit_pid, 0); ++ /* replacing a healthy auditd is not allowed */ ++ if (auditd_pid && new_pid) { ++ rcu_read_unlock(); ++ audit_log_config_change("audit_pid", new_pid, ++ auditd_pid, 0); + return -EEXIST; + } ++ rcu_read_unlock(); ++ + if (audit_enabled != AUDIT_OFF) +- audit_log_config_change("audit_pid", new_pid, audit_pid, 1); ++ audit_log_config_change("audit_pid", new_pid, ++ auditd_pid, 1); ++ + if (new_pid) { +- if (audit_sock) +- sock_put(audit_sock); +- audit_pid = new_pid; +- audit_nlk_portid = NETLINK_CB(skb).portid; +- sock_hold(skb->sk); +- audit_sock = skb->sk; +- } else { ++ /* register a new auditd connection */ ++ auditd_set(new_pid, ++ NETLINK_CB(skb).portid, ++ sock_net(NETLINK_CB(skb).sk)); ++ /* try to process any backlog */ ++ wake_up_interruptible(&kauditd_wait); ++ } else ++ /* unregister the auditd connection */ + auditd_reset(); +- } +- wake_up_interruptible(&kauditd_wait); + } + if (s.mask & AUDIT_STATUS_RATE_LIMIT) { + err = audit_set_rate_limit(s.rate_limit); +@@ -1084,7 +1224,6 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh) + if (err) + break; + } +- mutex_unlock(&audit_cmd_mutex); + audit_log_common_recv_msg(&ab, msg_type); + if (msg_type != AUDIT_USER_TTY) + audit_log_format(ab, " msg='%.*s'", +@@ -1102,7 +1241,6 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh) + } + audit_set_portid(ab, NETLINK_CB(skb).portid); + audit_log_end(ab); +- mutex_lock(&audit_cmd_mutex); + } + break; + case AUDIT_ADD_RULE: +@@ -1292,26 +1430,26 @@ static int __net_init audit_net_init(struct net *net) + + struct audit_net *aunet = net_generic(net, audit_net_id); + +- aunet->nlsk = netlink_kernel_create(net, NETLINK_AUDIT, &cfg); +- if (aunet->nlsk == NULL) { ++ aunet->sk = netlink_kernel_create(net, NETLINK_AUDIT, &cfg); ++ if (aunet->sk == NULL) { + audit_panic("cannot initialize netlink socket in namespace"); + return -ENOMEM; + } +- aunet->nlsk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT; ++ aunet->sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT; ++ + return 0; + } + + static void __net_exit audit_net_exit(struct net *net) + { + struct audit_net *aunet = net_generic(net, audit_net_id); +- struct sock *sock = aunet->nlsk; +- mutex_lock(&audit_cmd_mutex); +- if (sock == audit_sock) ++ ++ rcu_read_lock(); ++ if (net == auditd_conn.net) + auditd_reset(); +- mutex_unlock(&audit_cmd_mutex); ++ rcu_read_unlock(); + +- netlink_kernel_release(sock); +- aunet->nlsk = NULL; ++ netlink_kernel_release(aunet->sk); + } + + static struct pernet_operations audit_net_ops __net_initdata = { +@@ -1329,20 +1467,24 @@ static int __init audit_init(void) + if (audit_initialized == AUDIT_DISABLED) + return 0; + +- pr_info("initializing netlink subsys (%s)\n", +- audit_default ? "enabled" : "disabled"); +- register_pernet_subsys(&audit_net_ops); ++ memset(&auditd_conn, 0, sizeof(auditd_conn)); ++ spin_lock_init(&auditd_conn.lock); + + skb_queue_head_init(&audit_queue); + skb_queue_head_init(&audit_retry_queue); + skb_queue_head_init(&audit_hold_queue); +- audit_initialized = AUDIT_INITIALIZED; +- audit_enabled = audit_default; +- audit_ever_enabled |= !!audit_default; + + for (i = 0; i < AUDIT_INODE_BUCKETS; i++) + INIT_LIST_HEAD(&audit_inode_hash[i]); + ++ pr_info("initializing netlink subsys (%s)\n", ++ audit_default ? "enabled" : "disabled"); ++ register_pernet_subsys(&audit_net_ops); ++ ++ audit_initialized = AUDIT_INITIALIZED; ++ audit_enabled = audit_default; ++ audit_ever_enabled |= !!audit_default; ++ + kauditd_task = kthread_run(kauditd_thread, NULL, "kauditd"); + if (IS_ERR(kauditd_task)) { + int err = PTR_ERR(kauditd_task); +@@ -1511,20 +1653,16 @@ struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask, + if (unlikely(!audit_filter(type, AUDIT_FILTER_TYPE))) + return NULL; + +- /* don't ever fail/sleep on these two conditions: ++ /* NOTE: don't ever fail/sleep on these two conditions: + * 1. auditd generated record - since we need auditd to drain the + * queue; also, when we are checking for auditd, compare PIDs using + * task_tgid_vnr() since auditd_pid is set in audit_receive_msg() + * using a PID anchored in the caller's namespace +- * 2. audit command message - record types 1000 through 1099 inclusive +- * are command messages/records used to manage the kernel subsystem +- * and the audit userspace, blocking on these messages could cause +- * problems under load so don't do it (note: not all of these +- * command types are valid as record types, but it is quicker to +- * just check two ints than a series of ints in a if/switch stmt) */ +- if (!((audit_pid && audit_pid == task_tgid_vnr(current)) || +- (type >= 1000 && type <= 1099))) { +- long sleep_time = audit_backlog_wait_time; ++ * 2. generator holding the audit_cmd_mutex - we don't want to block ++ * while holding the mutex */ ++ if (!(auditd_test_task(current) || ++ (current == __mutex_owner(&audit_cmd_mutex)))) { ++ long stime = audit_backlog_wait_time; + + while (audit_backlog_limit && + (skb_queue_len(&audit_queue) > audit_backlog_limit)) { +@@ -1533,14 +1671,13 @@ struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask, + + /* sleep if we are allowed and we haven't exhausted our + * backlog wait limit */ +- if ((gfp_mask & __GFP_DIRECT_RECLAIM) && +- (sleep_time > 0)) { ++ if (gfpflags_allow_blocking(gfp_mask) && (stime > 0)) { + DECLARE_WAITQUEUE(wait, current); + + add_wait_queue_exclusive(&audit_backlog_wait, + &wait); + set_current_state(TASK_UNINTERRUPTIBLE); +- sleep_time = schedule_timeout(sleep_time); ++ stime = schedule_timeout(stime); + remove_wait_queue(&audit_backlog_wait, &wait); + } else { + if (audit_rate_check() && printk_ratelimit()) +@@ -2119,15 +2256,27 @@ void audit_log_link_denied(const char *operation, const struct path *link) + */ + void audit_log_end(struct audit_buffer *ab) + { ++ struct sk_buff *skb; ++ struct nlmsghdr *nlh; ++ + if (!ab) + return; +- if (!audit_rate_check()) { +- audit_log_lost("rate limit exceeded"); +- } else { +- skb_queue_tail(&audit_queue, ab->skb); +- wake_up_interruptible(&kauditd_wait); ++ ++ if (audit_rate_check()) { ++ skb = ab->skb; + ab->skb = NULL; +- } ++ ++ /* setup the netlink header, see the comments in ++ * kauditd_send_multicast_skb() for length quirks */ ++ nlh = nlmsg_hdr(skb); ++ nlh->nlmsg_len = skb->len - NLMSG_HDRLEN; ++ ++ /* queue the netlink packet and poke the kauditd thread */ ++ skb_queue_tail(&audit_queue, skb); ++ wake_up_interruptible(&kauditd_wait); ++ } else ++ audit_log_lost("rate limit exceeded"); ++ + audit_buffer_free(ab); + } + +diff --git a/kernel/audit.h b/kernel/audit.h +index 960d49c9db5e..c6fba919b2e4 100644 +--- a/kernel/audit.h ++++ b/kernel/audit.h +@@ -215,7 +215,7 @@ extern void audit_log_name(struct audit_context *context, + struct audit_names *n, const struct path *path, + int record_num, int *call_panic); + +-extern int audit_pid; ++extern int auditd_test_task(const struct task_struct *task); + + #define AUDIT_INODE_BUCKETS 32 + extern struct list_head audit_inode_hash[AUDIT_INODE_BUCKETS]; +@@ -247,10 +247,6 @@ struct audit_netlink_list { + + int audit_send_list(void *); + +-struct audit_net { +- struct sock *nlsk; +-}; +- + extern int selinux_audit_rule_update(void); + + extern struct mutex audit_filter_mutex; +@@ -337,8 +333,7 @@ extern int audit_filter(int msgtype, unsigned int listtype); + extern int __audit_signal_info(int sig, struct task_struct *t); + static inline int audit_signal_info(int sig, struct task_struct *t) + { +- if (unlikely((audit_pid && t->tgid == audit_pid) || +- (audit_signals && !audit_dummy_context()))) ++ if (auditd_test_task(t) || (audit_signals && !audit_dummy_context())) + return __audit_signal_info(sig, t); + return 0; + } +diff --git a/kernel/auditsc.c b/kernel/auditsc.c +index cf1fa43512c1..9e69c3a6b732 100644 +--- a/kernel/auditsc.c ++++ b/kernel/auditsc.c +@@ -762,7 +762,7 @@ static enum audit_state audit_filter_syscall(struct task_struct *tsk, + struct audit_entry *e; + enum audit_state state; + +- if (audit_pid && tsk->tgid == audit_pid) ++ if (auditd_test_task(tsk)) + return AUDIT_DISABLED; + + rcu_read_lock(); +@@ -816,7 +816,7 @@ void audit_filter_inodes(struct task_struct *tsk, struct audit_context *ctx) + { + struct audit_names *n; + +- if (audit_pid && tsk->tgid == audit_pid) ++ if (auditd_test_task(tsk)) + return; + + rcu_read_lock(); +@@ -2251,7 +2251,7 @@ int __audit_signal_info(int sig, struct task_struct *t) + struct audit_context *ctx = tsk->audit_context; + kuid_t uid = current_uid(), t_uid = task_uid(t); + +- if (audit_pid && t->tgid == audit_pid) { ++ if (auditd_test_task(t)) { + if (sig == SIGTERM || sig == SIGHUP || sig == SIGUSR1 || sig == SIGUSR2) { + audit_sig_pid = task_tgid_nr(tsk); + if (uid_valid(tsk->loginuid)) +diff --git a/net/ceph/osdmap.c b/net/ceph/osdmap.c +index d2436880b305..d3f6c26425b3 100644 +--- a/net/ceph/osdmap.c ++++ b/net/ceph/osdmap.c +@@ -1334,7 +1334,6 @@ static int decode_new_up_state_weight(void **p, void *end, + if ((map->osd_state[osd] & CEPH_OSD_EXISTS) && + (xorstate & CEPH_OSD_EXISTS)) { + pr_info("osd%d does not exist\n", osd); +- map->osd_weight[osd] = CEPH_OSD_IN; + ret = set_primary_affinity(map, osd, + CEPH_OSD_DEFAULT_PRIMARY_AFFINITY); + if (ret) +diff --git a/net/core/dev.c b/net/core/dev.c +index fd6e2dfda45f..54f8c162ded8 100644 +--- a/net/core/dev.c ++++ b/net/core/dev.c +@@ -4913,6 +4913,39 @@ void __napi_schedule(struct napi_struct *n) + EXPORT_SYMBOL(__napi_schedule); + + /** ++ * napi_schedule_prep - check if napi can be scheduled ++ * @n: napi context ++ * ++ * Test if NAPI routine is already running, and if not mark ++ * it as running. This is used as a condition variable ++ * insure only one NAPI poll instance runs. We also make ++ * sure there is no pending NAPI disable. ++ */ ++bool napi_schedule_prep(struct napi_struct *n) ++{ ++ unsigned long val, new; ++ ++ do { ++ val = READ_ONCE(n->state); ++ if (unlikely(val & NAPIF_STATE_DISABLE)) ++ return false; ++ new = val | NAPIF_STATE_SCHED; ++ ++ /* Sets STATE_MISSED bit if STATE_SCHED was already set ++ * This was suggested by Alexander Duyck, as compiler ++ * emits better code than : ++ * if (val & NAPIF_STATE_SCHED) ++ * new |= NAPIF_STATE_MISSED; ++ */ ++ new |= (val & NAPIF_STATE_SCHED) / NAPIF_STATE_SCHED * ++ NAPIF_STATE_MISSED; ++ } while (cmpxchg(&n->state, val, new) != val); ++ ++ return !(val & NAPIF_STATE_SCHED); ++} ++EXPORT_SYMBOL(napi_schedule_prep); ++ ++/** + * __napi_schedule_irqoff - schedule for receive + * @n: entry to schedule + * +@@ -4943,7 +4976,7 @@ EXPORT_SYMBOL(__napi_complete); + + bool napi_complete_done(struct napi_struct *n, int work_done) + { +- unsigned long flags; ++ unsigned long flags, val, new; + + /* + * 1) Don't let napi dequeue from the cpu poll list +@@ -4967,14 +5000,33 @@ bool napi_complete_done(struct napi_struct *n, int work_done) + else + napi_gro_flush(n, false); + } +- if (likely(list_empty(&n->poll_list))) { +- WARN_ON_ONCE(!test_and_clear_bit(NAPI_STATE_SCHED, &n->state)); +- } else { ++ if (unlikely(!list_empty(&n->poll_list))) { + /* If n->poll_list is not empty, we need to mask irqs */ + local_irq_save(flags); +- __napi_complete(n); ++ list_del_init(&n->poll_list); + local_irq_restore(flags); + } ++ ++ do { ++ val = READ_ONCE(n->state); ++ ++ WARN_ON_ONCE(!(val & NAPIF_STATE_SCHED)); ++ ++ new = val & ~(NAPIF_STATE_MISSED | NAPIF_STATE_SCHED); ++ ++ /* If STATE_MISSED was set, leave STATE_SCHED set, ++ * because we will call napi->poll() one more time. ++ * This C code was suggested by Alexander Duyck to help gcc. ++ */ ++ new |= (val & NAPIF_STATE_MISSED) / NAPIF_STATE_MISSED * ++ NAPIF_STATE_SCHED; ++ } while (cmpxchg(&n->state, val, new) != val); ++ ++ if (unlikely(val & NAPIF_STATE_MISSED)) { ++ __napi_schedule(n); ++ return false; ++ } ++ + return true; + } + EXPORT_SYMBOL(napi_complete_done); +@@ -5000,6 +5052,16 @@ static void busy_poll_stop(struct napi_struct *napi, void *have_poll_lock) + { + int rc; + ++ /* Busy polling means there is a high chance device driver hard irq ++ * could not grab NAPI_STATE_SCHED, and that NAPI_STATE_MISSED was ++ * set in napi_schedule_prep(). ++ * Since we are about to call napi->poll() once more, we can safely ++ * clear NAPI_STATE_MISSED. ++ * ++ * Note: x86 could use a single "lock and ..." instruction ++ * to perform these two clear_bit() ++ */ ++ clear_bit(NAPI_STATE_MISSED, &napi->state); + clear_bit(NAPI_STATE_IN_BUSY_POLL, &napi->state); + + local_bh_disable(); +@@ -5146,8 +5208,13 @@ static enum hrtimer_restart napi_watchdog(struct hrtimer *timer) + struct napi_struct *napi; + + napi = container_of(timer, struct napi_struct, timer); +- if (napi->gro_list) +- napi_schedule(napi); ++ ++ /* Note : we use a relaxed variant of napi_schedule_prep() not setting ++ * NAPI_STATE_MISSED, since we do not react to a device IRQ. ++ */ ++ if (napi->gro_list && !napi_disable_pending(napi) && ++ !test_and_set_bit(NAPI_STATE_SCHED, &napi->state)) ++ __napi_schedule_irqoff(napi); + + return HRTIMER_NORESTART; + } +diff --git a/net/core/netclassid_cgroup.c b/net/core/netclassid_cgroup.c +index 11fce17274f6..46e8830c1979 100644 +--- a/net/core/netclassid_cgroup.c ++++ b/net/core/netclassid_cgroup.c +@@ -69,27 +69,17 @@ static int update_classid_sock(const void *v, struct file *file, unsigned n) + return 0; + } + +-static void update_classid(struct cgroup_subsys_state *css, void *v) ++static void cgrp_attach(struct cgroup_taskset *tset) + { +- struct css_task_iter it; ++ struct cgroup_subsys_state *css; + struct task_struct *p; + +- css_task_iter_start(css, &it); +- while ((p = css_task_iter_next(&it))) { ++ cgroup_taskset_for_each(p, css, tset) { + task_lock(p); +- iterate_fd(p->files, 0, update_classid_sock, v); ++ iterate_fd(p->files, 0, update_classid_sock, ++ (void *)(unsigned long)css_cls_state(css)->classid); + task_unlock(p); + } +- css_task_iter_end(&it); +-} +- +-static void cgrp_attach(struct cgroup_taskset *tset) +-{ +- struct cgroup_subsys_state *css; +- +- cgroup_taskset_first(tset, &css); +- update_classid(css, +- (void *)(unsigned long)css_cls_state(css)->classid); + } + + static u64 read_classid(struct cgroup_subsys_state *css, struct cftype *cft) +@@ -101,12 +91,22 @@ static int write_classid(struct cgroup_subsys_state *css, struct cftype *cft, + u64 value) + { + struct cgroup_cls_state *cs = css_cls_state(css); ++ struct css_task_iter it; ++ struct task_struct *p; + + cgroup_sk_alloc_disable(); + + cs->classid = (u32)value; + +- update_classid(css, (void *)(unsigned long)cs->classid); ++ css_task_iter_start(css, &it); ++ while ((p = css_task_iter_next(&it))) { ++ task_lock(p); ++ iterate_fd(p->files, 0, update_classid_sock, ++ (void *)(unsigned long)cs->classid); ++ task_unlock(p); ++ } ++ css_task_iter_end(&it); ++ + return 0; + } + +diff --git a/net/core/sock.c b/net/core/sock.c +index 4eca27dc5c94..4e7f10c92666 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -1444,6 +1444,11 @@ static void __sk_destruct(struct rcu_head *head) + pr_debug("%s: optmem leakage (%d bytes) detected\n", + __func__, atomic_read(&sk->sk_omem_alloc)); + ++ if (sk->sk_frag.page) { ++ put_page(sk->sk_frag.page); ++ sk->sk_frag.page = NULL; ++ } ++ + if (sk->sk_peer_cred) + put_cred(sk->sk_peer_cred); + put_pid(sk->sk_peer_pid); +@@ -1540,6 +1545,12 @@ struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority) + is_charged = sk_filter_charge(newsk, filter); + + if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk, sk))) { ++ /* We need to make sure that we don't uncharge the new ++ * socket if we couldn't charge it in the first place ++ * as otherwise we uncharge the parent's filter. ++ */ ++ if (!is_charged) ++ RCU_INIT_POINTER(newsk->sk_filter, NULL); + /* It is still raw copy of parent, so invalidate + * destructor and make plain sk_free() */ + newsk->sk_destruct = NULL; +@@ -2774,11 +2785,6 @@ void sk_common_release(struct sock *sk) + + sk_refcnt_debug_release(sk); + +- if (sk->sk_frag.page) { +- put_page(sk->sk_frag.page); +- sk->sk_frag.page = NULL; +- } +- + sock_put(sk); + } + EXPORT_SYMBOL(sk_common_release); +diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c +index b39a791f6756..091de0b93d5d 100644 +--- a/net/ipv4/fib_frontend.c ++++ b/net/ipv4/fib_frontend.c +@@ -1082,7 +1082,8 @@ static void nl_fib_input(struct sk_buff *skb) + + net = sock_net(skb->sk); + nlh = nlmsg_hdr(skb); +- if (skb->len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len || ++ if (skb->len < nlmsg_total_size(sizeof(*frn)) || ++ skb->len < nlh->nlmsg_len || + nlmsg_len(nlh) < sizeof(*frn)) + return; + +diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c +index 28777a0307c8..e7516efa99dc 100644 +--- a/net/ipv4/tcp_input.c ++++ b/net/ipv4/tcp_input.c +@@ -5571,6 +5571,7 @@ void tcp_finish_connect(struct sock *sk, struct sk_buff *skb) + struct inet_connection_sock *icsk = inet_csk(sk); + + tcp_set_state(sk, TCP_ESTABLISHED); ++ icsk->icsk_ack.lrcvtime = tcp_time_stamp; + + if (skb) { + icsk->icsk_af_ops->sk_rx_dst_set(sk, skb); +@@ -5789,7 +5790,6 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, + * to stand against the temptation 8) --ANK + */ + inet_csk_schedule_ack(sk); +- icsk->icsk_ack.lrcvtime = tcp_time_stamp; + tcp_enter_quickack_mode(sk); + inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, + TCP_DELACK_MAX, TCP_RTO_MAX); +diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c +index 28ce5ee831f5..80ff517a7542 100644 +--- a/net/ipv4/tcp_minisocks.c ++++ b/net/ipv4/tcp_minisocks.c +@@ -466,6 +466,7 @@ struct sock *tcp_create_openreq_child(const struct sock *sk, + newtp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT); + minmax_reset(&newtp->rtt_min, tcp_time_stamp, ~0U); + newicsk->icsk_rto = TCP_TIMEOUT_INIT; ++ newicsk->icsk_ack.lrcvtime = tcp_time_stamp; + + newtp->packets_out = 0; + newtp->retrans_out = 0; +diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c +index 221825a9407a..0770f95f5e1c 100644 +--- a/net/ipv6/udp.c ++++ b/net/ipv6/udp.c +@@ -1022,6 +1022,7 @@ int udpv6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) + ipc6.hlimit = -1; + ipc6.tclass = -1; + ipc6.dontfrag = -1; ++ sockc.tsflags = sk->sk_tsflags; + + /* destination address check */ + if (sin6) { +@@ -1146,7 +1147,6 @@ int udpv6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) + + fl6.flowi6_mark = sk->sk_mark; + fl6.flowi6_uid = sk->sk_uid; +- sockc.tsflags = sk->sk_tsflags; + + if (msg->msg_controllen) { + opt = &opt_space; +diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c +index fb6e10fdb217..92e0981f7404 100644 +--- a/net/netlink/genetlink.c ++++ b/net/netlink/genetlink.c +@@ -783,8 +783,10 @@ static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb) + + if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid, + cb->nlh->nlmsg_seq, NLM_F_MULTI, +- skb, CTRL_CMD_NEWFAMILY) < 0) ++ skb, CTRL_CMD_NEWFAMILY) < 0) { ++ n--; + break; ++ } + } + + cb->args[0] = n; +diff --git a/net/openvswitch/flow_netlink.c b/net/openvswitch/flow_netlink.c +index c87d359b9b37..256e8f1450fd 100644 +--- a/net/openvswitch/flow_netlink.c ++++ b/net/openvswitch/flow_netlink.c +@@ -588,7 +588,7 @@ static int ip_tun_from_nlattr(const struct nlattr *attr, + ipv4 = true; + break; + case OVS_TUNNEL_KEY_ATTR_IPV6_SRC: +- SW_FLOW_KEY_PUT(match, tun_key.u.ipv6.dst, ++ SW_FLOW_KEY_PUT(match, tun_key.u.ipv6.src, + nla_get_in6_addr(a), is_mask); + ipv6 = true; + break; +@@ -649,6 +649,8 @@ static int ip_tun_from_nlattr(const struct nlattr *attr, + tun_flags |= TUNNEL_VXLAN_OPT; + opts_type = type; + break; ++ case OVS_TUNNEL_KEY_ATTR_PAD: ++ break; + default: + OVS_NLERR(log, "Unknown IP tunnel attribute %d", + type); +diff --git a/net/unix/garbage.c b/net/unix/garbage.c +index 6a0d48525fcf..c36757e72844 100644 +--- a/net/unix/garbage.c ++++ b/net/unix/garbage.c +@@ -146,6 +146,7 @@ void unix_notinflight(struct user_struct *user, struct file *fp) + if (s) { + struct unix_sock *u = unix_sk(s); + ++ BUG_ON(!atomic_long_read(&u->inflight)); + BUG_ON(list_empty(&u->link)); + + if (atomic_long_dec_and_test(&u->inflight)) +@@ -341,6 +342,14 @@ void unix_gc(void) + } + list_del(&cursor); + ++ /* Now gc_candidates contains only garbage. Restore original ++ * inflight counters for these as well, and remove the skbuffs ++ * which are creating the cycle(s). ++ */ ++ skb_queue_head_init(&hitlist); ++ list_for_each_entry(u, &gc_candidates, link) ++ scan_children(&u->sk, inc_inflight, &hitlist); ++ + /* not_cycle_list contains those sockets which do not make up a + * cycle. Restore these to the inflight list. + */ +@@ -350,14 +359,6 @@ void unix_gc(void) + list_move_tail(&u->link, &gc_inflight_list); + } + +- /* Now gc_candidates contains only garbage. Restore original +- * inflight counters for these as well, and remove the skbuffs +- * which are creating the cycle(s). +- */ +- skb_queue_head_init(&hitlist); +- list_for_each_entry(u, &gc_candidates, link) +- scan_children(&u->sk, inc_inflight, &hitlist); +- + spin_unlock(&unix_gc_lock); + + /* Here we are. Hitlist is filled. Die. */ +diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c +index aee396b9f190..c1081a6e31ef 100644 +--- a/net/wireless/nl80211.c ++++ b/net/wireless/nl80211.c +@@ -540,22 +540,18 @@ static int nl80211_prepare_wdev_dump(struct sk_buff *skb, + { + int err; + +- rtnl_lock(); +- + if (!cb->args[0]) { + err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, + genl_family_attrbuf(&nl80211_fam), + nl80211_fam.maxattr, nl80211_policy); + if (err) +- goto out_unlock; ++ return err; + + *wdev = __cfg80211_wdev_from_attrs( + sock_net(skb->sk), + genl_family_attrbuf(&nl80211_fam)); +- if (IS_ERR(*wdev)) { +- err = PTR_ERR(*wdev); +- goto out_unlock; +- } ++ if (IS_ERR(*wdev)) ++ return PTR_ERR(*wdev); + *rdev = wiphy_to_rdev((*wdev)->wiphy); + /* 0 is the first index - add 1 to parse only once */ + cb->args[0] = (*rdev)->wiphy_idx + 1; +@@ -565,10 +561,8 @@ static int nl80211_prepare_wdev_dump(struct sk_buff *skb, + struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1); + struct wireless_dev *tmp; + +- if (!wiphy) { +- err = -ENODEV; +- goto out_unlock; +- } ++ if (!wiphy) ++ return -ENODEV; + *rdev = wiphy_to_rdev(wiphy); + *wdev = NULL; + +@@ -579,21 +573,11 @@ static int nl80211_prepare_wdev_dump(struct sk_buff *skb, + } + } + +- if (!*wdev) { +- err = -ENODEV; +- goto out_unlock; +- } ++ if (!*wdev) ++ return -ENODEV; + } + + return 0; +- out_unlock: +- rtnl_unlock(); +- return err; +-} +- +-static void nl80211_finish_wdev_dump(struct cfg80211_registered_device *rdev) +-{ +- rtnl_unlock(); + } + + /* IE validation */ +@@ -2599,17 +2583,17 @@ static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback * + int filter_wiphy = -1; + struct cfg80211_registered_device *rdev; + struct wireless_dev *wdev; ++ int ret; + + rtnl_lock(); + if (!cb->args[2]) { + struct nl80211_dump_wiphy_state state = { + .filter_wiphy = -1, + }; +- int ret; + + ret = nl80211_dump_wiphy_parse(skb, cb, &state); + if (ret) +- return ret; ++ goto out_unlock; + + filter_wiphy = state.filter_wiphy; + +@@ -2654,12 +2638,14 @@ static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback * + wp_idx++; + } + out: +- rtnl_unlock(); +- + cb->args[0] = wp_idx; + cb->args[1] = if_idx; + +- return skb->len; ++ ret = skb->len; ++ out_unlock: ++ rtnl_unlock(); ++ ++ return ret; + } + + static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info) +@@ -4398,9 +4384,10 @@ static int nl80211_dump_station(struct sk_buff *skb, + int sta_idx = cb->args[2]; + int err; + ++ rtnl_lock(); + err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev); + if (err) +- return err; ++ goto out_err; + + if (!wdev->netdev) { + err = -EINVAL; +@@ -4435,7 +4422,7 @@ static int nl80211_dump_station(struct sk_buff *skb, + cb->args[2] = sta_idx; + err = skb->len; + out_err: +- nl80211_finish_wdev_dump(rdev); ++ rtnl_unlock(); + + return err; + } +@@ -5221,9 +5208,10 @@ static int nl80211_dump_mpath(struct sk_buff *skb, + int path_idx = cb->args[2]; + int err; + ++ rtnl_lock(); + err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev); + if (err) +- return err; ++ goto out_err; + + if (!rdev->ops->dump_mpath) { + err = -EOPNOTSUPP; +@@ -5256,7 +5244,7 @@ static int nl80211_dump_mpath(struct sk_buff *skb, + cb->args[2] = path_idx; + err = skb->len; + out_err: +- nl80211_finish_wdev_dump(rdev); ++ rtnl_unlock(); + return err; + } + +@@ -5416,9 +5404,10 @@ static int nl80211_dump_mpp(struct sk_buff *skb, + int path_idx = cb->args[2]; + int err; + ++ rtnl_lock(); + err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev); + if (err) +- return err; ++ goto out_err; + + if (!rdev->ops->dump_mpp) { + err = -EOPNOTSUPP; +@@ -5451,7 +5440,7 @@ static int nl80211_dump_mpp(struct sk_buff *skb, + cb->args[2] = path_idx; + err = skb->len; + out_err: +- nl80211_finish_wdev_dump(rdev); ++ rtnl_unlock(); + return err; + } + +@@ -7596,9 +7585,12 @@ static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb) + int start = cb->args[2], idx = 0; + int err; + ++ rtnl_lock(); + err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev); +- if (err) ++ if (err) { ++ rtnl_unlock(); + return err; ++ } + + wdev_lock(wdev); + spin_lock_bh(&rdev->bss_lock); +@@ -7621,7 +7613,7 @@ static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb) + wdev_unlock(wdev); + + cb->args[2] = idx; +- nl80211_finish_wdev_dump(rdev); ++ rtnl_unlock(); + + return skb->len; + } +@@ -7706,9 +7698,10 @@ static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb) + int res; + bool radio_stats; + ++ rtnl_lock(); + res = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev); + if (res) +- return res; ++ goto out_err; + + /* prepare_wdev_dump parsed the attributes */ + radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS]; +@@ -7749,7 +7742,7 @@ static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb) + cb->args[2] = survey_idx; + res = skb->len; + out_err: +- nl80211_finish_wdev_dump(rdev); ++ rtnl_unlock(); + return res; + } + +@@ -11378,17 +11371,13 @@ static int nl80211_prepare_vendor_dump(struct sk_buff *skb, + void *data = NULL; + unsigned int data_len = 0; + +- rtnl_lock(); +- + if (cb->args[0]) { + /* subtract the 1 again here */ + struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1); + struct wireless_dev *tmp; + +- if (!wiphy) { +- err = -ENODEV; +- goto out_unlock; +- } ++ if (!wiphy) ++ return -ENODEV; + *rdev = wiphy_to_rdev(wiphy); + *wdev = NULL; + +@@ -11408,23 +11397,19 @@ static int nl80211_prepare_vendor_dump(struct sk_buff *skb, + err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, + attrbuf, nl80211_fam.maxattr, nl80211_policy); + if (err) +- goto out_unlock; ++ return err; + + if (!attrbuf[NL80211_ATTR_VENDOR_ID] || +- !attrbuf[NL80211_ATTR_VENDOR_SUBCMD]) { +- err = -EINVAL; +- goto out_unlock; +- } ++ !attrbuf[NL80211_ATTR_VENDOR_SUBCMD]) ++ return -EINVAL; + + *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk), attrbuf); + if (IS_ERR(*wdev)) + *wdev = NULL; + + *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf); +- if (IS_ERR(*rdev)) { +- err = PTR_ERR(*rdev); +- goto out_unlock; +- } ++ if (IS_ERR(*rdev)) ++ return PTR_ERR(*rdev); + + vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]); + subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]); +@@ -11437,19 +11422,15 @@ static int nl80211_prepare_vendor_dump(struct sk_buff *skb, + if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd) + continue; + +- if (!vcmd->dumpit) { +- err = -EOPNOTSUPP; +- goto out_unlock; +- } ++ if (!vcmd->dumpit) ++ return -EOPNOTSUPP; + + vcmd_idx = i; + break; + } + +- if (vcmd_idx < 0) { +- err = -EOPNOTSUPP; +- goto out_unlock; +- } ++ if (vcmd_idx < 0) ++ return -EOPNOTSUPP; + + if (attrbuf[NL80211_ATTR_VENDOR_DATA]) { + data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]); +@@ -11466,9 +11447,6 @@ static int nl80211_prepare_vendor_dump(struct sk_buff *skb, + + /* keep rtnl locked in successful case */ + return 0; +- out_unlock: +- rtnl_unlock(); +- return err; + } + + static int nl80211_vendor_cmd_dump(struct sk_buff *skb, +@@ -11483,9 +11461,10 @@ static int nl80211_vendor_cmd_dump(struct sk_buff *skb, + int err; + struct nlattr *vendor_data; + ++ rtnl_lock(); + err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev); + if (err) +- return err; ++ goto out; + + vcmd_idx = cb->args[2]; + data = (void *)cb->args[3]; +@@ -11494,15 +11473,21 @@ static int nl80211_vendor_cmd_dump(struct sk_buff *skb, + + if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV | + WIPHY_VENDOR_CMD_NEED_NETDEV)) { +- if (!wdev) +- return -EINVAL; ++ if (!wdev) { ++ err = -EINVAL; ++ goto out; ++ } + if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV && +- !wdev->netdev) +- return -EINVAL; ++ !wdev->netdev) { ++ err = -EINVAL; ++ goto out; ++ } + + if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) { +- if (!wdev_running(wdev)) +- return -ENETDOWN; ++ if (!wdev_running(wdev)) { ++ err = -ENETDOWN; ++ goto out; ++ } + } + } + +diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c +index 4c935202ce23..f3b1d7f50b81 100644 +--- a/sound/core/seq/seq_clientmgr.c ++++ b/sound/core/seq/seq_clientmgr.c +@@ -1832,6 +1832,7 @@ static int snd_seq_ioctl_set_client_pool(struct snd_seq_client *client, + info->output_pool != client->pool->size)) { + if (snd_seq_write_pool_allocated(client)) { + /* remove all existing cells */ ++ snd_seq_pool_mark_closing(client->pool); + snd_seq_queue_client_leave_cells(client->number); + snd_seq_pool_done(client->pool); + } +diff --git a/sound/core/seq/seq_fifo.c b/sound/core/seq/seq_fifo.c +index 86240d02b530..3f4efcb85df5 100644 +--- a/sound/core/seq/seq_fifo.c ++++ b/sound/core/seq/seq_fifo.c +@@ -70,6 +70,9 @@ void snd_seq_fifo_delete(struct snd_seq_fifo **fifo) + return; + *fifo = NULL; + ++ if (f->pool) ++ snd_seq_pool_mark_closing(f->pool); ++ + snd_seq_fifo_clear(f); + + /* wake up clients if any */ +diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c +index dfa5156f3585..5847c4475bf3 100644 +--- a/sound/core/seq/seq_memory.c ++++ b/sound/core/seq/seq_memory.c +@@ -414,6 +414,18 @@ int snd_seq_pool_init(struct snd_seq_pool *pool) + return 0; + } + ++/* refuse the further insertion to the pool */ ++void snd_seq_pool_mark_closing(struct snd_seq_pool *pool) ++{ ++ unsigned long flags; ++ ++ if (snd_BUG_ON(!pool)) ++ return; ++ spin_lock_irqsave(&pool->lock, flags); ++ pool->closing = 1; ++ spin_unlock_irqrestore(&pool->lock, flags); ++} ++ + /* remove events */ + int snd_seq_pool_done(struct snd_seq_pool *pool) + { +@@ -424,10 +436,6 @@ int snd_seq_pool_done(struct snd_seq_pool *pool) + return -EINVAL; + + /* wait for closing all threads */ +- spin_lock_irqsave(&pool->lock, flags); +- pool->closing = 1; +- spin_unlock_irqrestore(&pool->lock, flags); +- + if (waitqueue_active(&pool->output_sleep)) + wake_up(&pool->output_sleep); + +@@ -484,6 +492,7 @@ int snd_seq_pool_delete(struct snd_seq_pool **ppool) + *ppool = NULL; + if (pool == NULL) + return 0; ++ snd_seq_pool_mark_closing(pool); + snd_seq_pool_done(pool); + kfree(pool); + return 0; +diff --git a/sound/core/seq/seq_memory.h b/sound/core/seq/seq_memory.h +index 4a2ec779b8a7..32f959c17786 100644 +--- a/sound/core/seq/seq_memory.h ++++ b/sound/core/seq/seq_memory.h +@@ -84,6 +84,7 @@ static inline int snd_seq_total_cells(struct snd_seq_pool *pool) + int snd_seq_pool_init(struct snd_seq_pool *pool); + + /* done pool - free events */ ++void snd_seq_pool_mark_closing(struct snd_seq_pool *pool); + int snd_seq_pool_done(struct snd_seq_pool *pool); + + /* create pool */ +diff --git a/sound/pci/ctxfi/cthw20k1.c b/sound/pci/ctxfi/cthw20k1.c +index ab4cdab5cfa5..79edd88d5cd0 100644 +--- a/sound/pci/ctxfi/cthw20k1.c ++++ b/sound/pci/ctxfi/cthw20k1.c +@@ -1905,7 +1905,7 @@ static int hw_card_start(struct hw *hw) + return err; + + /* Set DMA transfer mask */ +- if (dma_set_mask(&pci->dev, DMA_BIT_MASK(dma_bits))) { ++ if (!dma_set_mask(&pci->dev, DMA_BIT_MASK(dma_bits))) { + dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(dma_bits)); + } else { + dma_set_mask(&pci->dev, DMA_BIT_MASK(32)); +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index 6b041f7268fb..c813ad857650 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -6058,6 +6058,8 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { + ALC295_STANDARD_PINS, + {0x17, 0x21014040}, + {0x18, 0x21a19050}), ++ SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, ++ ALC295_STANDARD_PINS), + SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, + ALC298_STANDARD_PINS, + {0x17, 0x90170110}),