tree 7a5930da836609883eb336b406ef2ccc3ad6516d
parent d9e420c4db293b3013a31da5c85ed96b861d483e
parent 8f55ad4daf001b6ee8ddf672e14475a35403b258
author COS Kernel Merge Bot <cloud-image-merge-automation@prod.google.com> 1618391129 -0700
committer COS Kernel Merge Bot <cloud-image-merge-automation@prod.google.com> 1618391129 -0700

merge-upstream/v5.4.112 from branch/tag: upstream/v5.4.112 into branch: cos-5.4

Changelog:
-------------------------------------------------------------

Adrian Hunter (1):
      perf inject: Fix repipe usage

Ahmed S. Darwish (1):
      net: xfrm: Localize sequence counter per network namespace

Al Viro (1):
      hostfs: fix memory handling in follow_link()

Alexander Aring (8):
      net: ieee802154: nl-mac: fix check on panid
      net: ieee802154: fix nl802154 del llsec key
      net: ieee802154: fix nl802154 del llsec dev
      net: ieee802154: fix nl802154 add llsec key
      net: ieee802154: fix nl802154 del llsec devkey
      net: ieee802154: forbid monitor for set llsec params
      net: ieee802154: forbid monitor for del llsec seclevel
      net: ieee802154: stop dump llsec params for monitors

Alexander Gordeev (1):
      s390/cpcmd: fix inline assembly register clobbering

Andy Shevchenko (1):
      hostfs: Use kasprintf() instead of fixed buffer formatting

Anirudh Rayabharam (1):
      net: hso: fix null-ptr-deref during tty device unregistration

Arkadiusz Kubalewski (2):
      i40e: Fix sparse warning: missing error code 'err'
      i40e: Fix sparse error: 'vsi->netdev' could be null

Arnd Bergmann (1):
      soc/fsl: qbman: fix conflicting alignment attributes

Aya Levin (2):
      net/mlx5e: Fix ethtool indication of connector type
      net/mlx5: Fix PBMC register mapping

Bart Van Assche (2):
      scsi: ufs: Avoid busy-waiting by eliminating tag conflicts
      scsi: ufs: Use blk_{get,put}_request() to allocate and free TMFs

Bastian Germann (1):
      ASoC: sunxi: sun4i-codec: fill ASoC card owner

Can Guo (2):
      scsi: ufs: core: Fix task management request completion timeout
      scsi: ufs: core: Fix wrong Task Tag used in task management request UPIUs

Claudiu Beznea (1):
      net: macb: restore cmp registers on resume path

Claudiu Manoil (1):
      gianfar: Handle error code at MAC address change

Daniel Jurgens (1):
      net/mlx5: Don't request more than supported EQs

Du Cheng (1):
      cfg80211: remove WARN_ON() in cfg80211_sme_connect

Eric Dumazet (2):
      net: ensure mac header is set in virtio_net_hdr_to_skb()
      sch_red: fix off-by-one checks in red_check_params()

Eryk Rybak (2):
      i40e: Fix kernel oops when i40e driver removes VF's
      i40e: Fix display statistics for veb_tc

Eyal Birger (1):
      xfrm: interface: fix ipv4 pmtu check to honor ip header df

Fabio Pricoco (1):
      ice: Increase control queue timeout

Fabrice Gasnier (1):
      counter: stm32-timer-cnt: fix ceiling miss-alignment with reload register

Florian Fainelli (1):
      net: phy: broadcom: Only advertise EEE for supported modes

Gao Xiang (1):
      parisc: avoid a warning on u8 cast for cmpxchg on u8 pointers

Geert Uytterhoeven (1):
      regulator: bd9571mwv: Fix AVS and DVFS voltage range

Greg Kroah-Hartman (2):
      Revert "cifs: Set CIFS_MOUNT_USE_PREFIX_PATH flag on setting cifs_sb->prepath."
      Linux 5.4.112

Guangbin Huang (1):
      net: hns3: clear VF down state bit before request link status

Guennadi Liakhovetski (1):
      ASoC: SOF: Intel: HDA: fix core status verification

Hans de Goede (1):
      ASoC: intel: atom: Stop advertising non working S24LE support

Helge Deller (1):
      parisc: parisc-agp requires SBA IOMMU driver

Ilya Maximets (1):
      openvswitch: fix send of uninitialized stack memory in ct limit reply

Jacek Bułatek (1):
      ice: Fix for dereference of NULL pointer

Jack Qiu (1):
      fs: direct-io: fix missing sdio->boundary

Johannes Berg (1):
      mac80211: fix TXQ AC confusion

John Fastabend (1):
      bpf, sockmap: Fix sk->prot unhash op reset

Jonas Holmberg (1):
      ALSA: aloop: Fix initialization of controls

Krzysztof Kozlowski (1):
      clk: socfpga: fix iomem pointer cast on 64-bit

Kumar Kartikeya Dwivedi (1):
      net: sched: bump refcount for new action in ACT replace mode

Kurt Kanzenbach (1):
      net: hsr: Reset MAC header for Tx path

Leon Romanovsky (1):
      RDMA/addr: Be strict with gid size

Luca Fancellu (1):
      xen/evtchn: Change irq_info lock to raw_spinlock_t

Lukasz Bartosik (2):
      clk: fix invalid usage of list cursor in register
      clk: fix invalid usage of list cursor in unregister

Lv Yunlong (3):
      ethernet/netronome/nfp: Fix a use after free in nfp_bpf_ctrl_msg_rx
      net:tipc: Fix a double free in tipc_sk_mcast_rcv
      net/rds: Fix a use after free in rds_message_map_pages

Maciej Żenczykowski (1):
      net-ipv6: bugfix - raw & sctp - switch to ipv6_can_nonlocal_bind()

Marek Behún (1):
      ARM: dts: turris-omnia: configure LED[2]/INTn pin as interrupt pin

Martin Blumenstingl (3):
      net: dsa: lantiq_gswip: Let GSWIP automatically set the xMII clock
      net: dsa: lantiq_gswip: Don't use PHY auto polling
      net: dsa: lantiq_gswip: Configure all remaining GSWIP_MII_CFG bits

Mateusz Palczewski (1):
      i40e: Added Asym_Pause to supported link modes

Mike Rapoport (1):
      nds32: flush_dcache_page: use page_mapping_file to avoid races with swapoff

Milton Miller (1):
      net/ncsi: Avoid channel_monitor hrtimer deadlock

Muhammad Usama Anjum (1):
      net: ipv6: check for validity before dereferencing cfg->fc_nlinfo.nlh

Nick Desaulniers (1):
      gcov: re-fix clang-11+ support

Norman Maurer (1):
      net: udp: Add support for getsockopt(..., ..., UDP_GRO, ..., ...);

Oliver Hartkopp (1):
      can: bcm/raw: fix msg_namelen values depending on CAN_REQUIRED_SIZE

Oliver Stäbler (1):
      arm64: dts: imx8mm/q: Fix pad control of SD1_DATA0

Paolo Abeni (1):
      net: let skb_orphan_partial wake-up waiters.

Pavel Skripkin (3):
      drivers: net: fix memory leak in atusb_probe
      drivers: net: fix memory leak in peak_usb_create_dev
      net: mac802154: Fix general protection fault

Pavel Tikhomirov (1):
      net: sched: sch_teql: fix null-pointer dereference

Payal Kshirsagar (1):
      ASoC: SOF: Intel: hda: remove unnecessary parentheses

Phillip Potter (1):
      net: tun: set tun->dev->addr_len during TUNSETLINK processing

Potnuri Bharat Teja (1):
      RDMA/cxgb4: check for ipv6 address properly while destroying listener

Raed Salem (1):
      net/mlx5: Fix placement of log_max_flow_counter

Rafał Miłecki (1):
      dt-bindings: net: ethernet-controller: fix typo in NVMEM

Rahul Lakkireddy (1):
      cxgb4: avoid collecting SGE_QBASE regs during traffic

Robert Malz (1):
      ice: Cleanup fltr list in case of allocation issues

Sergei Trofimovich (1):
      ia64: fix user_stack_pointer() for ptrace()

Shengjiu Wang (1):
      ASoC: wm8960: Fix wrong bclk and lrclk with pll enabled for some chips

Shuah Khan (4):
      usbip: add sysfs_lock to synchronize sysfs code paths
      usbip: stub-dev synchronize sysfs code paths
      usbip: vudc synchronize sysfs code paths
      usbip: synchronize event handler with sysfs code paths

Shyam Sundar S K (1):
      amd-xgbe: Update DMA coherency values

Stefan Riedmueller (1):
      ARM: dts: imx6: pbab01: Set vmmc supply for both SD interfaces

Steffen Klassert (1):
      xfrm: Fix NULL pointer dereference on policy lookup

Stephen Boyd (1):
      drm/msm: Set drvdata to NULL when msm_drm_init() fails

Takashi Iwai (2):
      ALSA: hda/realtek: Fix speaker amp setup on Acer Aspire E1
      drm/i915: Fix invalid access to ACPI _DSM objects

Tetsuo Handa (1):
      batman-adv: initialize "struct batadv_tvlv_tt_vlan_data"->reserved field

Venkat Gopalakrishnan (1):
      scsi: ufs: Fix irq return code

Wengang Wang (1):
      ocfs2: fix deadlock between setattr and dio_end_io_write

William Roche (1):
      RAS/CEC: Correct ce_add_elem()'s returned values

Wolfram Sang (1):
      i2c: turn recovery error on init to debug

Xiaoming Ni (4):
      nfc: fix refcount leak in llcp_sock_bind()
      nfc: fix refcount leak in llcp_sock_connect()
      nfc: fix memory leak in llcp_sock_connect()
      nfc: Avoid endless loops caused by repeated llcp_sock_connect()

Xin Long (1):
      esp: delete NETIF_F_SCTP_CRC bit from features for esp offload

Yinjun Zhang (1):
      nfp: flower: ignore duplicate merge hints from FW

Yuya Kusakabe (1):
      virtio_net: Add XDP meta data support

Zheng Yongjun (1):
      net: openvswitch: conntrack: simplify the return expression of ovs_ct_limit_get_default_limit()

Zqiang (1):
      workqueue: Move the position of debug_work_activate() in __queue_work()

BUG=b/185311816
TEST=tryjob, validation and K8s e2e
RELEASE_NOTE=Updated the Linux kernel to v5.4.112.

Signed-off-by: COS Kernel Merge Bot <cloud-image-merge-automation@prod.google.com>
Change-Id: I61549d1254275f9f759e680377a8dd61f95e8292
