commit: 17c422470de07821071759e3cd47a84861a54791 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Apr 7 12:17:43 2021 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Apr 7 12:17:43 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=17c42247
Linux patch 4.14.229 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1228_linux-4.14.229.patch | 1512 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1516 insertions(+) diff --git a/0000_README b/0000_README index f78a10d..cab5677 100644 --- a/0000_README +++ b/0000_README @@ -955,6 +955,10 @@ Patch: 1227_linux-4.14.228.patch From: https://www.kernel.org Desc: Linux 4.14.228 +Patch: 1228_linux-4.14.229.patch +From: https://www.kernel.org +Desc: Linux 4.14.229 + 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/1228_linux-4.14.229.patch b/1228_linux-4.14.229.patch new file mode 100644 index 0000000..5148e61 --- /dev/null +++ b/1228_linux-4.14.229.patch @@ -0,0 +1,1512 @@ +diff --git a/Makefile b/Makefile +index b30a6e708d5ee..f45576aeda9d3 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 14 +-SUBLEVEL = 228 ++SUBLEVEL = 229 + EXTRAVERSION = + NAME = Petit Gorille + +diff --git a/arch/powerpc/include/asm/cpu_has_feature.h b/arch/powerpc/include/asm/cpu_has_feature.h +index 7897d16e09904..727d4b3219379 100644 +--- a/arch/powerpc/include/asm/cpu_has_feature.h ++++ b/arch/powerpc/include/asm/cpu_has_feature.h +@@ -7,7 +7,7 @@ + #include <linux/bug.h> + #include <asm/cputable.h> + +-static inline bool early_cpu_has_feature(unsigned long feature) ++static __always_inline bool early_cpu_has_feature(unsigned long feature) + { + return !!((CPU_FTRS_ALWAYS & feature) || + (CPU_FTRS_POSSIBLE & cur_cpu_spec->cpu_features & feature)); +@@ -46,7 +46,7 @@ static __always_inline bool cpu_has_feature(unsigned long feature) + return static_branch_likely(&cpu_feature_keys[i]); + } + #else +-static inline bool cpu_has_feature(unsigned long feature) ++static __always_inline bool cpu_has_feature(unsigned long feature) + { + return early_cpu_has_feature(feature); + } +diff --git a/drivers/extcon/extcon.c b/drivers/extcon/extcon.c +index 95e96f04bf6fd..e9fe3e3bac2b1 100644 +--- a/drivers/extcon/extcon.c ++++ b/drivers/extcon/extcon.c +@@ -1252,6 +1252,7 @@ int extcon_dev_register(struct extcon_dev *edev) + sizeof(*edev->nh), GFP_KERNEL); + if (!edev->nh) { + ret = -ENOMEM; ++ device_unregister(&edev->dev); + goto err_dev; + } + +diff --git a/drivers/firewire/nosy.c b/drivers/firewire/nosy.c +index 180f0a96528ce..646dca0a8d73e 100644 +--- a/drivers/firewire/nosy.c ++++ b/drivers/firewire/nosy.c +@@ -359,6 +359,7 @@ nosy_ioctl(struct file *file, unsigned int cmd, unsigned long arg) + struct client *client = file->private_data; + spinlock_t *client_list_lock = &client->lynx->client_list_lock; + struct nosy_stats stats; ++ int ret; + + switch (cmd) { + case NOSY_IOC_GET_STATS: +@@ -373,11 +374,15 @@ nosy_ioctl(struct file *file, unsigned int cmd, unsigned long arg) + return 0; + + case NOSY_IOC_START: ++ ret = -EBUSY; + spin_lock_irq(client_list_lock); +- list_add_tail(&client->link, &client->lynx->client_list); ++ if (list_empty(&client->link)) { ++ list_add_tail(&client->link, &client->lynx->client_list); ++ ret = 0; ++ } + spin_unlock_irq(client_list_lock); + +- return 0; ++ return ret; + + case NOSY_IOC_STOP: + spin_lock_irq(client_list_lock); +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +index 863c6dd0123a2..57b1369aa5226 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +@@ -2074,8 +2074,8 @@ int amdgpu_vm_bo_map(struct amdgpu_device *adev, + uint64_t eaddr; + + /* validate the parameters */ +- if (saddr & AMDGPU_GPU_PAGE_MASK || offset & AMDGPU_GPU_PAGE_MASK || +- size == 0 || size & AMDGPU_GPU_PAGE_MASK) ++ if (saddr & ~PAGE_MASK || offset & ~PAGE_MASK || ++ size == 0 || size & ~PAGE_MASK) + return -EINVAL; + + /* make sure object fit at this offset */ +@@ -2142,8 +2142,8 @@ int amdgpu_vm_bo_replace_map(struct amdgpu_device *adev, + int r; + + /* validate the parameters */ +- if (saddr & AMDGPU_GPU_PAGE_MASK || offset & AMDGPU_GPU_PAGE_MASK || +- size == 0 || size & AMDGPU_GPU_PAGE_MASK) ++ if (saddr & ~PAGE_MASK || offset & ~PAGE_MASK || ++ size == 0 || size & ~PAGE_MASK) + return -EINVAL; + + /* make sure object fit at this offset */ +@@ -2285,7 +2285,7 @@ int amdgpu_vm_bo_clear_mappings(struct amdgpu_device *adev, + after->start = eaddr + 1; + after->last = tmp->last; + after->offset = tmp->offset; +- after->offset += after->start - tmp->start; ++ after->offset += (after->start - tmp->start) << PAGE_SHIFT; + after->flags = tmp->flags; + list_add(&after->list, &tmp->list); + } +diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_main.c b/drivers/net/ethernet/aquantia/atlantic/aq_main.c +index 5d6c40d86775d..2fb532053d6df 100644 +--- a/drivers/net/ethernet/aquantia/atlantic/aq_main.c ++++ b/drivers/net/ethernet/aquantia/atlantic/aq_main.c +@@ -60,8 +60,10 @@ static int aq_ndev_open(struct net_device *ndev) + if (err < 0) + goto err_exit; + err = aq_nic_start(aq_nic); +- if (err < 0) ++ if (err < 0) { ++ aq_nic_stop(aq_nic); + goto err_exit; ++ } + + err_exit: + if (err < 0) +diff --git a/drivers/net/wan/lmc/lmc_main.c b/drivers/net/wan/lmc/lmc_main.c +index bb43d176eb4e3..41b5c6b236d23 100644 +--- a/drivers/net/wan/lmc/lmc_main.c ++++ b/drivers/net/wan/lmc/lmc_main.c +@@ -922,6 +922,8 @@ static int lmc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) + break; + default: + printk(KERN_WARNING "%s: LMC UNKNOWN CARD!\n", dev->name); ++ unregister_hdlc_device(dev); ++ return -EIO; + break; + } + +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c +index 04fa66ed99a0f..b5fceba108062 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c +@@ -5381,7 +5381,8 @@ static bool brcmf_is_linkup(struct brcmf_cfg80211_vif *vif, + return false; + } + +-static bool brcmf_is_linkdown(const struct brcmf_event_msg *e) ++static bool brcmf_is_linkdown(struct brcmf_cfg80211_vif *vif, ++ const struct brcmf_event_msg *e) + { + u32 event = e->event_code; + u16 flags = e->flags; +@@ -5390,6 +5391,8 @@ static bool brcmf_is_linkdown(const struct brcmf_event_msg *e) + (event == BRCMF_E_DISASSOC_IND) || + ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) { + brcmf_dbg(CONN, "Processing link down\n"); ++ clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state); ++ clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state); + return true; + } + return false; +@@ -5674,7 +5677,7 @@ brcmf_notify_connect_status(struct brcmf_if *ifp, + } else + brcmf_bss_connect_done(cfg, ndev, e, true); + brcmf_net_setcarrier(ifp, true); +- } else if (brcmf_is_linkdown(e)) { ++ } else if (brcmf_is_linkdown(ifp->vif, e)) { + brcmf_dbg(CONN, "Linkdown\n"); + if (!brcmf_is_ibssmode(ifp->vif)) { + brcmf_bss_connect_done(cfg, ndev, e, false); +diff --git a/drivers/pinctrl/pinctrl-rockchip.c b/drivers/pinctrl/pinctrl-rockchip.c +index 26974973ecdde..d6b344163448e 100644 +--- a/drivers/pinctrl/pinctrl-rockchip.c ++++ b/drivers/pinctrl/pinctrl-rockchip.c +@@ -3121,12 +3121,15 @@ static int __maybe_unused rockchip_pinctrl_suspend(struct device *dev) + static int __maybe_unused rockchip_pinctrl_resume(struct device *dev) + { + struct rockchip_pinctrl *info = dev_get_drvdata(dev); +- int ret = regmap_write(info->regmap_base, RK3288_GRF_GPIO6C_IOMUX, +- rk3288_grf_gpio6c_iomux | +- GPIO6C6_SEL_WRITE_ENABLE); ++ int ret; + +- if (ret) +- return ret; ++ if (info->ctrl->type == RK3288) { ++ ret = regmap_write(info->regmap_base, RK3288_GRF_GPIO6C_IOMUX, ++ rk3288_grf_gpio6c_iomux | ++ GPIO6C6_SEL_WRITE_ENABLE); ++ if (ret) ++ return ret; ++ } + + return pinctrl_force_default(info->pctl_dev); + } +diff --git a/drivers/scsi/qla2xxx/qla_target.h b/drivers/scsi/qla2xxx/qla_target.h +index 511a31b359c7c..f51293540a610 100644 +--- a/drivers/scsi/qla2xxx/qla_target.h ++++ b/drivers/scsi/qla2xxx/qla_target.h +@@ -124,7 +124,6 @@ + (min(1270, ((ql) > 0) ? (QLA_TGT_DATASEGS_PER_CMD_24XX + \ + QLA_TGT_DATASEGS_PER_CONT_24XX*((ql) - 1)) : 0)) + #endif +-#endif + + #define GET_TARGET_ID(ha, iocb) ((HAS_EXTENDED_IDS(ha)) \ + ? le16_to_cpu((iocb)->u.isp2x.target.extended) \ +@@ -257,6 +256,7 @@ struct ctio_to_2xxx { + #ifndef CTIO_RET_TYPE + #define CTIO_RET_TYPE 0x17 /* CTIO return entry */ + #define ATIO_TYPE7 0x06 /* Accept target I/O entry for 24xx */ ++#endif + + struct fcp_hdr { + uint8_t r_ctl; +diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c +index 94e402ed30f6a..6497a6f12a6f3 100644 +--- a/drivers/scsi/st.c ++++ b/drivers/scsi/st.c +@@ -1268,8 +1268,8 @@ static int st_open(struct inode *inode, struct file *filp) + spin_lock(&st_use_lock); + if (STp->in_use) { + spin_unlock(&st_use_lock); +- scsi_tape_put(STp); + DEBC_printk(STp, "Device already in use.\n"); ++ scsi_tape_put(STp); + return (-EBUSY); + } + +diff --git a/drivers/staging/comedi/drivers/cb_pcidas.c b/drivers/staging/comedi/drivers/cb_pcidas.c +index 3ea15bb0e56ef..15b9cc8531f02 100644 +--- a/drivers/staging/comedi/drivers/cb_pcidas.c ++++ b/drivers/staging/comedi/drivers/cb_pcidas.c +@@ -1290,7 +1290,7 @@ static int cb_pcidas_auto_attach(struct comedi_device *dev, + devpriv->amcc + AMCC_OP_REG_INTCSR); + + ret = request_irq(pcidev->irq, cb_pcidas_interrupt, IRQF_SHARED, +- dev->board_name, dev); ++ "cb_pcidas", dev); + if (ret) { + dev_dbg(dev->class_dev, "unable to allocate irq %d\n", + pcidev->irq); +diff --git a/drivers/staging/comedi/drivers/cb_pcidas64.c b/drivers/staging/comedi/drivers/cb_pcidas64.c +index b761f000c1dc2..8c6ac7f37599b 100644 +--- a/drivers/staging/comedi/drivers/cb_pcidas64.c ++++ b/drivers/staging/comedi/drivers/cb_pcidas64.c +@@ -4032,7 +4032,7 @@ static int auto_attach(struct comedi_device *dev, + init_stc_registers(dev); + + retval = request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED, +- dev->board_name, dev); ++ "cb_pcidas64", dev); + if (retval) { + dev_dbg(dev->class_dev, "unable to allocate irq %u\n", + pcidev->irq); +diff --git a/drivers/staging/rtl8192e/rtllib.h b/drivers/staging/rtl8192e/rtllib.h +index 0042a0f6cf794..828b2f627965a 100644 +--- a/drivers/staging/rtl8192e/rtllib.h ++++ b/drivers/staging/rtl8192e/rtllib.h +@@ -1110,7 +1110,7 @@ struct rtllib_network { + bool bWithAironetIE; + bool bCkipSupported; + bool bCcxRmEnable; +- u16 CcxRmState[2]; ++ u8 CcxRmState[2]; + bool bMBssidValid; + u8 MBssidMask; + u8 MBssid[ETH_ALEN]; +diff --git a/drivers/staging/rtl8192e/rtllib_rx.c b/drivers/staging/rtl8192e/rtllib_rx.c +index 7bc9cb131bcc1..171009e821379 100644 +--- a/drivers/staging/rtl8192e/rtllib_rx.c ++++ b/drivers/staging/rtl8192e/rtllib_rx.c +@@ -1979,7 +1979,7 @@ static void rtllib_parse_mife_generic(struct rtllib_device *ieee, + info_element->data[2] == 0x96 && + info_element->data[3] == 0x01) { + if (info_element->len == 6) { +- memcpy(network->CcxRmState, &info_element[4], 2); ++ memcpy(network->CcxRmState, &info_element->data[4], 2); + if (network->CcxRmState[0] != 0) + network->bCcxRmEnable = true; + else +diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c +index 8d20e4ff1b803..b2f67d7ace6d8 100644 +--- a/drivers/usb/class/cdc-acm.c ++++ b/drivers/usb/class/cdc-acm.c +@@ -160,17 +160,29 @@ static inline int acm_set_control(struct acm *acm, int control) + #define acm_send_break(acm, ms) \ + acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0) + +-static void acm_kill_urbs(struct acm *acm) ++static void acm_poison_urbs(struct acm *acm) + { + int i; + +- usb_kill_urb(acm->ctrlurb); ++ usb_poison_urb(acm->ctrlurb); + for (i = 0; i < ACM_NW; i++) +- usb_kill_urb(acm->wb[i].urb); ++ usb_poison_urb(acm->wb[i].urb); + for (i = 0; i < acm->rx_buflimit; i++) +- usb_kill_urb(acm->read_urbs[i]); ++ usb_poison_urb(acm->read_urbs[i]); + } + ++static void acm_unpoison_urbs(struct acm *acm) ++{ ++ int i; ++ ++ for (i = 0; i < acm->rx_buflimit; i++) ++ usb_unpoison_urb(acm->read_urbs[i]); ++ for (i = 0; i < ACM_NW; i++) ++ usb_unpoison_urb(acm->wb[i].urb); ++ usb_unpoison_urb(acm->ctrlurb); ++} ++ ++ + /* + * Write buffer management. + * All of these assume proper locks taken by the caller. +@@ -238,9 +250,10 @@ static int acm_start_wb(struct acm *acm, struct acm_wb *wb) + + rc = usb_submit_urb(wb->urb, GFP_ATOMIC); + if (rc < 0) { +- dev_err(&acm->data->dev, +- "%s - usb_submit_urb(write bulk) failed: %d\n", +- __func__, rc); ++ if (rc != -EPERM) ++ dev_err(&acm->data->dev, ++ "%s - usb_submit_urb(write bulk) failed: %d\n", ++ __func__, rc); + acm_write_done(acm, wb); + } + return rc; +@@ -324,8 +337,10 @@ static void acm_process_notification(struct acm *acm, unsigned char *buf) + acm->iocount.dsr++; + if (difference & ACM_CTRL_DCD) + acm->iocount.dcd++; +- if (newctrl & ACM_CTRL_BRK) ++ if (newctrl & ACM_CTRL_BRK) { + acm->iocount.brk++; ++ tty_insert_flip_char(&acm->port, 0, TTY_BREAK); ++ } + if (newctrl & ACM_CTRL_RI) + acm->iocount.rng++; + if (newctrl & ACM_CTRL_FRAMING) +@@ -492,11 +507,6 @@ static void acm_read_bulk_callback(struct urb *urb) + dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n", + rb->index, urb->actual_length, status); + +- if (!acm->dev) { +- dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__); +- return; +- } +- + switch (status) { + case 0: + usb_mark_last_busy(acm->dev); +@@ -666,7 +676,8 @@ static void acm_port_dtr_rts(struct tty_port *port, int raise) + + res = acm_set_control(acm, val); + if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE)) +- dev_err(&acm->control->dev, "failed to set dtr/rts\n"); ++ /* This is broken in too many devices to spam the logs */ ++ dev_dbg(&acm->control->dev, "failed to set dtr/rts\n"); + } + + static int acm_port_activate(struct tty_port *port, struct tty_struct *tty) +@@ -751,6 +762,7 @@ static void acm_port_shutdown(struct tty_port *port) + * Need to grab write_lock to prevent race with resume, but no need to + * hold it due to the tty-port initialised flag. + */ ++ acm_poison_urbs(acm); + spin_lock_irq(&acm->write_lock); + spin_unlock_irq(&acm->write_lock); + +@@ -767,7 +779,8 @@ static void acm_port_shutdown(struct tty_port *port) + usb_autopm_put_interface_async(acm->control); + } + +- acm_kill_urbs(acm); ++ acm_unpoison_urbs(acm); ++ + } + + static void acm_tty_cleanup(struct tty_struct *tty) +@@ -1559,6 +1572,11 @@ skip_countries: + + return 0; + alloc_fail8: ++ if (!acm->combined_interfaces) { ++ /* Clear driver data so that disconnect() returns early. */ ++ usb_set_intfdata(data_interface, NULL); ++ usb_driver_release_interface(&acm_driver, data_interface); ++ } + if (acm->country_codes) { + device_remove_file(&acm->control->dev, + &dev_attr_wCountryCodes); +@@ -1598,8 +1616,14 @@ static void acm_disconnect(struct usb_interface *intf) + if (!acm) + return; + +- mutex_lock(&acm->mutex); + acm->disconnected = true; ++ /* ++ * there is a circular dependency. acm_softint() can resubmit ++ * the URBs in error handling so we need to block any ++ * submission right away ++ */ ++ acm_poison_urbs(acm); ++ mutex_lock(&acm->mutex); + if (acm->country_codes) { + device_remove_file(&acm->control->dev, + &dev_attr_wCountryCodes); +@@ -1618,7 +1642,6 @@ static void acm_disconnect(struct usb_interface *intf) + tty_kref_put(tty); + } + +- acm_kill_urbs(acm); + cancel_delayed_work_sync(&acm->dwork); + + tty_unregister_device(acm_tty_driver, acm->minor); +@@ -1660,7 +1683,7 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message) + if (cnt) + return 0; + +- acm_kill_urbs(acm); ++ acm_poison_urbs(acm); + cancel_delayed_work_sync(&acm->dwork); + acm->urbs_in_error_delay = 0; + +@@ -1673,6 +1696,7 @@ static int acm_resume(struct usb_interface *intf) + struct urb *urb; + int rv = 0; + ++ acm_unpoison_urbs(acm); + spin_lock_irq(&acm->write_lock); + + if (--acm->susp_count) +diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c +index 2fc735efc3dc5..cd43e11d74f34 100644 +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -321,6 +321,10 @@ static const struct usb_device_id usb_quirk_list[] = { + /* DJI CineSSD */ + { USB_DEVICE(0x2ca3, 0x0031), .driver_info = USB_QUIRK_NO_LPM }, + ++ /* Fibocom L850-GL LTE Modem */ ++ { USB_DEVICE(0x2cb7, 0x0007), .driver_info = ++ USB_QUIRK_IGNORE_REMOTE_WAKEUP }, ++ + /* INTEL VALUE SSD */ + { USB_DEVICE(0x8086, 0xf1a5), .driver_info = USB_QUIRK_RESET_RESUME }, + +diff --git a/drivers/usb/gadget/udc/amd5536udc_pci.c b/drivers/usb/gadget/udc/amd5536udc_pci.c +index 57a13f080a791..73413c1211cbd 100644 +--- a/drivers/usb/gadget/udc/amd5536udc_pci.c ++++ b/drivers/usb/gadget/udc/amd5536udc_pci.c +@@ -158,6 +158,11 @@ static int udc_pci_probe( + pci_set_master(pdev); + pci_try_set_mwi(pdev); + ++ dev->phys_addr = resource; ++ dev->irq = pdev->irq; ++ dev->pdev = pdev; ++ dev->dev = &pdev->dev; ++ + /* init dma pools */ + if (use_dma) { + retval = init_dma_pools(dev); +@@ -165,11 +170,6 @@ static int udc_pci_probe( + goto err_dma; + } + +- dev->phys_addr = resource; +- dev->irq = pdev->irq; +- dev->pdev = pdev; +- dev->dev = &pdev->dev; +- + /* general probing */ + if (udc_probe(dev)) { + retval = -ENODEV; +diff --git a/drivers/usb/host/xhci-mtk.c b/drivers/usb/host/xhci-mtk.c +index 945e108cffb8d..5ad2972114e03 100644 +--- a/drivers/usb/host/xhci-mtk.c ++++ b/drivers/usb/host/xhci-mtk.c +@@ -487,6 +487,13 @@ static void xhci_mtk_quirks(struct device *dev, struct xhci_hcd *xhci) + xhci->quirks |= XHCI_SPURIOUS_SUCCESS; + if (mtk->lpm_support) + xhci->quirks |= XHCI_LPM_SUPPORT; ++ ++ /* ++ * MTK xHCI 0.96: PSA is 1 by default even if doesn't support stream, ++ * and it's 3 when support it. ++ */ ++ if (xhci->hci_version < 0x100 && HCC_MAX_PSA(xhci->hcc_params) == 4) ++ xhci->quirks |= XHCI_BROKEN_STREAMS; + } + + /* called during probe() after chip reset completes */ +@@ -681,7 +688,8 @@ static int xhci_mtk_probe(struct platform_device *pdev) + if (ret) + goto put_usb3_hcd; + +- if (HCC_MAX_PSA(xhci->hcc_params) >= 4) ++ if (HCC_MAX_PSA(xhci->hcc_params) >= 4 && ++ !(xhci->quirks & XHCI_BROKEN_STREAMS)) + xhci->shared_hcd->can_do_streams = 1; + + ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED); +diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c +index 97b2feae36f78..9ed604ddbb585 100644 +--- a/drivers/usb/musb/musb_core.c ++++ b/drivers/usb/musb/musb_core.c +@@ -1864,10 +1864,14 @@ static void musb_pm_runtime_check_session(struct musb *musb) + MUSB_DEVCTL_HR; + switch (devctl & ~s) { + case MUSB_QUIRK_B_DISCONNECT_99: +- musb_dbg(musb, "Poll devctl in case of suspend after disconnect\n"); +- schedule_delayed_work(&musb->irq_work, +- msecs_to_jiffies(1000)); +- break; ++ if (musb->quirk_retries && !musb->flush_irq_work) { ++ musb_dbg(musb, "Poll devctl in case of suspend after disconnect\n"); ++ schedule_delayed_work(&musb->irq_work, ++ msecs_to_jiffies(1000)); ++ musb->quirk_retries--; ++ break; ++ } ++ /* fall through */ + case MUSB_QUIRK_B_INVALID_VBUS_91: + if (musb->quirk_retries && !musb->flush_irq_work) { + musb_dbg(musb, +diff --git a/drivers/usb/usbip/vhci_hcd.c b/drivers/usb/usbip/vhci_hcd.c +index ba1dcd222d7fa..d87159e6c716d 100644 +--- a/drivers/usb/usbip/vhci_hcd.c ++++ b/drivers/usb/usbip/vhci_hcd.c +@@ -608,6 +608,8 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, + pr_err("invalid port number %d\n", wIndex); + goto error; + } ++ if (wValue >= 32) ++ goto error; + if (hcd->speed == HCD_USB3) { + if ((vhci_hcd->port_status[rhport] & + USB_SS_PORT_STAT_POWER) != 0) { +diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c +index 3d7bea15c57bc..4b5590f4e98ba 100644 +--- a/drivers/vhost/vhost.c ++++ b/drivers/vhost/vhost.c +@@ -324,8 +324,8 @@ static void vhost_vq_reset(struct vhost_dev *dev, + vq->call_ctx = NULL; + vq->call = NULL; + vq->log_ctx = NULL; +- vhost_reset_is_le(vq); + vhost_disable_cross_endian(vq); ++ vhost_reset_is_le(vq); + vq->busyloop_timeout = 0; + vq->umem = NULL; + vq->iotlb = NULL; +diff --git a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c +index 6bdf9ca787fbf..75e219ec8125a 100644 +--- a/drivers/video/fbdev/core/fbcon.c ++++ b/drivers/video/fbdev/core/fbcon.c +@@ -1284,6 +1284,9 @@ static void fbcon_cursor(struct vc_data *vc, int mode) + + ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1; + ++ if (!ops->cursor) ++ return; ++ + ops->cursor(vc, info, mode, get_color(vc, info, c, 1), + get_color(vc, info, c, 0)); + } +diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c +index ad6a1282a5cdd..9c07c8674b216 100644 +--- a/fs/ext4/inode.c ++++ b/fs/ext4/inode.c +@@ -2071,13 +2071,13 @@ static int __ext4_journalled_writepage(struct page *page, + if (!ret) + ret = err; + +- if (!ext4_has_inline_data(inode)) +- ext4_walk_page_buffers(NULL, page_bufs, 0, len, +- NULL, bput_one); + ext4_set_inode_state(inode, EXT4_STATE_JDATA); + out: + unlock_page(page); + out_no_pagelock: ++ if (!inline_data && page_bufs) ++ ext4_walk_page_buffers(NULL, page_bufs, 0, len, ++ NULL, bput_one); + brelse(inode_bh); + return ret; + } +diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c +index 647d4a8d6b68b..b4ec5a41797b8 100644 +--- a/fs/ext4/namei.c ++++ b/fs/ext4/namei.c +@@ -3635,7 +3635,7 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry, + */ + retval = -ENOENT; + if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino) +- goto end_rename; ++ goto release_bh; + + if ((old.dir != new.dir) && + ext4_encrypted_inode(new.dir) && +@@ -3649,7 +3649,7 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry, + if (IS_ERR(new.bh)) { + retval = PTR_ERR(new.bh); + new.bh = NULL; +- goto end_rename; ++ goto release_bh; + } + if (new.bh) { + if (!new.inode) { +@@ -3666,15 +3666,13 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry, + handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits); + if (IS_ERR(handle)) { + retval = PTR_ERR(handle); +- handle = NULL; +- goto end_rename; ++ goto release_bh; + } + } else { + whiteout = ext4_whiteout_for_rename(&old, credits, &handle); + if (IS_ERR(whiteout)) { + retval = PTR_ERR(whiteout); +- whiteout = NULL; +- goto end_rename; ++ goto release_bh; + } + } + +@@ -3782,16 +3780,18 @@ end_rename: + ext4_resetent(handle, &old, + old.inode->i_ino, old_file_type); + drop_nlink(whiteout); ++ ext4_orphan_add(handle, whiteout); + } + unlock_new_inode(whiteout); ++ ext4_journal_stop(handle); + iput(whiteout); +- ++ } else { ++ ext4_journal_stop(handle); + } ++release_bh: + brelse(old.dir_bh); + brelse(old.bh); + brelse(new.bh); +- if (handle) +- ext4_journal_stop(handle); + return retval; + } + +diff --git a/fs/reiserfs/xattr.h b/fs/reiserfs/xattr.h +index c764352447ba1..81bec2c80b25c 100644 +--- a/fs/reiserfs/xattr.h ++++ b/fs/reiserfs/xattr.h +@@ -43,7 +43,7 @@ void reiserfs_security_free(struct reiserfs_security_handle *sec); + + static inline int reiserfs_xattrs_initialized(struct super_block *sb) + { +- return REISERFS_SB(sb)->priv_root != NULL; ++ return REISERFS_SB(sb)->priv_root && REISERFS_SB(sb)->xattr_root; + } + + #define xattr_size(size) ((size) + sizeof(struct reiserfs_xattr_header)) +diff --git a/include/linux/extcon.h b/include/linux/extcon.h +index 744d60ca80c32..8f4dc784ab90e 100644 +--- a/include/linux/extcon.h ++++ b/include/linux/extcon.h +@@ -377,6 +377,29 @@ static inline void devm_extcon_unregister_notifier(struct device *dev, + struct extcon_dev *edev, unsigned int id, + struct notifier_block *nb) { } + ++static inline int extcon_register_notifier_all(struct extcon_dev *edev, ++ struct notifier_block *nb) ++{ ++ return 0; ++} ++ ++static inline int extcon_unregister_notifier_all(struct extcon_dev *edev, ++ struct notifier_block *nb) ++{ ++ return 0; ++} ++ ++static inline int devm_extcon_register_notifier_all(struct device *dev, ++ struct extcon_dev *edev, ++ struct notifier_block *nb) ++{ ++ return 0; ++} ++ ++static inline void devm_extcon_unregister_notifier_all(struct device *dev, ++ struct extcon_dev *edev, ++ struct notifier_block *nb) { } ++ + static inline struct extcon_dev *extcon_get_extcon_dev(const char *extcon_name) + { + return ERR_PTR(-ENODEV); +diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h +index 8820468635810..365d5079d1cba 100644 +--- a/include/linux/memcontrol.h ++++ b/include/linux/memcontrol.h +@@ -48,13 +48,13 @@ enum memcg_stat_item { + MEMCG_NR_STAT, + }; + +-/* Cgroup-specific events, on top of universal VM events */ +-enum memcg_event_item { +- MEMCG_LOW = NR_VM_EVENT_ITEMS, ++enum memcg_memory_event { ++ MEMCG_LOW, + MEMCG_HIGH, + MEMCG_MAX, + MEMCG_OOM, +- MEMCG_NR_EVENTS, ++ MEMCG_OOM_KILL, ++ MEMCG_NR_MEMORY_EVENTS, + }; + + struct mem_cgroup_reclaim_cookie { +@@ -88,7 +88,7 @@ enum mem_cgroup_events_target { + + struct mem_cgroup_stat_cpu { + long count[MEMCG_NR_STAT]; +- unsigned long events[MEMCG_NR_EVENTS]; ++ unsigned long events[NR_VM_EVENT_ITEMS]; + unsigned long nr_page_events; + unsigned long targets[MEM_CGROUP_NTARGETS]; + }; +@@ -156,6 +156,15 @@ enum memcg_kmem_state { + KMEM_ONLINE, + }; + ++#if defined(CONFIG_SMP) ++struct memcg_padding { ++ char x[0]; ++} ____cacheline_internodealigned_in_smp; ++#define MEMCG_PADDING(name) struct memcg_padding name; ++#else ++#define MEMCG_PADDING(name) ++#endif ++ + /* + * The memory controller data structure. The memory controller controls both + * page cache and RSS per cgroup. We would eventually like to provide +@@ -202,7 +211,7 @@ struct mem_cgroup { + /* OOM-Killer disable */ + int oom_kill_disable; + +- /* handle for "memory.events" */ ++ /* memory.events */ + struct cgroup_file events_file; + + /* protect arrays of thresholds */ +@@ -222,18 +231,26 @@ struct mem_cgroup { + * mem_cgroup ? And what type of charges should we move ? + */ + unsigned long move_charge_at_immigrate; ++ /* taken only while moving_account > 0 */ ++ spinlock_t move_lock; ++ unsigned long move_lock_flags; ++ ++ MEMCG_PADDING(_pad1_); ++ + /* + * set > 0 if pages under this cgroup are moving to other cgroup. + */ + atomic_t moving_account; +- /* taken only while moving_account > 0 */ +- spinlock_t move_lock; + struct task_struct *move_lock_task; +- unsigned long move_lock_flags; + ++ /* memory.stat */ + struct mem_cgroup_stat_cpu __percpu *stat_cpu; ++ ++ MEMCG_PADDING(_pad2_); ++ + atomic_long_t stat[MEMCG_NR_STAT]; +- atomic_long_t events[MEMCG_NR_EVENTS]; ++ atomic_long_t events[NR_VM_EVENT_ITEMS]; ++ atomic_long_t memory_events[MEMCG_NR_MEMORY_EVENTS]; + + unsigned long socket_pressure; + +@@ -490,7 +507,10 @@ struct mem_cgroup *lock_page_memcg(struct page *page); + void __unlock_page_memcg(struct mem_cgroup *memcg); + void unlock_page_memcg(struct page *page); + +-/* idx can be of type enum memcg_stat_item or node_stat_item */ ++/* ++ * idx can be of type enum memcg_stat_item or node_stat_item. ++ * Keep in sync with memcg_exact_page_state(). ++ */ + static inline unsigned long memcg_page_state(struct mem_cgroup *memcg, + int idx) + { +@@ -523,9 +543,11 @@ static inline void __mod_memcg_state(struct mem_cgroup *memcg, + static inline void mod_memcg_state(struct mem_cgroup *memcg, + int idx, int val) + { +- preempt_disable(); ++ unsigned long flags; ++ ++ local_irq_save(flags); + __mod_memcg_state(memcg, idx, val); +- preempt_enable(); ++ local_irq_restore(flags); + } + + /** +@@ -606,9 +628,11 @@ static inline void __mod_lruvec_state(struct lruvec *lruvec, + static inline void mod_lruvec_state(struct lruvec *lruvec, + enum node_stat_item idx, int val) + { +- preempt_disable(); ++ unsigned long flags; ++ ++ local_irq_save(flags); + __mod_lruvec_state(lruvec, idx, val); +- preempt_enable(); ++ local_irq_restore(flags); + } + + static inline void __mod_lruvec_page_state(struct page *page, +@@ -630,18 +654,20 @@ static inline void __mod_lruvec_page_state(struct page *page, + static inline void mod_lruvec_page_state(struct page *page, + enum node_stat_item idx, int val) + { +- preempt_disable(); ++ unsigned long flags; ++ ++ local_irq_save(flags); + __mod_lruvec_page_state(page, idx, val); +- preempt_enable(); ++ local_irq_restore(flags); + } + + unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order, + gfp_t gfp_mask, + unsigned long *total_scanned); + +-/* idx can be of type enum memcg_event_item or vm_event_item */ + static inline void __count_memcg_events(struct mem_cgroup *memcg, +- int idx, unsigned long count) ++ enum vm_event_item idx, ++ unsigned long count) + { + unsigned long x; + +@@ -657,16 +683,18 @@ static inline void __count_memcg_events(struct mem_cgroup *memcg, + } + + static inline void count_memcg_events(struct mem_cgroup *memcg, +- int idx, unsigned long count) ++ enum vm_event_item idx, ++ unsigned long count) + { +- preempt_disable(); ++ unsigned long flags; ++ ++ local_irq_save(flags); + __count_memcg_events(memcg, idx, count); +- preempt_enable(); ++ local_irq_restore(flags); + } + +-/* idx can be of type enum memcg_event_item or vm_event_item */ + static inline void count_memcg_page_event(struct page *page, +- int idx) ++ enum vm_event_item idx) + { + if (page->mem_cgroup) + count_memcg_events(page->mem_cgroup, idx, 1); +@@ -682,21 +710,33 @@ static inline void count_memcg_event_mm(struct mm_struct *mm, + + rcu_read_lock(); + memcg = mem_cgroup_from_task(rcu_dereference(mm->owner)); +- if (likely(memcg)) { ++ if (likely(memcg)) + count_memcg_events(memcg, idx, 1); +- if (idx == OOM_KILL) +- cgroup_file_notify(&memcg->events_file); +- } + rcu_read_unlock(); + } + +-static inline void mem_cgroup_event(struct mem_cgroup *memcg, +- enum memcg_event_item event) ++static inline void memcg_memory_event(struct mem_cgroup *memcg, ++ enum memcg_memory_event event) + { +- count_memcg_events(memcg, event, 1); ++ atomic_long_inc(&memcg->memory_events[event]); + cgroup_file_notify(&memcg->events_file); + } + ++static inline void memcg_memory_event_mm(struct mm_struct *mm, ++ enum memcg_memory_event event) ++{ ++ struct mem_cgroup *memcg; ++ ++ if (mem_cgroup_disabled()) ++ return; ++ ++ rcu_read_lock(); ++ memcg = mem_cgroup_from_task(rcu_dereference(mm->owner)); ++ if (likely(memcg)) ++ memcg_memory_event(memcg, event); ++ rcu_read_unlock(); ++} ++ + #ifdef CONFIG_TRANSPARENT_HUGEPAGE + void mem_cgroup_split_huge_fixup(struct page *head); + #endif +@@ -713,8 +753,13 @@ static inline bool mem_cgroup_disabled(void) + return true; + } + +-static inline void mem_cgroup_event(struct mem_cgroup *memcg, +- enum memcg_event_item event) ++static inline void memcg_memory_event(struct mem_cgroup *memcg, ++ enum memcg_memory_event event) ++{ ++} ++ ++static inline void memcg_memory_event_mm(struct mm_struct *mm, ++ enum memcg_memory_event event) + { + } + +diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c +index 3a0691c647044..ba966b9103783 100644 +--- a/kernel/trace/trace.c ++++ b/kernel/trace/trace.c +@@ -2631,7 +2631,8 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer, + size *= sizeof(unsigned long); + + event = __trace_buffer_lock_reserve(buffer, TRACE_STACK, +- sizeof(*entry) + size, flags, pc); ++ (sizeof(*entry) - sizeof(entry->caller)) + size, ++ flags, pc); + if (!event) + goto out; + entry = ring_buffer_event_data(event); +diff --git a/mm/memcontrol.c b/mm/memcontrol.c +index 4e763cdccb335..5e8b8e1b7d90d 100644 +--- a/mm/memcontrol.c ++++ b/mm/memcontrol.c +@@ -1872,7 +1872,7 @@ static int memcg_hotplug_cpu_dead(unsigned int cpu) + } + } + +- for (i = 0; i < MEMCG_NR_EVENTS; i++) { ++ for (i = 0; i < NR_VM_EVENT_ITEMS; i++) { + long x; + + x = this_cpu_xchg(memcg->stat_cpu->events[i], 0); +@@ -1891,7 +1891,7 @@ static void reclaim_high(struct mem_cgroup *memcg, + do { + if (page_counter_read(&memcg->memory) <= memcg->high) + continue; +- mem_cgroup_event(memcg, MEMCG_HIGH); ++ memcg_memory_event(memcg, MEMCG_HIGH); + try_to_free_mem_cgroup_pages(memcg, nr_pages, gfp_mask, true); + } while ((memcg = parent_mem_cgroup(memcg))); + } +@@ -1982,7 +1982,7 @@ retry: + if (!gfpflags_allow_blocking(gfp_mask)) + goto nomem; + +- mem_cgroup_event(mem_over_limit, MEMCG_MAX); ++ memcg_memory_event(mem_over_limit, MEMCG_MAX); + + nr_reclaimed = try_to_free_mem_cgroup_pages(mem_over_limit, nr_pages, + gfp_mask, may_swap); +@@ -2025,7 +2025,7 @@ retry: + if (fatal_signal_pending(current)) + goto force; + +- mem_cgroup_event(mem_over_limit, MEMCG_OOM); ++ memcg_memory_event(mem_over_limit, MEMCG_OOM); + + mem_cgroup_oom(mem_over_limit, gfp_mask, + get_order(nr_pages * PAGE_SIZE)); +@@ -2790,10 +2790,10 @@ static void tree_events(struct mem_cgroup *memcg, unsigned long *events) + struct mem_cgroup *iter; + int i; + +- memset(events, 0, sizeof(*events) * MEMCG_NR_EVENTS); ++ memset(events, 0, sizeof(*events) * NR_VM_EVENT_ITEMS); + + for_each_mem_cgroup_tree(iter, memcg) { +- for (i = 0; i < MEMCG_NR_EVENTS; i++) ++ for (i = 0; i < NR_VM_EVENT_ITEMS; i++) + events[i] += memcg_sum_events(iter, i); + } + } +@@ -3648,7 +3648,8 @@ static int mem_cgroup_oom_control_read(struct seq_file *sf, void *v) + + seq_printf(sf, "oom_kill_disable %d\n", memcg->oom_kill_disable); + seq_printf(sf, "under_oom %d\n", (bool)memcg->under_oom); +- seq_printf(sf, "oom_kill %lu\n", memcg_sum_events(memcg, OOM_KILL)); ++ seq_printf(sf, "oom_kill %lu\n", ++ atomic_long_read(&memcg->memory_events[MEMCG_OOM_KILL])); + return 0; + } + +@@ -3700,6 +3701,22 @@ struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb) + return &memcg->cgwb_domain; + } + ++/* ++ * idx can be of type enum memcg_stat_item or node_stat_item. ++ * Keep in sync with memcg_exact_page(). ++ */ ++static unsigned long memcg_exact_page_state(struct mem_cgroup *memcg, int idx) ++{ ++ long x = atomic_long_read(&memcg->stat[idx]); ++ int cpu; ++ ++ for_each_online_cpu(cpu) ++ x += per_cpu_ptr(memcg->stat_cpu, cpu)->count[idx]; ++ if (x < 0) ++ x = 0; ++ return x; ++} ++ + /** + * mem_cgroup_wb_stats - retrieve writeback related stats from its memcg + * @wb: bdi_writeback in question +@@ -3725,10 +3742,10 @@ void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages, + struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css); + struct mem_cgroup *parent; + +- *pdirty = memcg_page_state(memcg, NR_FILE_DIRTY); ++ *pdirty = memcg_exact_page_state(memcg, NR_FILE_DIRTY); + + /* this should eventually include NR_UNSTABLE_NFS */ +- *pwriteback = memcg_page_state(memcg, NR_WRITEBACK); ++ *pwriteback = memcg_exact_page_state(memcg, NR_WRITEBACK); + *pfilepages = mem_cgroup_nr_lru_pages(memcg, (1 << LRU_INACTIVE_FILE) | + (1 << LRU_ACTIVE_FILE)); + *pheadroom = PAGE_COUNTER_MAX; +@@ -5299,7 +5316,7 @@ static ssize_t memory_max_write(struct kernfs_open_file *of, + continue; + } + +- mem_cgroup_event(memcg, MEMCG_OOM); ++ memcg_memory_event(memcg, MEMCG_OOM); + if (!mem_cgroup_out_of_memory(memcg, GFP_KERNEL, 0)) + break; + } +@@ -5312,11 +5329,16 @@ static int memory_events_show(struct seq_file *m, void *v) + { + struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m)); + +- seq_printf(m, "low %lu\n", memcg_sum_events(memcg, MEMCG_LOW)); +- seq_printf(m, "high %lu\n", memcg_sum_events(memcg, MEMCG_HIGH)); +- seq_printf(m, "max %lu\n", memcg_sum_events(memcg, MEMCG_MAX)); +- seq_printf(m, "oom %lu\n", memcg_sum_events(memcg, MEMCG_OOM)); +- seq_printf(m, "oom_kill %lu\n", memcg_sum_events(memcg, OOM_KILL)); ++ seq_printf(m, "low %lu\n", ++ atomic_long_read(&memcg->memory_events[MEMCG_LOW])); ++ seq_printf(m, "high %lu\n", ++ atomic_long_read(&memcg->memory_events[MEMCG_HIGH])); ++ seq_printf(m, "max %lu\n", ++ atomic_long_read(&memcg->memory_events[MEMCG_MAX])); ++ seq_printf(m, "oom %lu\n", ++ atomic_long_read(&memcg->memory_events[MEMCG_OOM])); ++ seq_printf(m, "oom_kill %lu\n", ++ atomic_long_read(&memcg->memory_events[MEMCG_OOM_KILL])); + + return 0; + } +@@ -5325,7 +5347,7 @@ static int memory_stat_show(struct seq_file *m, void *v) + { + struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m)); + unsigned long stat[MEMCG_NR_STAT]; +- unsigned long events[MEMCG_NR_EVENTS]; ++ unsigned long events[NR_VM_EVENT_ITEMS]; + int i; + + /* +diff --git a/mm/memory.c b/mm/memory.c +index 21a0bbb9c21fb..c4f142d1ff98f 100644 +--- a/mm/memory.c ++++ b/mm/memory.c +@@ -149,7 +149,7 @@ static int __init init_zero_pfn(void) + zero_pfn = page_to_pfn(ZERO_PAGE(0)); + return 0; + } +-core_initcall(init_zero_pfn); ++early_initcall(init_zero_pfn); + + + #if defined(SPLIT_RSS_COUNTING) +diff --git a/mm/oom_kill.c b/mm/oom_kill.c +index 6482d743c5c88..6f1bed2111226 100644 +--- a/mm/oom_kill.c ++++ b/mm/oom_kill.c +@@ -917,7 +917,7 @@ static void oom_kill_process(struct oom_control *oc, const char *message) + + /* Raise event before sending signal: task reaper must see this */ + count_vm_event(OOM_KILL); +- count_memcg_event_mm(mm, OOM_KILL); ++ memcg_memory_event_mm(mm, MEMCG_OOM_KILL); + + /* + * We should send SIGKILL before granting access to memory reserves +diff --git a/mm/vmscan.c b/mm/vmscan.c +index 5ee6fbdec8a8d..b37e6dd509253 100644 +--- a/mm/vmscan.c ++++ b/mm/vmscan.c +@@ -2628,7 +2628,7 @@ static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc) + sc->memcg_low_skipped = 1; + continue; + } +- mem_cgroup_event(memcg, MEMCG_LOW); ++ memcg_memory_event(memcg, MEMCG_LOW); + } + + reclaimed = sc->nr_reclaimed; +diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c +index b4268bd2e5577..36a67e62710ce 100644 +--- a/net/appletalk/ddp.c ++++ b/net/appletalk/ddp.c +@@ -1575,8 +1575,8 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) + struct sk_buff *skb; + struct net_device *dev; + struct ddpehdr *ddp; +- int size; +- struct atalk_route *rt; ++ int size, hard_header_len; ++ struct atalk_route *rt, *rt_lo = NULL; + int err; + + if (flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT)) +@@ -1639,7 +1639,22 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) + SOCK_DEBUG(sk, "SK %p: Size needed %d, device %s\n", + sk, size, dev->name); + +- size += dev->hard_header_len; ++ hard_header_len = dev->hard_header_len; ++ /* Leave room for loopback hardware header if necessary */ ++ if (usat->sat_addr.s_node == ATADDR_BCAST && ++ (dev->flags & IFF_LOOPBACK || !(rt->flags & RTF_GATEWAY))) { ++ struct atalk_addr at_lo; ++ ++ at_lo.s_node = 0; ++ at_lo.s_net = 0; ++ ++ rt_lo = atrtr_find(&at_lo); ++ ++ if (rt_lo && rt_lo->dev->hard_header_len > hard_header_len) ++ hard_header_len = rt_lo->dev->hard_header_len; ++ } ++ ++ size += hard_header_len; + release_sock(sk); + skb = sock_alloc_send_skb(sk, size, (flags & MSG_DONTWAIT), &err); + lock_sock(sk); +@@ -1647,7 +1662,7 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) + goto out; + + skb_reserve(skb, ddp_dl->header_length); +- skb_reserve(skb, dev->hard_header_len); ++ skb_reserve(skb, hard_header_len); + skb->dev = dev; + + SOCK_DEBUG(sk, "SK %p: Begin build.\n", sk); +@@ -1698,18 +1713,12 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) + /* loop back */ + skb_orphan(skb); + if (ddp->deh_dnode == ATADDR_BCAST) { +- struct atalk_addr at_lo; +- +- at_lo.s_node = 0; +- at_lo.s_net = 0; +- +- rt = atrtr_find(&at_lo); +- if (!rt) { ++ if (!rt_lo) { + kfree_skb(skb); + err = -ENETUNREACH; + goto out; + } +- dev = rt->dev; ++ dev = rt_lo->dev; + skb->dev = dev; + } + ddp_dl->request(ddp_dl, skb, dev->dev_addr); +diff --git a/net/core/filter.c b/net/core/filter.c +index a3646230fbeee..a33cf7b28e4d7 100644 +--- a/net/core/filter.c ++++ b/net/core/filter.c +@@ -2279,17 +2279,14 @@ static int bpf_skb_net_shrink(struct sk_buff *skb, u32 len_diff) + return 0; + } + +-static u32 __bpf_skb_max_len(const struct sk_buff *skb) +-{ +- return skb->dev->mtu + skb->dev->hard_header_len; +-} ++#define BPF_SKB_MAX_LEN SKB_MAX_ALLOC + + static int bpf_skb_adjust_net(struct sk_buff *skb, s32 len_diff) + { + bool trans_same = skb->transport_header == skb->network_header; + u32 len_cur, len_diff_abs = abs(len_diff); + u32 len_min = bpf_skb_net_base_len(skb); +- u32 len_max = __bpf_skb_max_len(skb); ++ u32 len_max = BPF_SKB_MAX_LEN; + __be16 proto = skb->protocol; + bool shrink = len_diff < 0; + int ret; +@@ -2368,7 +2365,7 @@ static int bpf_skb_trim_rcsum(struct sk_buff *skb, unsigned int new_len) + BPF_CALL_3(bpf_skb_change_tail, struct sk_buff *, skb, u32, new_len, + u64, flags) + { +- u32 max_len = __bpf_skb_max_len(skb); ++ u32 max_len = BPF_SKB_MAX_LEN; + u32 min_len = __bpf_skb_min_len(skb); + int ret; + +@@ -2419,7 +2416,7 @@ static const struct bpf_func_proto bpf_skb_change_tail_proto = { + BPF_CALL_3(bpf_skb_change_head, struct sk_buff *, skb, u32, head_room, + u64, flags) + { +- u32 max_len = __bpf_skb_max_len(skb); ++ u32 max_len = BPF_SKB_MAX_LEN; + u32 new_len = skb->len + head_room; + int ret; + +diff --git a/net/dccp/ipv6.c b/net/dccp/ipv6.c +index b438bed6749d4..2cd3508a37869 100644 +--- a/net/dccp/ipv6.c ++++ b/net/dccp/ipv6.c +@@ -319,6 +319,11 @@ static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb) + if (!ipv6_unicast_destination(skb)) + return 0; /* discard, don't send a reset here */ + ++ if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) { ++ __IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS); ++ return 0; ++ } ++ + if (dccp_bad_service_code(sk, service)) { + dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE; + goto drop; +diff --git a/net/ipv6/ip6_input.c b/net/ipv6/ip6_input.c +index e41070fb4fc09..9ee208a348f55 100644 +--- a/net/ipv6/ip6_input.c ++++ b/net/ipv6/ip6_input.c +@@ -173,16 +173,6 @@ int ipv6_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt + if (ipv6_addr_is_multicast(&hdr->saddr)) + goto err; + +- /* While RFC4291 is not explicit about v4mapped addresses +- * in IPv6 headers, it seems clear linux dual-stack +- * model can not deal properly with these. +- * Security models could be fooled by ::ffff:127.0.0.1 for example. +- * +- * https://tools.ietf.org/html/draft-itojun-v6ops-v4mapped-harmful-02 +- */ +- if (ipv6_addr_v4mapped(&hdr->saddr)) +- goto err; +- + skb->transport_header = skb->network_header + sizeof(*hdr); + IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr); + +diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c +index a516490de3dbb..037958ccc9f57 100644 +--- a/net/ipv6/tcp_ipv6.c ++++ b/net/ipv6/tcp_ipv6.c +@@ -1013,6 +1013,11 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) + if (!ipv6_unicast_destination(skb)) + goto drop; + ++ if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) { ++ __IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS); ++ return 0; ++ } ++ + return tcp_conn_request(&tcp6_request_sock_ops, + &tcp_request_sock_ipv6_ops, sk, skb); + +diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c +index 03043d5221e92..27dfd85830d82 100644 +--- a/net/sunrpc/auth_gss/svcauth_gss.c ++++ b/net/sunrpc/auth_gss/svcauth_gss.c +@@ -1713,11 +1713,14 @@ static int + svcauth_gss_release(struct svc_rqst *rqstp) + { + struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data; +- struct rpc_gss_wire_cred *gc = &gsd->clcred; ++ struct rpc_gss_wire_cred *gc; + struct xdr_buf *resbuf = &rqstp->rq_res; + int stat = -EINVAL; + struct sunrpc_net *sn = net_generic(SVC_NET(rqstp), sunrpc_net_id); + ++ if (!gsd) ++ goto out; ++ gc = &gsd->clcred; + if (gc->gc_proc != RPC_GSS_PROC_DATA) + goto out; + /* Release can be called twice, but we only wrap once. */ +@@ -1758,10 +1761,10 @@ out_err: + if (rqstp->rq_cred.cr_group_info) + put_group_info(rqstp->rq_cred.cr_group_info); + rqstp->rq_cred.cr_group_info = NULL; +- if (gsd->rsci) ++ if (gsd && gsd->rsci) { + cache_put(&gsd->rsci->h, sn->rsc_cache); +- gsd->rsci = NULL; +- ++ gsd->rsci = NULL; ++ } + return stat; + } + +diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c +index eafcc75f289ac..ae85a5e5648b7 100644 +--- a/net/vmw_vsock/af_vsock.c ++++ b/net/vmw_vsock/af_vsock.c +@@ -635,6 +635,7 @@ struct sock *__vsock_create(struct net *net, + vsk->trusted = psk->trusted; + vsk->owner = get_cred(psk->owner); + vsk->connect_timeout = psk->connect_timeout; ++ security_sk_clone(parent, sk); + } else { + vsk->trusted = ns_capable_noaudit(&init_user_ns, CAP_NET_ADMIN); + vsk->owner = get_current_cred(); +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index 437fca15e5ef0..29de586c172f4 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -4642,7 +4642,7 @@ static void alc_determine_headset_type(struct hda_codec *codec) + case 0x10ec0274: + case 0x10ec0294: + alc_process_coef_fw(codec, coef0274); +- msleep(80); ++ msleep(850); + val = alc_read_coef_idx(codec, 0x46); + is_ctia = (val & 0x00f0) == 0x00f0; + break; +@@ -4811,6 +4811,7 @@ static void alc_update_headset_jack_cb(struct hda_codec *codec, + struct alc_spec *spec = codec->spec; + spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; + snd_hda_gen_hp_automute(codec, jack); ++ alc_update_headset_mode(codec); + } + + static void alc_probe_headset_mode(struct hda_codec *codec) +diff --git a/sound/soc/codecs/cs42l42.c b/sound/soc/codecs/cs42l42.c +index a2324a0e72ee5..39adb2fdd003b 100644 +--- a/sound/soc/codecs/cs42l42.c ++++ b/sound/soc/codecs/cs42l42.c +@@ -405,7 +405,7 @@ static const struct regmap_config cs42l42_regmap = { + }; + + static DECLARE_TLV_DB_SCALE(adc_tlv, -9600, 100, false); +-static DECLARE_TLV_DB_SCALE(mixer_tlv, -6200, 100, false); ++static DECLARE_TLV_DB_SCALE(mixer_tlv, -6300, 100, true); + + static const char * const cs42l42_hpf_freq_text[] = { + "1.86Hz", "120Hz", "235Hz", "466Hz" +@@ -462,7 +462,7 @@ static const struct snd_kcontrol_new cs42l42_snd_controls[] = { + CS42L42_DAC_HPF_EN_SHIFT, true, false), + SOC_DOUBLE_R_TLV("Mixer Volume", CS42L42_MIXER_CHA_VOL, + CS42L42_MIXER_CHB_VOL, CS42L42_MIXER_CH_VOL_SHIFT, +- 0x3e, 1, mixer_tlv) ++ 0x3f, 1, mixer_tlv) + }; + + static int cs42l42_hpdrv_evt(struct snd_soc_dapm_widget *w, +@@ -1809,7 +1809,7 @@ static int cs42l42_i2c_probe(struct i2c_client *i2c_client, + dev_dbg(&i2c_client->dev, "Found reset GPIO\n"); + gpiod_set_value_cansleep(cs42l42->reset_gpio, 1); + } +- mdelay(3); ++ usleep_range(CS42L42_BOOT_TIME_US, CS42L42_BOOT_TIME_US * 2); + + /* Request IRQ */ + ret = devm_request_threaded_irq(&i2c_client->dev, +@@ -1936,6 +1936,7 @@ static int cs42l42_runtime_resume(struct device *dev) + } + + gpiod_set_value_cansleep(cs42l42->reset_gpio, 1); ++ usleep_range(CS42L42_BOOT_TIME_US, CS42L42_BOOT_TIME_US * 2); + + regcache_cache_only(cs42l42->regmap, false); + regcache_sync(cs42l42->regmap); +diff --git a/sound/soc/codecs/cs42l42.h b/sound/soc/codecs/cs42l42.h +index d87a0a5322d58..3d5fa343db967 100644 +--- a/sound/soc/codecs/cs42l42.h ++++ b/sound/soc/codecs/cs42l42.h +@@ -743,6 +743,7 @@ + #define CS42L42_FRAC2_VAL(val) (((val) & 0xff0000) >> 16) + + #define CS42L42_NUM_SUPPLIES 5 ++#define CS42L42_BOOT_TIME_US 3000 + + static const char *const cs42l42_supply_names[CS42L42_NUM_SUPPLIES] = { + "VA", +diff --git a/sound/soc/codecs/es8316.c b/sound/soc/codecs/es8316.c +index 949dbdc0445e4..0410f2e5183c3 100644 +--- a/sound/soc/codecs/es8316.c ++++ b/sound/soc/codecs/es8316.c +@@ -56,13 +56,8 @@ static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(adc_pga_gain_tlv, + 1, 1, TLV_DB_SCALE_ITEM(0, 0, 0), + 2, 2, TLV_DB_SCALE_ITEM(250, 0, 0), + 3, 3, TLV_DB_SCALE_ITEM(450, 0, 0), +- 4, 4, TLV_DB_SCALE_ITEM(700, 0, 0), +- 5, 5, TLV_DB_SCALE_ITEM(1000, 0, 0), +- 6, 6, TLV_DB_SCALE_ITEM(1300, 0, 0), +- 7, 7, TLV_DB_SCALE_ITEM(1600, 0, 0), +- 8, 8, TLV_DB_SCALE_ITEM(1800, 0, 0), +- 9, 9, TLV_DB_SCALE_ITEM(2100, 0, 0), +- 10, 10, TLV_DB_SCALE_ITEM(2400, 0, 0), ++ 4, 7, TLV_DB_SCALE_ITEM(700, 300, 0), ++ 8, 10, TLV_DB_SCALE_ITEM(1800, 300, 0), + ); + + static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(hpout_vol_tlv, +diff --git a/sound/soc/codecs/rt5640.c b/sound/soc/codecs/rt5640.c +index 438fe52a12dfb..5af5dfc0fd465 100644 +--- a/sound/soc/codecs/rt5640.c ++++ b/sound/soc/codecs/rt5640.c +@@ -341,9 +341,9 @@ static bool rt5640_readable_register(struct device *dev, unsigned int reg) + } + + static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0); +-static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0); ++static const DECLARE_TLV_DB_MINMAX(dac_vol_tlv, -6562, 0); + static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0); +-static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0); ++static const DECLARE_TLV_DB_MINMAX(adc_vol_tlv, -1762, 3000); + static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0); + + /* {0, +20, +24, +30, +35, +40, +44, +50, +52} dB */ +diff --git a/sound/soc/codecs/rt5651.c b/sound/soc/codecs/rt5651.c +index 57c2add323c43..38510fd06458b 100644 +--- a/sound/soc/codecs/rt5651.c ++++ b/sound/soc/codecs/rt5651.c +@@ -287,9 +287,9 @@ static bool rt5651_readable_register(struct device *dev, unsigned int reg) + } + + static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0); +-static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0); ++static const DECLARE_TLV_DB_MINMAX(dac_vol_tlv, -6562, 0); + static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0); +-static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0); ++static const DECLARE_TLV_DB_MINMAX(adc_vol_tlv, -1762, 3000); + static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0); + + /* {0, +20, +24, +30, +35, +40, +44, +50, +52} dB */ +diff --git a/sound/soc/codecs/rt5659.c b/sound/soc/codecs/rt5659.c +index fa66b11df8d44..ae626d57c1adf 100644 +--- a/sound/soc/codecs/rt5659.c ++++ b/sound/soc/codecs/rt5659.c +@@ -3391,12 +3391,17 @@ static int rt5659_set_dai_sysclk(struct snd_soc_dai *dai, + struct snd_soc_codec *codec = dai->codec; + struct rt5659_priv *rt5659 = snd_soc_codec_get_drvdata(codec); + unsigned int reg_val = 0; ++ int ret; + + if (freq == rt5659->sysclk && clk_id == rt5659->sysclk_src) + return 0; + + switch (clk_id) { + case RT5659_SCLK_S_MCLK: ++ ret = clk_set_rate(rt5659->mclk, freq); ++ if (ret) ++ return ret; ++ + reg_val |= RT5659_SCLK_SRC_MCLK; + break; + case RT5659_SCLK_S_PLL1: +diff --git a/sound/soc/codecs/sgtl5000.c b/sound/soc/codecs/sgtl5000.c +index d64cb28e8dc5c..b7a0002d98720 100644 +--- a/sound/soc/codecs/sgtl5000.c ++++ b/sound/soc/codecs/sgtl5000.c +@@ -75,7 +75,7 @@ static const struct reg_default sgtl5000_reg_defaults[] = { + { SGTL5000_DAP_EQ_BASS_BAND4, 0x002f }, + { SGTL5000_DAP_MAIN_CHAN, 0x8000 }, + { SGTL5000_DAP_MIX_CHAN, 0x0000 }, +- { SGTL5000_DAP_AVC_CTRL, 0x0510 }, ++ { SGTL5000_DAP_AVC_CTRL, 0x5100 }, + { SGTL5000_DAP_AVC_THRESHOLD, 0x1473 }, + { SGTL5000_DAP_AVC_ATTACK, 0x0028 }, + { SGTL5000_DAP_AVC_DECAY, 0x0050 }, +diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c +index a5a274d7c560a..6fc9ad067d822 100644 +--- a/sound/usb/quirks.c ++++ b/sound/usb/quirks.c +@@ -1156,6 +1156,7 @@ bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip) + case USB_ID(0x21B4, 0x0081): /* AudioQuest DragonFly */ + case USB_ID(0x2912, 0x30c8): /* Audioengine D1 */ + case USB_ID(0x413c, 0xa506): /* Dell AE515 sound bar */ ++ case USB_ID(0x046d, 0x084c): /* Logitech ConferenceCam Connect */ + return true; + } + return false;
