commit:     584d5a37bfe568985e4f1ae9a640af0e7f986099
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Wed Oct 27 11:59:40 2021 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Wed Oct 27 11:59:40 2021 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=584d5a37

Linux patch 4.14.253

Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org>

 0000_README               |    4 +
 1252_linux-4.14.253.patch | 1004 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 1008 insertions(+)

diff --git a/0000_README b/0000_README
index 467bc5a..d4ac84b 100644
--- a/0000_README
+++ b/0000_README
@@ -1055,6 +1055,10 @@ Patch:  1251_linux-4.14.252.patch
 From:   https://www.kernel.org
 Desc:   Linux 4.14.252
 
+Patch:  1252_linux-4.14.253.patch
+From:   https://www.kernel.org
+Desc:   Linux 4.14.253
+
 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/1252_linux-4.14.253.patch b/1252_linux-4.14.253.patch
new file mode 100644
index 0000000..c628087
--- /dev/null
+++ b/1252_linux-4.14.253.patch
@@ -0,0 +1,1004 @@
+diff --git a/Makefile b/Makefile
+index 0e28fc0458082..f4084bf887619 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 4
+ PATCHLEVEL = 14
+-SUBLEVEL = 252
++SUBLEVEL = 253
+ EXTRAVERSION =
+ NAME = Petit Gorille
+ 
+diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
+index 89f7d0c282406..86ed77d75e4bb 100644
+--- a/arch/arm/Kconfig
++++ b/arch/arm/Kconfig
+@@ -65,6 +65,7 @@ config ARM
+       select HAVE_FTRACE_MCOUNT_RECORD if (!XIP_KERNEL)
+       select HAVE_FUNCTION_GRAPH_TRACER if (!THUMB2_KERNEL)
+       select HAVE_FUNCTION_TRACER if (!XIP_KERNEL)
++      select HAVE_FUTEX_CMPXCHG if FUTEX
+       select HAVE_GCC_PLUGINS
+       select HAVE_GENERIC_DMA_COHERENT
+       select HAVE_HW_BREAKPOINT if (PERF_EVENTS && (CPU_V6 || CPU_V6K || 
CPU_V7))
+diff --git a/arch/arm/boot/dts/at91-sama5d27_som1_ek.dts 
b/arch/arm/boot/dts/at91-sama5d27_som1_ek.dts
+index 60cb084a8d927..7e1acec92b508 100644
+--- a/arch/arm/boot/dts/at91-sama5d27_som1_ek.dts
++++ b/arch/arm/boot/dts/at91-sama5d27_som1_ek.dts
+@@ -98,7 +98,6 @@
+                       isc: isc@f0008000 {
+                               pinctrl-names = "default";
+                               pinctrl-0 = <&pinctrl_isc_base 
&pinctrl_isc_data_8bit &pinctrl_isc_data_9_10 &pinctrl_isc_data_11_12>;
+-                              status = "okay";
+                       };
+ 
+                       spi0: spi@f8000000 {
+diff --git a/arch/arm/boot/dts/spear3xx.dtsi b/arch/arm/boot/dts/spear3xx.dtsi
+index 118135d758990..4e4166d96b264 100644
+--- a/arch/arm/boot/dts/spear3xx.dtsi
++++ b/arch/arm/boot/dts/spear3xx.dtsi
+@@ -53,7 +53,7 @@
+               };
+ 
+               gmac: eth@e0800000 {
+-                      compatible = "st,spear600-gmac";
++                      compatible = "snps,dwmac-3.40a";
+                       reg = <0xe0800000 0x8000>;
+                       interrupts = <23 22>;
+                       interrupt-names = "macirq", "eth_wake_irq";
+diff --git a/arch/nios2/include/asm/irqflags.h 
b/arch/nios2/include/asm/irqflags.h
+index 75ab92e639f85..0338fcb88203c 100644
+--- a/arch/nios2/include/asm/irqflags.h
++++ b/arch/nios2/include/asm/irqflags.h
+@@ -22,7 +22,7 @@
+ 
+ static inline unsigned long arch_local_save_flags(void)
+ {
+-      return RDCTL(CTL_STATUS);
++      return RDCTL(CTL_FSTATUS);
+ }
+ 
+ /*
+@@ -31,7 +31,7 @@ static inline unsigned long arch_local_save_flags(void)
+  */
+ static inline void arch_local_irq_restore(unsigned long flags)
+ {
+-      WRCTL(CTL_STATUS, flags);
++      WRCTL(CTL_FSTATUS, flags);
+ }
+ 
+ static inline void arch_local_irq_disable(void)
+diff --git a/arch/nios2/include/asm/registers.h 
b/arch/nios2/include/asm/registers.h
+index 615bce19b546e..33824f2ad1ab7 100644
+--- a/arch/nios2/include/asm/registers.h
++++ b/arch/nios2/include/asm/registers.h
+@@ -24,7 +24,7 @@
+ #endif
+ 
+ /* control register numbers */
+-#define CTL_STATUS    0
++#define CTL_FSTATUS   0
+ #define CTL_ESTATUS   1
+ #define CTL_BSTATUS   2
+ #define CTL_IENABLE   3
+diff --git a/arch/xtensa/platforms/xtfpga/setup.c 
b/arch/xtensa/platforms/xtfpga/setup.c
+index 42285f35d3135..db5122765f166 100644
+--- a/arch/xtensa/platforms/xtfpga/setup.c
++++ b/arch/xtensa/platforms/xtfpga/setup.c
+@@ -54,8 +54,12 @@ void platform_power_off(void)
+ 
+ void platform_restart(void)
+ {
+-      /* Flush and reset the mmu, simulate a processor reset, and
+-       * jump to the reset vector. */
++      /* Try software reset first. */
++      WRITE_ONCE(*(u32 *)XTFPGA_SWRST_VADDR, 0xdead);
++
++      /* If software reset did not work, flush and reset the mmu,
++       * simulate a processor reset, and jump to the reset vector.
++       */
+       cpu_reset();
+       /* control never gets here */
+ }
+@@ -85,7 +89,7 @@ void __init platform_calibrate_ccount(void)
+ 
+ #endif
+ 
+-#ifdef CONFIG_OF
++#ifdef CONFIG_USE_OF
+ 
+ static void __init xtfpga_clk_setup(struct device_node *np)
+ {
+@@ -303,4 +307,4 @@ static int __init xtavnet_init(void)
+  */
+ arch_initcall(xtavnet_init);
+ 
+-#endif /* CONFIG_OF */
++#endif /* CONFIG_USE_OF */
+diff --git a/drivers/isdn/capi/kcapi.c b/drivers/isdn/capi/kcapi.c
+index 4c35abeceb617..103913d10ab1c 100644
+--- a/drivers/isdn/capi/kcapi.c
++++ b/drivers/isdn/capi/kcapi.c
+@@ -564,6 +564,11 @@ int detach_capi_ctr(struct capi_ctr *ctr)
+ 
+       ctr_down(ctr, CAPI_CTR_DETACHED);
+ 
++      if (ctr->cnr < 1 || ctr->cnr - 1 >= CAPI_MAXCONTR) {
++              err = -EINVAL;
++              goto unlock_out;
++      }
++
+       if (capi_controller[ctr->cnr - 1] != ctr) {
+               err = -EINVAL;
+               goto unlock_out;
+diff --git a/drivers/isdn/hardware/mISDN/netjet.c 
b/drivers/isdn/hardware/mISDN/netjet.c
+index 79f9925da76c0..56b54aab51f99 100644
+--- a/drivers/isdn/hardware/mISDN/netjet.c
++++ b/drivers/isdn/hardware/mISDN/netjet.c
+@@ -963,8 +963,8 @@ nj_release(struct tiger_hw *card)
+               nj_disable_hwirq(card);
+               mode_tiger(&card->bc[0], ISDN_P_NONE);
+               mode_tiger(&card->bc[1], ISDN_P_NONE);
+-              card->isac.release(&card->isac);
+               spin_unlock_irqrestore(&card->lock, flags);
++              card->isac.release(&card->isac);
+               release_region(card->base, card->base_s);
+               card->base_s = 0;
+       }
+diff --git a/drivers/net/can/rcar/rcar_can.c b/drivers/net/can/rcar/rcar_can.c
+index 771a460837397..963da8eda1687 100644
+--- a/drivers/net/can/rcar/rcar_can.c
++++ b/drivers/net/can/rcar/rcar_can.c
+@@ -857,10 +857,12 @@ static int __maybe_unused rcar_can_suspend(struct device 
*dev)
+       struct rcar_can_priv *priv = netdev_priv(ndev);
+       u16 ctlr;
+ 
+-      if (netif_running(ndev)) {
+-              netif_stop_queue(ndev);
+-              netif_device_detach(ndev);
+-      }
++      if (!netif_running(ndev))
++              return 0;
++
++      netif_stop_queue(ndev);
++      netif_device_detach(ndev);
++
+       ctlr = readw(&priv->regs->ctlr);
+       ctlr |= RCAR_CAN_CTLR_CANM_HALT;
+       writew(ctlr, &priv->regs->ctlr);
+@@ -879,6 +881,9 @@ static int __maybe_unused rcar_can_resume(struct device 
*dev)
+       u16 ctlr;
+       int err;
+ 
++      if (!netif_running(ndev))
++              return 0;
++
+       err = clk_enable(priv->clk);
+       if (err) {
+               netdev_err(ndev, "clk_enable() failed, error %d\n", err);
+@@ -892,10 +897,9 @@ static int __maybe_unused rcar_can_resume(struct device 
*dev)
+       writew(ctlr, &priv->regs->ctlr);
+       priv->can.state = CAN_STATE_ERROR_ACTIVE;
+ 
+-      if (netif_running(ndev)) {
+-              netif_device_attach(ndev);
+-              netif_start_queue(ndev);
+-      }
++      netif_device_attach(ndev);
++      netif_start_queue(ndev);
++
+       return 0;
+ }
+ 
+diff --git a/drivers/net/can/sja1000/peak_pci.c 
b/drivers/net/can/sja1000/peak_pci.c
+index 5adc95c922eef..34a645e27f665 100644
+--- a/drivers/net/can/sja1000/peak_pci.c
++++ b/drivers/net/can/sja1000/peak_pci.c
+@@ -739,16 +739,15 @@ static void peak_pci_remove(struct pci_dev *pdev)
+               struct net_device *prev_dev = chan->prev_dev;
+ 
+               dev_info(&pdev->dev, "removing device %s\n", dev->name);
++              /* do that only for first channel */
++              if (!prev_dev && chan->pciec_card)
++                      peak_pciec_remove(chan->pciec_card);
+               unregister_sja1000dev(dev);
+               free_sja1000dev(dev);
+               dev = prev_dev;
+ 
+-              if (!dev) {
+-                      /* do that only for first channel */
+-                      if (chan->pciec_card)
+-                              peak_pciec_remove(chan->pciec_card);
++              if (!dev)
+                       break;
+-              }
+               priv = netdev_priv(dev);
+               chan = priv->priv;
+       }
+diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_fd.c 
b/drivers/net/can/usb/peak_usb/pcan_usb_fd.c
+index 0d762bdac4f88..bb5cd80f0fb24 100644
+--- a/drivers/net/can/usb/peak_usb/pcan_usb_fd.c
++++ b/drivers/net/can/usb/peak_usb/pcan_usb_fd.c
+@@ -560,11 +560,10 @@ static int pcan_usb_fd_decode_status(struct 
pcan_usb_fd_if *usb_if,
+       } else if (sm->channel_p_w_b & PUCAN_BUS_WARNING) {
+               new_state = CAN_STATE_ERROR_WARNING;
+       } else {
+-              /* no error bit (so, no error skb, back to active state) */
+-              dev->can.state = CAN_STATE_ERROR_ACTIVE;
++              /* back to (or still in) ERROR_ACTIVE state */
++              new_state = CAN_STATE_ERROR_ACTIVE;
+               pdev->bec.txerr = 0;
+               pdev->bec.rxerr = 0;
+-              return 0;
+       }
+ 
+       /* state hasn't changed */
+diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-generic.c 
b/drivers/net/ethernet/stmicro/stmmac/dwmac-generic.c
+index 3304095c934c3..47842a796c3b6 100644
+--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-generic.c
++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-generic.c
+@@ -71,6 +71,7 @@ err_remove_config_dt:
+ 
+ static const struct of_device_id dwmac_generic_match[] = {
+       { .compatible = "st,spear600-gmac"},
++      { .compatible = "snps,dwmac-3.40a"},
+       { .compatible = "snps,dwmac-3.50a"},
+       { .compatible = "snps,dwmac-3.610"},
+       { .compatible = "snps,dwmac-3.70a"},
+diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c 
b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+index d48cc32dc5073..d008e9d1518b4 100644
+--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+@@ -458,6 +458,14 @@ stmmac_probe_config_dt(struct platform_device *pdev, 
const char **mac)
+               plat->pmt = 1;
+       }
+ 
++      if (of_device_is_compatible(np, "snps,dwmac-3.40a")) {
++              plat->has_gmac = 1;
++              plat->enh_desc = 1;
++              plat->tx_coe = 1;
++              plat->bugged_jumbo = 1;
++              plat->pmt = 1;
++      }
++
+       if (of_device_is_compatible(np, "snps,dwmac-4.00") ||
+           of_device_is_compatible(np, "snps,dwmac-4.10a")) {
+               plat->has_gmac4 = 1;
+diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
+index 5ef9bbbab3dbb..b8a38f32d27f0 100644
+--- a/drivers/net/phy/mdio_bus.c
++++ b/drivers/net/phy/mdio_bus.c
+@@ -354,6 +354,7 @@ int __mdiobus_register(struct mii_bus *bus, struct module 
*owner)
+       err = device_register(&bus->dev);
+       if (err) {
+               pr_err("mii_bus %s failed to register\n", bus->id);
++              put_device(&bus->dev);
+               return -EINVAL;
+       }
+ 
+diff --git a/drivers/platform/x86/intel_scu_ipc.c 
b/drivers/platform/x86/intel_scu_ipc.c
+index 2434ce8bead6d..46d543063b6d6 100644
+--- a/drivers/platform/x86/intel_scu_ipc.c
++++ b/drivers/platform/x86/intel_scu_ipc.c
+@@ -183,7 +183,7 @@ static inline int busy_loop(struct intel_scu_ipc_dev *scu)
+       return 0;
+ }
+ 
+-/* Wait till ipc ioc interrupt is received or timeout in 3 HZ */
++/* Wait till ipc ioc interrupt is received or timeout in 10 HZ */
+ static inline int ipc_wait_for_interrupt(struct intel_scu_ipc_dev *scu)
+ {
+       int status;
+diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
+index ec976b93341cf..27609b2ae544a 100644
+--- a/drivers/scsi/hosts.c
++++ b/drivers/scsi/hosts.c
+@@ -213,7 +213,8 @@ int scsi_add_host_with_dma(struct Scsi_Host *shost, struct 
device *dev,
+               goto fail;
+       }
+ 
+-      shost->cmd_per_lun = min_t(short, shost->cmd_per_lun,
++      /* Use min_t(int, ...) in case shost->can_queue exceeds SHRT_MAX */
++      shost->cmd_per_lun = min_t(int, shost->cmd_per_lun,
+                                  shost->can_queue);
+ 
+       error = scsi_init_sense_cache(shost);
+diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
+index dd2504322a87a..2f386d8dbd0ef 100644
+--- a/fs/btrfs/file.c
++++ b/fs/btrfs/file.c
+@@ -2102,53 +2102,12 @@ int btrfs_sync_file(struct file *file, loff_t start, 
loff_t end, int datasync)
+       atomic_inc(&root->log_batch);
+       full_sync = test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                            &BTRFS_I(inode)->runtime_flags);
++
+       /*
+-       * We might have have had more pages made dirty after calling
+-       * start_ordered_ops and before acquiring the inode's i_mutex.
++       * We have to do this here to avoid the priority inversion of waiting on
++       * IO of a lower priority task while holding a transaciton open.
+        */
+-      if (full_sync) {
+-              /*
+-               * For a full sync, we need to make sure any ordered operations
+-               * start and finish before we start logging the inode, so that
+-               * all extents are persisted and the respective file extent
+-               * items are in the fs/subvol btree.
+-               */
+-              ret = btrfs_wait_ordered_range(inode, start, len);
+-      } else {
+-              /*
+-               * Start any new ordered operations before starting to log the
+-               * inode. We will wait for them to finish in btrfs_sync_log().
+-               *
+-               * Right before acquiring the inode's mutex, we might have new
+-               * writes dirtying pages, which won't immediately start the
+-               * respective ordered operations - that is done through the
+-               * fill_delalloc callbacks invoked from the writepage and
+-               * writepages address space operations. So make sure we start
+-               * all ordered operations before starting to log our inode. Not
+-               * doing this means that while logging the inode, writeback
+-               * could start and invoke writepage/writepages, which would call
+-               * the fill_delalloc callbacks (cow_file_range,
+-               * submit_compressed_extents). These callbacks add first an
+-               * extent map to the modified list of extents and then create
+-               * the respective ordered operation, which means in
+-               * tree-log.c:btrfs_log_inode() we might capture all existing
+-               * ordered operations (with btrfs_get_logged_extents()) before
+-               * the fill_delalloc callback adds its ordered operation, and by
+-               * the time we visit the modified list of extent maps (with
+-               * btrfs_log_changed_extents()), we see and process the extent
+-               * map they created. We then use the extent map to construct a
+-               * file extent item for logging without waiting for the
+-               * respective ordered operation to finish - this file extent
+-               * item points to a disk location that might not have yet been
+-               * written to, containing random data - so after a crash a log
+-               * replay will make our inode have file extent items that point
+-               * to disk locations containing invalid data, as we returned
+-               * success to userspace without waiting for the respective
+-               * ordered operation to finish, because it wasn't captured by
+-               * btrfs_get_logged_extents().
+-               */
+-              ret = start_ordered_ops(inode, start, end);
+-      }
++      ret = btrfs_wait_ordered_range(inode, start, len);
+       if (ret) {
+               up_write(&BTRFS_I(inode)->dio_sem);
+               inode_unlock(inode);
+@@ -2283,13 +2242,6 @@ int btrfs_sync_file(struct file *file, loff_t start, 
loff_t end, int datasync)
+                               goto out;
+                       }
+               }
+-              if (!full_sync) {
+-                      ret = btrfs_wait_ordered_range(inode, start, len);
+-                      if (ret) {
+-                              btrfs_end_transaction(trans);
+-                              goto out;
+-                      }
+-              }
+               ret = btrfs_commit_transaction(trans);
+       } else {
+               ret = btrfs_end_transaction(trans);
+diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
+index 08ab7ab909a8e..372a10130ced1 100644
+--- a/fs/btrfs/tree-log.c
++++ b/fs/btrfs/tree-log.c
+@@ -901,9 +901,11 @@ out:
+ }
+ 
+ /*
+- * helper function to see if a given name and sequence number found
+- * in an inode back reference are already in a directory and correctly
+- * point to this inode
++ * See if a given name and sequence number found in an inode back reference 
are
++ * already in a directory and correctly point to this inode.
++ *
++ * Returns: < 0 on error, 0 if the directory entry does not exists and 1 if it
++ * exists.
+  */
+ static noinline int inode_in_dir(struct btrfs_root *root,
+                                struct btrfs_path *path,
+@@ -912,29 +914,35 @@ static noinline int inode_in_dir(struct btrfs_root *root,
+ {
+       struct btrfs_dir_item *di;
+       struct btrfs_key location;
+-      int match = 0;
++      int ret = 0;
+ 
+       di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
+                                        index, name, name_len, 0);
+-      if (di && !IS_ERR(di)) {
++      if (IS_ERR(di)) {
++              if (PTR_ERR(di) != -ENOENT)
++                      ret = PTR_ERR(di);
++              goto out;
++      } else if (di) {
+               btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
+               if (location.objectid != objectid)
+                       goto out;
+-      } else
++      } else {
+               goto out;
+-      btrfs_release_path(path);
++      }
+ 
++      btrfs_release_path(path);
+       di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
+-      if (di && !IS_ERR(di)) {
+-              btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
+-              if (location.objectid != objectid)
+-                      goto out;
+-      } else
++      if (IS_ERR(di)) {
++              ret = PTR_ERR(di);
+               goto out;
+-      match = 1;
++      } else if (di) {
++              btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
++              if (location.objectid == objectid)
++                      ret = 1;
++      }
+ out:
+       btrfs_release_path(path);
+-      return match;
++      return ret;
+ }
+ 
+ /*
+@@ -1319,10 +1327,12 @@ static noinline int add_inode_ref(struct 
btrfs_trans_handle *trans,
+               if (ret)
+                       goto out;
+ 
+-              /* if we already have a perfect match, we're done */
+-              if (!inode_in_dir(root, path, btrfs_ino(BTRFS_I(dir)),
+-                                      btrfs_ino(BTRFS_I(inode)), ref_index,
+-                                      name, namelen)) {
++              ret = inode_in_dir(root, path, btrfs_ino(BTRFS_I(dir)),
++                                 btrfs_ino(BTRFS_I(inode)), ref_index,
++                                 name, namelen);
++              if (ret < 0) {
++                      goto out;
++              } else if (ret == 0) {
+                       /*
+                        * look for a conflicting back reference in the
+                        * metadata. if we find one we have to unlink that name
+@@ -1355,6 +1365,7 @@ static noinline int add_inode_ref(struct 
btrfs_trans_handle *trans,
+ 
+                       btrfs_update_inode(trans, root, inode);
+               }
++              /* Else, ret == 1, we already have a perfect match, we're done. 
*/
+ 
+               ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
+               kfree(name);
+diff --git a/fs/exec.c b/fs/exec.c
+index e8d1e67059775..c72ccfa49f541 100644
+--- a/fs/exec.c
++++ b/fs/exec.c
+@@ -980,7 +980,7 @@ int kernel_read_file_from_fd(int fd, void **buf, loff_t 
*size, loff_t max_size,
+       struct fd f = fdget(fd);
+       int ret = -EBADF;
+ 
+-      if (!f.file)
++      if (!f.file || !(f.file->f_mode & FMODE_READ))
+               goto out;
+ 
+       ret = kernel_read_file(f.file, buf, size, max_size, id);
+diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
+index d44402241d9e6..50465ee502c7e 100644
+--- a/fs/nfsd/nfsctl.c
++++ b/fs/nfsd/nfsctl.c
+@@ -788,7 +788,10 @@ out_close:
+               svc_xprt_put(xprt);
+       }
+ out_err:
+-      nfsd_destroy(net);
++      if (!list_empty(&nn->nfsd_serv->sv_permsocks))
++              nn->nfsd_serv->sv_nrthreads--;
++       else
++              nfsd_destroy(net);
+       return err;
+ }
+ 
+diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
+index bed54e8adcf99..8512f2119241c 100644
+--- a/fs/ocfs2/alloc.c
++++ b/fs/ocfs2/alloc.c
+@@ -6885,7 +6885,7 @@ void ocfs2_set_inode_data_inline(struct inode *inode, 
struct ocfs2_dinode *di)
+ int ocfs2_convert_inline_data_to_extents(struct inode *inode,
+                                        struct buffer_head *di_bh)
+ {
+-      int ret, i, has_data, num_pages = 0;
++      int ret, has_data, num_pages = 0;
+       int need_free = 0;
+       u32 bit_off, num;
+       handle_t *handle;
+@@ -6894,26 +6894,17 @@ int ocfs2_convert_inline_data_to_extents(struct inode 
*inode,
+       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+       struct ocfs2_alloc_context *data_ac = NULL;
+-      struct page **pages = NULL;
+-      loff_t end = osb->s_clustersize;
++      struct page *page = NULL;
+       struct ocfs2_extent_tree et;
+       int did_quota = 0;
+ 
+       has_data = i_size_read(inode) ? 1 : 0;
+ 
+       if (has_data) {
+-              pages = kcalloc(ocfs2_pages_per_cluster(osb->sb),
+-                              sizeof(struct page *), GFP_NOFS);
+-              if (pages == NULL) {
+-                      ret = -ENOMEM;
+-                      mlog_errno(ret);
+-                      return ret;
+-              }
+-
+               ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
+               if (ret) {
+                       mlog_errno(ret);
+-                      goto free_pages;
++                      goto out;
+               }
+       }
+ 
+@@ -6933,7 +6924,8 @@ int ocfs2_convert_inline_data_to_extents(struct inode 
*inode,
+       }
+ 
+       if (has_data) {
+-              unsigned int page_end;
++              unsigned int page_end = min_t(unsigned, PAGE_SIZE,
++                                                      osb->s_clustersize);
+               u64 phys;
+ 
+               ret = dquot_alloc_space_nodirty(inode,
+@@ -6957,15 +6949,8 @@ int ocfs2_convert_inline_data_to_extents(struct inode 
*inode,
+                */
+               block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
+ 
+-              /*
+-               * Non sparse file systems zero on extend, so no need
+-               * to do that now.
+-               */
+-              if (!ocfs2_sparse_alloc(osb) &&
+-                  PAGE_SIZE < osb->s_clustersize)
+-                      end = PAGE_SIZE;
+-
+-              ret = ocfs2_grab_eof_pages(inode, 0, end, pages, &num_pages);
++              ret = ocfs2_grab_eof_pages(inode, 0, page_end, &page,
++                                         &num_pages);
+               if (ret) {
+                       mlog_errno(ret);
+                       need_free = 1;
+@@ -6976,20 +6961,15 @@ int ocfs2_convert_inline_data_to_extents(struct inode 
*inode,
+                * This should populate the 1st page for us and mark
+                * it up to date.
+                */
+-              ret = ocfs2_read_inline_data(inode, pages[0], di_bh);
++              ret = ocfs2_read_inline_data(inode, page, di_bh);
+               if (ret) {
+                       mlog_errno(ret);
+                       need_free = 1;
+                       goto out_unlock;
+               }
+ 
+-              page_end = PAGE_SIZE;
+-              if (PAGE_SIZE > osb->s_clustersize)
+-                      page_end = osb->s_clustersize;
+-
+-              for (i = 0; i < num_pages; i++)
+-                      ocfs2_map_and_dirty_page(inode, handle, 0, page_end,
+-                                               pages[i], i > 0, &phys);
++              ocfs2_map_and_dirty_page(inode, handle, 0, page_end, page, 0,
++                                       &phys);
+       }
+ 
+       spin_lock(&oi->ip_lock);
+@@ -7020,8 +7000,8 @@ int ocfs2_convert_inline_data_to_extents(struct inode 
*inode,
+       }
+ 
+ out_unlock:
+-      if (pages)
+-              ocfs2_unlock_and_free_pages(pages, num_pages);
++      if (page)
++              ocfs2_unlock_and_free_pages(&page, num_pages);
+ 
+ out_commit:
+       if (ret < 0 && did_quota)
+@@ -7045,8 +7025,6 @@ out_commit:
+ out:
+       if (data_ac)
+               ocfs2_free_alloc_context(data_ac);
+-free_pages:
+-      kfree(pages);
+       return ret;
+ }
+ 
+diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
+index f9deabfa303e9..4d76321cf722b 100644
+--- a/fs/ocfs2/super.c
++++ b/fs/ocfs2/super.c
+@@ -2188,11 +2188,17 @@ static int ocfs2_initialize_super(struct super_block 
*sb,
+       }
+ 
+       if (ocfs2_clusterinfo_valid(osb)) {
++              /*
++               * ci_stack and ci_cluster in ocfs2_cluster_info may not be null
++               * terminated, so make sure no overflow happens here by using
++               * memcpy. Destination strings will always be null terminated
++               * because osb is allocated using kzalloc.
++               */
+               osb->osb_stackflags =
+                       OCFS2_RAW_SB(di)->s_cluster_info.ci_stackflags;
+-              strlcpy(osb->osb_cluster_stack,
++              memcpy(osb->osb_cluster_stack,
+                      OCFS2_RAW_SB(di)->s_cluster_info.ci_stack,
+-                     OCFS2_STACK_LABEL_LEN + 1);
++                     OCFS2_STACK_LABEL_LEN);
+               if (strlen(osb->osb_cluster_stack) != OCFS2_STACK_LABEL_LEN) {
+                       mlog(ML_ERROR,
+                            "couldn't mount because of an invalid "
+@@ -2201,9 +2207,9 @@ static int ocfs2_initialize_super(struct super_block *sb,
+                       status = -EINVAL;
+                       goto bail;
+               }
+-              strlcpy(osb->osb_cluster_name,
++              memcpy(osb->osb_cluster_name,
+                       OCFS2_RAW_SB(di)->s_cluster_info.ci_cluster,
+-                      OCFS2_CLUSTER_NAME_LEN + 1);
++                      OCFS2_CLUSTER_NAME_LEN);
+       } else {
+               /* The empty string is identical with classic tools that
+                * don't know about s_cluster_info. */
+diff --git a/include/linux/elfcore.h b/include/linux/elfcore.h
+index b81f9e1d74b0a..9d249dfbab726 100644
+--- a/include/linux/elfcore.h
++++ b/include/linux/elfcore.h
+@@ -58,7 +58,7 @@ static inline int elf_core_copy_task_xfpregs(struct 
task_struct *t, elf_fpxregse
+ }
+ #endif
+ 
+-#if defined(CONFIG_UM) || defined(CONFIG_IA64)
++#if (defined(CONFIG_UML) && defined(CONFIG_X86_32)) || defined(CONFIG_IA64)
+ /*
+  * These functions parameterize elf_core_dump in fs/binfmt_elf.c to write out
+  * extra segments containing the gate DSO contents.  Dumping its
+diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
+index 50c03c430f1a1..7d734b4144fd7 100644
+--- a/kernel/trace/ftrace.c
++++ b/kernel/trace/ftrace.c
+@@ -6113,7 +6113,7 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long 
parent_ip,
+       struct ftrace_ops *op;
+       int bit;
+ 
+-      bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
++      bit = trace_test_and_set_recursion(TRACE_LIST_START);
+       if (bit < 0)
+               return;
+ 
+@@ -6188,7 +6188,7 @@ static void ftrace_ops_assist_func(unsigned long ip, 
unsigned long parent_ip,
+ {
+       int bit;
+ 
+-      bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
++      bit = trace_test_and_set_recursion(TRACE_LIST_START);
+       if (bit < 0)
+               return;
+ 
+diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
+index 5097e9406e78e..b5a251efd164d 100644
+--- a/kernel/trace/trace.h
++++ b/kernel/trace/trace.h
+@@ -459,23 +459,8 @@ struct tracer {
+  *  When function tracing occurs, the following steps are made:
+  *   If arch does not support a ftrace feature:
+  *    call internal function (uses INTERNAL bits) which calls...
+- *   If callback is registered to the "global" list, the list
+- *    function is called and recursion checks the GLOBAL bits.
+- *    then this function calls...
+  *   The function callback, which can use the FTRACE bits to
+  *    check for recursion.
+- *
+- * Now if the arch does not suppport a feature, and it calls
+- * the global list function which calls the ftrace callback
+- * all three of these steps will do a recursion protection.
+- * There's no reason to do one if the previous caller already
+- * did. The recursion that we are protecting against will
+- * go through the same steps again.
+- *
+- * To prevent the multiple recursion checks, if a recursion
+- * bit is set that is higher than the MAX bit of the current
+- * check, then we know that the check was made by the previous
+- * caller, and we can skip the current check.
+  */
+ enum {
+       TRACE_BUFFER_BIT,
+@@ -488,12 +473,14 @@ enum {
+       TRACE_FTRACE_NMI_BIT,
+       TRACE_FTRACE_IRQ_BIT,
+       TRACE_FTRACE_SIRQ_BIT,
++      TRACE_FTRACE_TRANSITION_BIT,
+ 
+-      /* INTERNAL_BITs must be greater than FTRACE_BITs */
++      /* Internal use recursion bits */
+       TRACE_INTERNAL_BIT,
+       TRACE_INTERNAL_NMI_BIT,
+       TRACE_INTERNAL_IRQ_BIT,
+       TRACE_INTERNAL_SIRQ_BIT,
++      TRACE_INTERNAL_TRANSITION_BIT,
+ 
+       TRACE_BRANCH_BIT,
+ /*
+@@ -526,12 +513,6 @@ enum {
+ 
+       TRACE_GRAPH_DEPTH_START_BIT,
+       TRACE_GRAPH_DEPTH_END_BIT,
+-
+-      /*
+-       * When transitioning between context, the preempt_count() may
+-       * not be correct. Allow for a single recursion to cover this case.
+-       */
+-      TRACE_TRANSITION_BIT,
+ };
+ 
+ #define trace_recursion_set(bit)      do { (current)->trace_recursion |= 
(1<<(bit)); } while (0)
+@@ -551,12 +532,18 @@ enum {
+ #define TRACE_CONTEXT_BITS    4
+ 
+ #define TRACE_FTRACE_START    TRACE_FTRACE_BIT
+-#define TRACE_FTRACE_MAX      ((1 << (TRACE_FTRACE_START + 
TRACE_CONTEXT_BITS)) - 1)
+ 
+ #define TRACE_LIST_START      TRACE_INTERNAL_BIT
+-#define TRACE_LIST_MAX                ((1 << (TRACE_LIST_START + 
TRACE_CONTEXT_BITS)) - 1)
+ 
+-#define TRACE_CONTEXT_MASK    TRACE_LIST_MAX
++#define TRACE_CONTEXT_MASK    ((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) 
- 1)
++
++enum {
++      TRACE_CTX_NMI,
++      TRACE_CTX_IRQ,
++      TRACE_CTX_SOFTIRQ,
++      TRACE_CTX_NORMAL,
++      TRACE_CTX_TRANSITION,
++};
+ 
+ static __always_inline int trace_get_context_bit(void)
+ {
+@@ -564,59 +551,48 @@ static __always_inline int trace_get_context_bit(void)
+ 
+       if (in_interrupt()) {
+               if (in_nmi())
+-                      bit = 0;
++                      bit = TRACE_CTX_NMI;
+ 
+               else if (in_irq())
+-                      bit = 1;
++                      bit = TRACE_CTX_IRQ;
+               else
+-                      bit = 2;
++                      bit = TRACE_CTX_SOFTIRQ;
+       } else
+-              bit = 3;
++              bit = TRACE_CTX_NORMAL;
+ 
+       return bit;
+ }
+ 
+-static __always_inline int trace_test_and_set_recursion(int start, int max)
++static __always_inline int trace_test_and_set_recursion(int start)
+ {
+       unsigned int val = current->trace_recursion;
+       int bit;
+ 
+-      /* A previous recursion check was made */
+-      if ((val & TRACE_CONTEXT_MASK) > max)
+-              return 0;
+-
+       bit = trace_get_context_bit() + start;
+       if (unlikely(val & (1 << bit))) {
+               /*
+                * It could be that preempt_count has not been updated during
+                * a switch between contexts. Allow for a single recursion.
+                */
+-              bit = TRACE_TRANSITION_BIT;
++              bit = start + TRACE_CTX_TRANSITION;
+               if (trace_recursion_test(bit))
+                       return -1;
+               trace_recursion_set(bit);
+               barrier();
+-              return bit + 1;
++              return bit;
+       }
+ 
+-      /* Normal check passed, clear the transition to allow it again */
+-      trace_recursion_clear(TRACE_TRANSITION_BIT);
+-
+       val |= 1 << bit;
+       current->trace_recursion = val;
+       barrier();
+ 
+-      return bit + 1;
++      return bit;
+ }
+ 
+ static __always_inline void trace_clear_recursion(int bit)
+ {
+       unsigned int val = current->trace_recursion;
+ 
+-      if (!bit)
+-              return;
+-
+-      bit--;
+       bit = 1 << bit;
+       val &= ~bit;
+ 
+diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
+index 27f7ad12c4b1b..7a5d3d4222159 100644
+--- a/kernel/trace/trace_functions.c
++++ b/kernel/trace/trace_functions.c
+@@ -138,7 +138,7 @@ function_trace_call(unsigned long ip, unsigned long 
parent_ip,
+       pc = preempt_count();
+       preempt_disable_notrace();
+ 
+-      bit = trace_test_and_set_recursion(TRACE_FTRACE_START, 
TRACE_FTRACE_MAX);
++      bit = trace_test_and_set_recursion(TRACE_FTRACE_START);
+       if (bit < 0)
+               goto out;
+ 
+diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig
+index e4a13cc8a2e76..1b302d9fd0a07 100644
+--- a/net/netfilter/Kconfig
++++ b/net/netfilter/Kconfig
+@@ -75,7 +75,7 @@ config NF_CONNTRACK_MARK
+ config NF_CONNTRACK_SECMARK
+       bool  'Connection tracking security mark support'
+       depends on NETWORK_SECMARK
+-      default m if NETFILTER_ADVANCED=n
++      default y if NETFILTER_ADVANCED=n
+       help
+         This option enables security markings to be applied to
+         connections.  Typically they are copied to connections from
+diff --git a/net/netfilter/ipvs/ip_vs_ctl.c b/net/netfilter/ipvs/ip_vs_ctl.c
+index eea0144aada7a..ecc16d8c1cc31 100644
+--- a/net/netfilter/ipvs/ip_vs_ctl.c
++++ b/net/netfilter/ipvs/ip_vs_ctl.c
+@@ -3987,6 +3987,11 @@ static int __net_init 
ip_vs_control_net_init_sysctl(struct netns_ipvs *ipvs)
+       tbl[idx++].data = &ipvs->sysctl_conn_reuse_mode;
+       tbl[idx++].data = &ipvs->sysctl_schedule_icmp;
+       tbl[idx++].data = &ipvs->sysctl_ignore_tunneled;
++#ifdef CONFIG_IP_VS_DEBUG
++      /* Global sysctls must be ro in non-init netns */
++      if (!net_eq(net, &init_net))
++              tbl[idx++].mode = 0444;
++#endif
+ 
+       ipvs->sysctl_hdr = register_net_sysctl(net, "net/ipv4/vs", tbl);
+       if (ipvs->sysctl_hdr == NULL) {
+diff --git a/net/nfc/nci/rsp.c b/net/nfc/nci/rsp.c
+index e3bbf1937d0e9..7681f89dc312b 100644
+--- a/net/nfc/nci/rsp.c
++++ b/net/nfc/nci/rsp.c
+@@ -289,6 +289,8 @@ static void nci_core_conn_close_rsp_packet(struct nci_dev 
*ndev,
+                                                        ndev->cur_conn_id);
+               if (conn_info) {
+                       list_del(&conn_info->list);
++                      if (conn_info == ndev->rf_conn_info)
++                              ndev->rf_conn_info = NULL;
+                       devm_kfree(&ndev->nfc_dev->dev, conn_info);
+               }
+       }
+diff --git a/sound/hda/hdac_controller.c b/sound/hda/hdac_controller.c
+index 778b42ba90b80..5ae72134159a7 100644
+--- a/sound/hda/hdac_controller.c
++++ b/sound/hda/hdac_controller.c
+@@ -389,8 +389,9 @@ int snd_hdac_bus_reset_link(struct hdac_bus *bus, bool 
full_reset)
+       if (!full_reset)
+               goto skip_reset;
+ 
+-      /* clear STATESTS */
+-      snd_hdac_chip_writew(bus, STATESTS, STATESTS_INT_MASK);
++      /* clear STATESTS if not in reset */
++      if (snd_hdac_chip_readb(bus, GCTL) & AZX_GCTL_RESET)
++              snd_hdac_chip_writew(bus, STATESTS, STATESTS_INT_MASK);
+ 
+       /* reset controller */
+       snd_hdac_bus_enter_link_reset(bus);
+diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
+index dedd3517d3694..7c013d237ea19 100644
+--- a/sound/soc/soc-dapm.c
++++ b/sound/soc/soc-dapm.c
+@@ -2495,6 +2495,7 @@ static int snd_soc_dapm_set_pin(struct 
snd_soc_dapm_context *dapm,
+                               const char *pin, int status)
+ {
+       struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
++      int ret = 0;
+ 
+       dapm_assert_locked(dapm);
+ 
+@@ -2507,13 +2508,14 @@ static int snd_soc_dapm_set_pin(struct 
snd_soc_dapm_context *dapm,
+               dapm_mark_dirty(w, "pin configuration");
+               dapm_widget_invalidate_input_paths(w);
+               dapm_widget_invalidate_output_paths(w);
++              ret = 1;
+       }
+ 
+       w->connected = status;
+       if (status == 0)
+               w->force = 0;
+ 
+-      return 0;
++      return ret;
+ }
+ 
+ /**
+@@ -3441,14 +3443,15 @@ int snd_soc_dapm_put_pin_switch(struct snd_kcontrol 
*kcontrol,
+ {
+       struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
+       const char *pin = (const char *)kcontrol->private_value;
++      int ret;
+ 
+       if (ucontrol->value.integer.value[0])
+-              snd_soc_dapm_enable_pin(&card->dapm, pin);
++              ret = snd_soc_dapm_enable_pin(&card->dapm, pin);
+       else
+-              snd_soc_dapm_disable_pin(&card->dapm, pin);
++              ret = snd_soc_dapm_disable_pin(&card->dapm, pin);
+ 
+       snd_soc_dapm_sync(&card->dapm);
+-      return 0;
++      return ret;
+ }
+ EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
+ 
+@@ -3824,7 +3827,7 @@ static int snd_soc_dapm_dai_link_put(struct snd_kcontrol 
*kcontrol,
+ 
+       w->params_select = ucontrol->value.enumerated.item[0];
+ 
+-      return 0;
++      return 1;
+ }
+ 
+ int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
+diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h
+index d3d3e05fe5b8d..1904fc542025d 100644
+--- a/sound/usb/quirks-table.h
++++ b/sound/usb/quirks-table.h
+@@ -3446,5 +3446,37 @@ AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
+               }
+       }
+ },
++{
++      /*
++       * Sennheiser GSP670
++       * Change order of interfaces loaded
++       */
++      USB_DEVICE(0x1395, 0x0300),
++      .bInterfaceClass = USB_CLASS_PER_INTERFACE,
++      .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
++              .ifnum = QUIRK_ANY_INTERFACE,
++              .type = QUIRK_COMPOSITE,
++              .data = &(const struct snd_usb_audio_quirk[]) {
++                      // Communication
++                      {
++                              .ifnum = 3,
++                              .type = QUIRK_AUDIO_STANDARD_INTERFACE
++                      },
++                      // Recording
++                      {
++                              .ifnum = 4,
++                              .type = QUIRK_AUDIO_STANDARD_INTERFACE
++                      },
++                      // Main
++                      {
++                              .ifnum = 1,
++                              .type = QUIRK_AUDIO_STANDARD_INTERFACE
++                      },
++                      {
++                              .ifnum = -1
++                      }
++              }
++      }
++},
+ 
+ #undef USB_DEVICE_VENDOR_SPEC

Reply via email to