Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

Pull networking fixes from David Miller: 1) BPF sample build fixes from Björn Töpel 2) Fix powerpc bpf tail call implementation, from Eric Dumazet. 3) DCCP leaks jiffies on the wire, fix also from Eric Dumazet. 4) Fix crash in ebtables when using dnat target, from Florian Westphal. 5) Fix port disable handling whne removing bcm_sf2 driver, from Florian Fainelli. 6) Fix kTLS sk_msg trim on fallback to copy mode, from Jakub Kicinski. 7) Various KCSAN fixes all over the networking, from Eric Dumazet. 8) Memory leaks in mlx5 driver, from Alex Vesker. 9) SMC interface refcounting fix, from Ursula Braun. 10) TSO descriptor handling fixes in stmmac driver, from Jose Abreu. 11) Add a TX lock to synchonize the kTLS TX path properly with crypto operations. From Jakub Kicinski. 12) Sock refcount during shutdown fix in vsock/virtio code, from Stefano Garzarella. 13) Infinite loop in Intel ice driver, from Colin Ian King. * git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (108 commits) ixgbe: need_wakeup flag might not be set for Tx i40e: need_wakeup flag might not be set for Tx igb/igc: use ktime accessors for skb->tstamp i40e: Fix for ethtool -m issue on X722 NIC iavf: initialize ITRN registers with correct values ice: fix potential infinite loop because loop counter being too small qede: fix NULL pointer deref in __qede_remove() net: fix data-race in neigh_event_send() vsock/virtio: fix sock refcnt holding during the shutdown net: ethernet: octeon_mgmt: Account for second possible VLAN header mac80211: fix station inactive_time shortly after boot net/fq_impl: Switch to kvmalloc() for memory allocation mac80211: fix ieee80211_txq_setup_flows() failure path ipv4: Fix table id reference in fib_sync_down_addr ipv6: fixes rt6_probe() and fib6_nh->last_probe init net: hns: Fix the stray netpoll locks causing deadlock in NAPI path net: usb: qmi_wwan: add support for DW5821e with eSIM support CDC-NCM: handle incomplete transfer of MTU nfc: netlink: fix double device reference drop NFC: st21nfca: fix double free ...
author: Linus Torvalds <torvalds@linux-foundation.org> 2019-11-08 21:21:05 -0500
committer: Linus Torvalds <torvalds@linux-foundation.org> 2019-11-08 21:21:05 -0500
commit: 0058b0a506e40d9a2c62015fe92eb64a44d78cd9 (patch)
tree: b92b6bb31d6308a3f049b49e3780e525ff67a2e5
parent: 5cb8418cb533222709f362d264653a634eb8c7ac (diff)
parent: a2582cdc32f071422e0197a6c59bd1235b426ce2 (diff)
111 files changed, 1093 insertions, 483 deletions
diff --git a/Documentation/networking/tls-offload.rst b/Documentation/networking/tls-offload.rst
index 0dd3f748239f..f914e81fd3a6 100644
--- a/Documentation/networking/tls-offload.rst
+++ b/Documentation/networking/tls-offload.rst
@@ -436,6 +436,10 @@ by the driver:
   encryption.
 * ``tx_tls_ooo`` - number of TX packets which were part of a TLS stream
   but did not arrive in the expected order.
+ * ``tx_tls_skip_no_sync_data`` - number of TX packets which were part of
+   a TLS stream and arrived out-of-order, but skipped the HW offload routine
+   and went to the regular transmit flow as they were retransmissions of the
+   connection handshake.
 * ``tx_tls_drop_no_sync_data`` - number of TX packets which were part of
   a TLS stream dropped, because they arrived out of order and associated
   record could not be found.
diff --git a/MAINTAINERS b/MAINTAINERS
index 2a427d1e9f01..8f148f499660 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -3053,6 +3053,7 @@ M:	Daniel Borkmann <daniel@iogearbox.net>
 R:      Martin KaFai Lau <kafai@fb.com>
 R:      Song Liu <songliubraving@fb.com>
 R:      Yonghong Song <yhs@fb.com>
+R:      Andrii Nakryiko <andriin@fb.com>
 L:      netdev@vger.kernel.org
 L:      bpf@vger.kernel.org
 T:      git git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git
diff --git a/arch/powerpc/net/bpf_jit_comp64.c b/arch/powerpc/net/bpf_jit_comp64.c
index 02a59946a78a..be3517ef0574 100644
--- a/arch/powerpc/net/bpf_jit_comp64.c
+++ b/arch/powerpc/net/bpf_jit_comp64.c
@@ -1142,6 +1142,19 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp)
        }
        /*
+         * If we have seen a tail call, we need a second pass.
+         * This is because bpf_jit_emit_common_epilogue() is called
+         * from bpf_jit_emit_tail_call() with a not yet stable ctx->seen.
+         */
+        if (cgctx.seen & SEEN_TAILCALL) {
+                cgctx.idx = 0;
+                if (bpf_jit_build_body(fp, 0, &cgctx, addrs, false)) {
+                        fp = org_fp;
+                        goto out_addrs;
+                }
+        }
+        /*
         * Pretend to build prologue, given the features we've seen.  This will
         * update ctgtx.idx as it pretends to output instructions, then we can
         * calculate total size from idx.
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 480f9459b402..62f65573eb04 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -2083,8 +2083,7 @@ static int bond_miimon_inspect(struct bonding *bond)
        ignore_updelay = !rcu_dereference(bond->curr_active_slave);
        bond_for_each_slave_rcu(bond, slave, iter) {
-                slave->new_link = BOND_LINK_NOCHANGE;
+                bond_propose_link_state(slave, BOND_LINK_NOCHANGE);
-                slave->link_new_state = slave->link;
                link_state = bond_check_dev_link(bond, slave->dev, 0);
@@ -2118,7 +2117,7 @@ static int bond_miimon_inspect(struct bonding *bond)
                        }
                        if (slave->delay <= 0) {
-                                slave->new_link = BOND_LINK_DOWN;
+                                bond_propose_link_state(slave, BOND_LINK_DOWN);
                                commit++;
                                continue;
                        }
@@ -2155,7 +2154,7 @@ static int bond_miimon_inspect(struct bonding *bond)
                                slave->delay = 0;
                        if (slave->delay <= 0) {
-                                slave->new_link = BOND_LINK_UP;
+                                bond_propose_link_state(slave, BOND_LINK_UP);
                                commit++;
                                ignore_updelay = false;
                                continue;
@@ -2193,7 +2192,7 @@ static void bond_miimon_commit(struct bonding *bond)
        struct slave *slave, *primary;
        bond_for_each_slave(bond, slave, iter) {
-                switch (slave->new_link) {
+                switch (slave->link_new_state) {
                case BOND_LINK_NOCHANGE:
                        /* For 802.3ad mode, check current slave speed and
                         * duplex again in case its port was disabled after
@@ -2265,8 +2264,8 @@ static void bond_miimon_commit(struct bonding *bond)
                default:
                        slave_err(bond->dev, slave->dev, "invalid new link %d on slave\n",
-                                  slave->new_link);
+                                  slave->link_new_state);
-                        slave->new_link = BOND_LINK_NOCHANGE;
+                        bond_propose_link_state(slave, BOND_LINK_NOCHANGE);
                        continue;
                }
@@ -2674,13 +2673,13 @@ static void bond_loadbalance_arp_mon(struct bonding *bond)
        bond_for_each_slave_rcu(bond, slave, iter) {
                unsigned long trans_start = dev_trans_start(slave->dev);
-                slave->new_link = BOND_LINK_NOCHANGE;
+                bond_propose_link_state(slave, BOND_LINK_NOCHANGE);
                if (slave->link != BOND_LINK_UP) {
                        if (bond_time_in_interval(bond, trans_start, 1) &&
                            bond_time_in_interval(bond, slave->last_rx, 1)) {
-                                slave->new_link = BOND_LINK_UP;
+                                bond_propose_link_state(slave, BOND_LINK_UP);
                                slave_state_changed = 1;
                                /* primary_slave has no meaning in round-robin
@@ -2705,7 +2704,7 @@ static void bond_loadbalance_arp_mon(struct bonding *bond)
                        if (!bond_time_in_interval(bond, trans_start, 2) ||
                            !bond_time_in_interval(bond, slave->last_rx, 2)) {
-                                slave->new_link = BOND_LINK_DOWN;
+                                bond_propose_link_state(slave, BOND_LINK_DOWN);
                                slave_state_changed = 1;
                                if (slave->link_failure_count < UINT_MAX)
@@ -2736,8 +2735,8 @@ static void bond_loadbalance_arp_mon(struct bonding *bond)
                        goto re_arm;
                bond_for_each_slave(bond, slave, iter) {
-                        if (slave->new_link != BOND_LINK_NOCHANGE)
+                        if (slave->link_new_state != BOND_LINK_NOCHANGE)
-                                slave->link = slave->new_link;
+                                slave->link = slave->link_new_state;
                }
                if (slave_state_changed) {
@@ -2760,9 +2759,9 @@ re_arm:
 }
 /* Called to inspect slaves for active-backup mode ARP monitor link state
- * changes.  Sets new_link in slaves to specify what action should take
+ * changes.  Sets proposed link state in slaves to specify what action
- * place for the slave.  Returns 0 if no changes are found, >0 if changes
+ * should take place for the slave.  Returns 0 if no changes are found, >0
- * to link states must be committed.
+ * if changes to link states must be committed.
 *
 * Called with rcu_read_lock held.
 */
@@ -2774,12 +2773,12 @@ static int bond_ab_arp_inspect(struct bonding *bond)
        int commit = 0;
        bond_for_each_slave_rcu(bond, slave, iter) {
-                slave->new_link = BOND_LINK_NOCHANGE;
+                bond_propose_link_state(slave, BOND_LINK_NOCHANGE);
                last_rx = slave_last_rx(bond, slave);
                if (slave->link != BOND_LINK_UP) {
                        if (bond_time_in_interval(bond, last_rx, 1)) {
-                                slave->new_link = BOND_LINK_UP;
+                                bond_propose_link_state(slave, BOND_LINK_UP);
                                commit++;
                        }
                        continue;
@@ -2807,7 +2806,7 @@ static int bond_ab_arp_inspect(struct bonding *bond)
                if (!bond_is_active_slave(slave) &&
                    !rcu_access_pointer(bond->current_arp_slave) &&
                    !bond_time_in_interval(bond, last_rx, 3)) {
-                        slave->new_link = BOND_LINK_DOWN;
+                        bond_propose_link_state(slave, BOND_LINK_DOWN);
                        commit++;
                }
@@ -2820,7 +2819,7 @@ static int bond_ab_arp_inspect(struct bonding *bond)
                if (bond_is_active_slave(slave) &&
                    (!bond_time_in_interval(bond, trans_start, 2) ||
                     !bond_time_in_interval(bond, last_rx, 2))) {
-                        slave->new_link = BOND_LINK_DOWN;
+                        bond_propose_link_state(slave, BOND_LINK_DOWN);
                        commit++;
                }
        }
@@ -2840,7 +2839,7 @@ static void bond_ab_arp_commit(struct bonding *bond)
        struct slave *slave;
        bond_for_each_slave(bond, slave, iter) {
-                switch (slave->new_link) {
+                switch (slave->link_new_state) {
                case BOND_LINK_NOCHANGE:
                        continue;
@@ -2890,8 +2889,9 @@ static void bond_ab_arp_commit(struct bonding *bond)
                        continue;
                default:
-                        slave_err(bond->dev, slave->dev, "impossible: new_link %d on slave\n",
+                        slave_err(bond->dev, slave->dev,
-                                  slave->new_link);
+                                  "impossible: link_new_state %d on slave\n",
+                                  slave->link_new_state);
                        continue;
                }
diff --git a/drivers/net/can/c_can/c_can.c b/drivers/net/can/c_can/c_can.c
index 606b7d8ffe13..8e9f5620c9a2 100644
--- a/drivers/net/can/c_can/c_can.c
+++ b/drivers/net/can/c_can/c_can.c
@@ -52,6 +52,7 @@
 #define CONTROL_EX_PDR          BIT(8)
 /* control register */
+#define CONTROL_SWR             BIT(15)
 #define CONTROL_TEST            BIT(7)
 #define CONTROL_CCE             BIT(6)
 #define CONTROL_DISABLE_AR      BIT(5)
@@ -97,6 +98,9 @@
 #define BTR_TSEG2_SHIFT         12
 #define BTR_TSEG2_MASK          (0x7 << BTR_TSEG2_SHIFT)
+/* interrupt register */
+#define INT_STS_PENDING         0x8000
 /* brp extension register */
 #define BRP_EXT_BRPE_MASK       0x0f
 #define BRP_EXT_BRPE_SHIFT      0
@@ -569,6 +573,26 @@ static void c_can_configure_msg_objects(struct net_device *dev)
                                   IF_MCONT_RCV_EOB);
 }
+static int c_can_software_reset(struct net_device *dev)
+{
+        struct c_can_priv *priv = netdev_priv(dev);
+        int retry = 0;
+        if (priv->type != BOSCH_D_CAN)
+                return 0;
+        priv->write_reg(priv, C_CAN_CTRL_REG, CONTROL_SWR | CONTROL_INIT);
+        while (priv->read_reg(priv, C_CAN_CTRL_REG) & CONTROL_SWR) {
+                msleep(20);
+                if (retry++ > 100) {
+                        netdev_err(dev, "CCTRL: software reset failed\n");
+                        return -EIO;
+                }
+        }
+        return 0;
+}
 /*
 * Configure C_CAN chip:
 * - enable/disable auto-retransmission
@@ -578,6 +602,11 @@ static void c_can_configure_msg_objects(struct net_device *dev)
 static int c_can_chip_config(struct net_device *dev)
 {
        struct c_can_priv *priv = netdev_priv(dev);
+        int err;
+        err = c_can_software_reset(dev);
+        if (err)
+                return err;
        /* enable automatic retransmission */
        priv->write_reg(priv, C_CAN_CTRL_REG, CONTROL_ENABLE_AR);
@@ -886,6 +915,9 @@ static int c_can_handle_state_change(struct net_device *dev,
        struct can_berr_counter bec;
        switch (error_type) {
+        case C_CAN_NO_ERROR:
+                priv->can.state = CAN_STATE_ERROR_ACTIVE;
+                break;
        case C_CAN_ERROR_WARNING:
                /* error warning state */
                priv->can.can_stats.error_warning++;
@@ -916,6 +948,13 @@ static int c_can_handle_state_change(struct net_device *dev,
                                ERR_CNT_RP_SHIFT;
        switch (error_type) {
+        case C_CAN_NO_ERROR:
+                /* error warning state */
+                cf->can_id |= CAN_ERR_CRTL;
+                cf->data[1] = CAN_ERR_CRTL_ACTIVE;
+                cf->data[6] = bec.txerr;
+                cf->data[7] = bec.rxerr;
+                break;
        case C_CAN_ERROR_WARNING:
                /* error warning state */
                cf->can_id |= CAN_ERR_CRTL;
@@ -1029,10 +1068,16 @@ static int c_can_poll(struct napi_struct *napi, int quota)
        u16 curr, last = priv->last_status;
        int work_done = 0;
-        priv->last_status = curr = priv->read_reg(priv, C_CAN_STS_REG);
+        /* Only read the status register if a status interrupt was pending */
-        /* Ack status on C_CAN. D_CAN is self clearing */
+        if (atomic_xchg(&priv->sie_pending, 0)) {
-        if (priv->type != BOSCH_D_CAN)
+                priv->last_status = curr = priv->read_reg(priv, C_CAN_STS_REG);
-                priv->write_reg(priv, C_CAN_STS_REG, LEC_UNUSED);
+                /* Ack status on C_CAN. D_CAN is self clearing */
+                if (priv->type != BOSCH_D_CAN)
+                        priv->write_reg(priv, C_CAN_STS_REG, LEC_UNUSED);
+        } else {
+                /* no change detected ... */
+                curr = last;
+        }
        /* handle state changes */
        if ((curr & STATUS_EWARN) && (!(last & STATUS_EWARN))) {
@@ -1054,11 +1099,17 @@ static int c_can_poll(struct napi_struct *napi, int quota)
        /* handle bus recovery events */
        if ((!(curr & STATUS_BOFF)) && (last & STATUS_BOFF)) {
                netdev_dbg(dev, "left bus off state\n");
-                priv->can.state = CAN_STATE_ERROR_ACTIVE;
+                work_done += c_can_handle_state_change(dev, C_CAN_ERROR_PASSIVE);
        }
        if ((!(curr & STATUS_EPASS)) && (last & STATUS_EPASS)) {
                netdev_dbg(dev, "left error passive state\n");
-                priv->can.state = CAN_STATE_ERROR_ACTIVE;
+                work_done += c_can_handle_state_change(dev, C_CAN_ERROR_WARNING);
+        }
+        if ((!(curr & STATUS_EWARN)) && (last & STATUS_EWARN)) {
+                netdev_dbg(dev, "left error warning state\n");
+                work_done += c_can_handle_state_change(dev, C_CAN_NO_ERROR);
        }
        /* handle lec errors on the bus */
@@ -1083,10 +1134,16 @@ static irqreturn_t c_can_isr(int irq, void *dev_id)
 {
        struct net_device *dev = (struct net_device *)dev_id;
        struct c_can_priv *priv = netdev_priv(dev);
+        int reg_int;
-        if (!priv->read_reg(priv, C_CAN_INT_REG))
+        reg_int = priv->read_reg(priv, C_CAN_INT_REG);
+        if (!reg_int)
                return IRQ_NONE;
+        /* save for later use */
+        if (reg_int & INT_STS_PENDING)
+                atomic_set(&priv->sie_pending, 1);
        /* disable all interrupts and schedule the NAPI */
        c_can_irq_control(priv, false);
        napi_schedule(&priv->napi);
diff --git a/drivers/net/can/c_can/c_can.h b/drivers/net/can/c_can/c_can.h
index 8acdc7fa4792..d5567a7c1c6d 100644
--- a/drivers/net/can/c_can/c_can.h
+++ b/drivers/net/can/c_can/c_can.h
@@ -198,6 +198,7 @@ struct c_can_priv {
        struct net_device *dev;
        struct device *device;
        atomic_t tx_active;
+        atomic_t sie_pending;
        unsigned long tx_dir;
        int last_status;
        u16 (*read_reg) (const struct c_can_priv *priv, enum reg index);
diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
index ac86be52b461..1c88c361938c 100644
--- a/drivers/net/can/dev.c
+++ b/drivers/net/can/dev.c
@@ -848,6 +848,7 @@ void of_can_transceiver(struct net_device *dev)
                return;
        ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max);
+        of_node_put(dn);
        if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max))
                netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n");
 }
diff --git a/drivers/net/can/flexcan.c b/drivers/net/can/flexcan.c
index dc5695dffc2e..57f9a2f51085 100644
--- a/drivers/net/can/flexcan.c
+++ b/drivers/net/can/flexcan.c
@@ -677,6 +677,7 @@ static void flexcan_irq_bus_err(struct net_device *dev, u32 reg_esr)
        struct can_frame *cf;
        bool rx_errors = false, tx_errors = false;
        u32 timestamp;
+        int err;
        timestamp = priv->read(&regs->timer) << 16;
@@ -725,7 +726,9 @@ static void flexcan_irq_bus_err(struct net_device *dev, u32 reg_esr)
        if (tx_errors)
                dev->stats.tx_errors++;
-        can_rx_offload_queue_sorted(&priv->offload, skb, timestamp);
+        err = can_rx_offload_queue_sorted(&priv->offload, skb, timestamp);
+        if (err)
+                dev->stats.rx_fifo_errors++;
 }
 static void flexcan_irq_state(struct net_device *dev, u32 reg_esr)
@@ -738,6 +741,7 @@ static void flexcan_irq_state(struct net_device *dev, u32 reg_esr)
        int flt;
        struct can_berr_counter bec;
        u32 timestamp;
+        int err;
        timestamp = priv->read(&regs->timer) << 16;
@@ -769,7 +773,9 @@ static void flexcan_irq_state(struct net_device *dev, u32 reg_esr)
        if (unlikely(new_state == CAN_STATE_BUS_OFF))
                can_bus_off(dev);
-        can_rx_offload_queue_sorted(&priv->offload, skb, timestamp);
+        err = can_rx_offload_queue_sorted(&priv->offload, skb, timestamp);
+        if (err)
+                dev->stats.rx_fifo_errors++;
 }
 static inline struct flexcan_priv *rx_offload_to_priv(struct can_rx_offload *offload)
@@ -1188,6 +1194,7 @@ static int flexcan_chip_start(struct net_device *dev)
                reg_mecr = priv->read(&regs->mecr);
                reg_mecr &= ~FLEXCAN_MECR_ECRWRDIS;
                priv->write(reg_mecr, &regs->mecr);
+                reg_mecr |= FLEXCAN_MECR_ECCDIS;
                reg_mecr &= ~(FLEXCAN_MECR_NCEFAFRZ | FLEXCAN_MECR_HANCEI_MSK |
                              FLEXCAN_MECR_FANCEI_MSK);
                priv->write(reg_mecr, &regs->mecr);
diff --git a/drivers/net/can/rx-offload.c b/drivers/net/can/rx-offload.c
index e6a668ee7730..84cae167e42f 100644
--- a/drivers/net/can/rx-offload.c
+++ b/drivers/net/can/rx-offload.c
@@ -107,37 +107,95 @@ static int can_rx_offload_compare(struct sk_buff *a, struct sk_buff *b)
        return cb_b->timestamp - cb_a->timestamp;
 }
-static struct sk_buff *can_rx_offload_offload_one(struct can_rx_offload *offload, unsigned int n)
+/**
+ * can_rx_offload_offload_one() - Read one CAN frame from HW
+ * @offload: pointer to rx_offload context
+ * @n: number of mailbox to read
+ *
+ * The task of this function is to read a CAN frame from mailbox @n
+ * from the device and return the mailbox's content as a struct
+ * sk_buff.
+ *
+ * If the struct can_rx_offload::skb_queue exceeds the maximal queue
+ * length (struct can_rx_offload::skb_queue_len_max) or no skb can be
+ * allocated, the mailbox contents is discarded by reading it into an
+ * overflow buffer. This way the mailbox is marked as free by the
+ * driver.
+ *
+ * Return: A pointer to skb containing the CAN frame on success.
+ *
+ *         NULL if the mailbox @n is empty.
+ *
+ *         ERR_PTR() in case of an error
+ */
+static struct sk_buff *
+can_rx_offload_offload_one(struct can_rx_offload *offload, unsigned int n)
 {
-        struct sk_buff *skb = NULL;
+        struct sk_buff *skb = NULL, *skb_error = NULL;
        struct can_rx_offload_cb *cb;
        struct can_frame *cf;
        int ret;
-        /* If queue is full or skb not available, read to discard mailbox */
+        if (likely(skb_queue_len(&offload->skb_queue) <
-        if (likely(skb_queue_len(&offload->skb_queue) <=
+                   offload->skb_queue_len_max)) {
-                   offload->skb_queue_len_max))
                skb = alloc_can_skb(offload->dev, &cf);
+                if (unlikely(!skb))
+                        skb_error = ERR_PTR(-ENOMEM);   /* skb alloc failed */
+        } else {
+                skb_error = ERR_PTR(-ENOBUFS);          /* skb_queue is full */
+        }
-        if (!skb) {
+        /* If queue is full or skb not available, drop by reading into
+         * overflow buffer.
+         */
+        if (unlikely(skb_error)) {
                struct can_frame cf_overflow;
                u32 timestamp;
                ret = offload->mailbox_read(offload, &cf_overflow,
                                            &timestamp, n);
-                if (ret)
-                        offload->dev->stats.rx_dropped++;
-                return NULL;
+                /* Mailbox was empty. */
+                if (unlikely(!ret))
+                        return NULL;
+                /* Mailbox has been read and we're dropping it or
+                 * there was a problem reading the mailbox.
+                 *
+                 * Increment error counters in any case.
+                 */
+                offload->dev->stats.rx_dropped++;
+                offload->dev->stats.rx_fifo_errors++;
+                /* There was a problem reading the mailbox, propagate
+                 * error value.
+                 */
+                if (unlikely(ret < 0))
+                        return ERR_PTR(ret);
+                return skb_error;
        }
        cb = can_rx_offload_get_cb(skb);
        ret = offload->mailbox_read(offload, cf, &cb->timestamp, n);
-        if (!ret) {
+        /* Mailbox was empty. */
+        if (unlikely(!ret)) {
                kfree_skb(skb);
                return NULL;
        }
+        /* There was a problem reading the mailbox, propagate error value. */
+        if (unlikely(ret < 0)) {
+                kfree_skb(skb);
+                offload->dev->stats.rx_dropped++;
+                offload->dev->stats.rx_fifo_errors++;
+                return ERR_PTR(ret);
+        }
+        /* Mailbox was read. */
        return skb;
 }
@@ -157,8 +215,8 @@ int can_rx_offload_irq_offload_timestamp(struct can_rx_offload *offload, u64 pen
                        continue;
                skb = can_rx_offload_offload_one(offload, i);
-                if (!skb)
+                if (IS_ERR_OR_NULL(skb))
-                        break;
+                        continue;
                __skb_queue_add_sort(&skb_queue, skb, can_rx_offload_compare);
        }
@@ -188,7 +246,13 @@ int can_rx_offload_irq_offload_fifo(struct can_rx_offload *offload)
        struct sk_buff *skb;
        int received = 0;
-        while ((skb = can_rx_offload_offload_one(offload, 0))) {
+        while (1) {
+                skb = can_rx_offload_offload_one(offload, 0);
+                if (IS_ERR(skb))
+                        continue;
+                if (!skb)
+                        break;
                skb_queue_tail(&offload->skb_queue, skb);
                received++;
        }
@@ -207,8 +271,10 @@ int can_rx_offload_queue_sorted(struct can_rx_offload *offload,
        unsigned long flags;
        if (skb_queue_len(&offload->skb_queue) >
-            offload->skb_queue_len_max)
+            offload->skb_queue_len_max) {
-                return -ENOMEM;
+                kfree_skb(skb);
+                return -ENOBUFS;
+        }
        cb = can_rx_offload_get_cb(skb);
        cb->timestamp = timestamp;
@@ -250,8 +316,10 @@ int can_rx_offload_queue_tail(struct can_rx_offload *offload,
                              struct sk_buff *skb)
 {
        if (skb_queue_len(&offload->skb_queue) >
-            offload->skb_queue_len_max)
+            offload->skb_queue_len_max) {
-                return -ENOMEM;
+                kfree_skb(skb);
+                return -ENOBUFS;
+        }
        skb_queue_tail(&offload->skb_queue, skb);
        can_rx_offload_schedule(offload);
diff --git a/drivers/net/can/spi/mcp251x.c b/drivers/net/can/spi/mcp251x.c
index bee9f7b8dad6..bb20a9b75cc6 100644
--- a/drivers/net/can/spi/mcp251x.c
+++ b/drivers/net/can/spi/mcp251x.c
@@ -717,6 +717,7 @@ static void mcp251x_restart_work_handler(struct work_struct *ws)
        if (priv->after_suspend) {
                mcp251x_hw_reset(spi);
                mcp251x_setup(net, spi);
+                priv->force_quit = 0;
                if (priv->after_suspend & AFTER_SUSPEND_RESTART) {
                        mcp251x_set_normal_mode(spi);
                } else if (priv->after_suspend & AFTER_SUSPEND_UP) {
@@ -728,7 +729,6 @@ static void mcp251x_restart_work_handler(struct work_struct *ws)
                        mcp251x_hw_sleep(spi);
                }
                priv->after_suspend = 0;
-                priv->force_quit = 0;
        }
        if (priv->restart_tx) {
diff --git a/drivers/net/can/ti_hecc.c b/drivers/net/can/ti_hecc.c
index f8b19eef5d26..31ad364a89bb 100644
--- a/drivers/net/can/ti_hecc.c
+++ b/drivers/net/can/ti_hecc.c
@@ -73,6 +73,7 @@ MODULE_VERSION(HECC_MODULE_VERSION);
 */
 #define HECC_MAX_RX_MBOX        (HECC_MAX_MAILBOXES - HECC_MAX_TX_MBOX)
 #define HECC_RX_FIRST_MBOX      (HECC_MAX_MAILBOXES - 1)
+#define HECC_RX_LAST_MBOX       (HECC_MAX_TX_MBOX)
 /* TI HECC module registers */
 #define HECC_CANME              0x0     /* Mailbox enable */
@@ -82,7 +83,7 @@ MODULE_VERSION(HECC_MODULE_VERSION);
 #define HECC_CANTA              0x10    /* Transmission acknowledge */
 #define HECC_CANAA              0x14    /* Abort acknowledge */
 #define HECC_CANRMP             0x18    /* Receive message pending */
-#define HECC_CANRML             0x1C    /* Remote message lost */
+#define HECC_CANRML             0x1C    /* Receive message lost */
 #define HECC_CANRFP             0x20    /* Remote frame pending */
 #define HECC_CANGAM             0x24    /* SECC only:Global acceptance mask */
 #define HECC_CANMC              0x28    /* Master control */
@@ -149,6 +150,8 @@ MODULE_VERSION(HECC_MODULE_VERSION);
 #define HECC_BUS_ERROR          (HECC_CANES_FE | HECC_CANES_BE |\
                                HECC_CANES_CRCE | HECC_CANES_SE |\
                                HECC_CANES_ACKE)
+#define HECC_CANES_FLAGS        (HECC_BUS_ERROR | HECC_CANES_BO |\
+                                HECC_CANES_EP | HECC_CANES_EW)
 #define HECC_CANMCF_RTR         BIT(4)  /* Remote transmit request */
@@ -382,8 +385,18 @@ static void ti_hecc_start(struct net_device *ndev)
                hecc_set_bit(priv, HECC_CANMIM, mbx_mask);
        }
-        /* Prevent message over-write & Enable interrupts */
+        /* Enable tx interrupts */
-        hecc_write(priv, HECC_CANOPC, HECC_SET_REG);
+        hecc_set_bit(priv, HECC_CANMIM, BIT(HECC_MAX_TX_MBOX) - 1);
+        /* Prevent message over-write to create a rx fifo, but not for
+         * the lowest priority mailbox, since that allows detecting
+         * overflows instead of the hardware silently dropping the
+         * messages.
+         */
+        mbx_mask = ~BIT(HECC_RX_LAST_MBOX);
+        hecc_write(priv, HECC_CANOPC, mbx_mask);
+        /* Enable interrupts */
        if (priv->use_hecc1int) {
                hecc_write(priv, HECC_CANMIL, HECC_SET_REG);
                hecc_write(priv, HECC_CANGIM, HECC_CANGIM_DEF_MASK |
@@ -400,6 +413,9 @@ static void ti_hecc_stop(struct net_device *ndev)
 {
        struct ti_hecc_priv *priv = netdev_priv(ndev);
+        /* Disable the CPK; stop sending, erroring and acking */
+        hecc_set_bit(priv, HECC_CANMC, HECC_CANMC_CCR);
        /* Disable interrupts and disable mailboxes */
        hecc_write(priv, HECC_CANGIM, 0);
        hecc_write(priv, HECC_CANMIM, 0);
@@ -508,8 +524,6 @@ static netdev_tx_t ti_hecc_xmit(struct sk_buff *skb, struct net_device *ndev)
        hecc_set_bit(priv, HECC_CANME, mbx_mask);
        spin_unlock_irqrestore(&priv->mbx_lock, flags);
-        hecc_clear_bit(priv, HECC_CANMD, mbx_mask);
-        hecc_set_bit(priv, HECC_CANMIM, mbx_mask);
        hecc_write(priv, HECC_CANTRS, mbx_mask);
        return NETDEV_TX_OK;
@@ -526,8 +540,10 @@ static unsigned int ti_hecc_mailbox_read(struct can_rx_offload *offload,
                                         u32 *timestamp, unsigned int mbxno)
 {
        struct ti_hecc_priv *priv = rx_offload_to_priv(offload);
-        u32 data;
+        u32 data, mbx_mask;
+        int ret = 1;
+        mbx_mask = BIT(mbxno);
        data = hecc_read_mbx(priv, mbxno, HECC_CANMID);
        if (data & HECC_CANMID_IDE)
                cf->can_id = (data & CAN_EFF_MASK) | CAN_EFF_FLAG;
@@ -548,7 +564,25 @@ static unsigned int ti_hecc_mailbox_read(struct can_rx_offload *offload,
        *timestamp = hecc_read_stamp(priv, mbxno);
-        return 1;
+        /* Check for FIFO overrun.
+         *
+         * All but the last RX mailbox have activated overwrite
+         * protection. So skip check for overrun, if we're not
+         * handling the last RX mailbox.
+         *
+         * As the overwrite protection for the last RX mailbox is
+         * disabled, the CAN core might update while we're reading
+         * it. This means the skb might be inconsistent.
+         *
+         * Return an error to let rx-offload discard this CAN frame.
+         */
+        if (unlikely(mbxno == HECC_RX_LAST_MBOX &&
+                     hecc_read(priv, HECC_CANRML) & mbx_mask))
+                ret = -ENOBUFS;
+        hecc_write(priv, HECC_CANRMP, mbx_mask);
+        return ret;
 }
 static int ti_hecc_error(struct net_device *ndev, int int_status,
@@ -558,92 +592,73 @@ static int ti_hecc_error(struct net_device *ndev, int int_status,
        struct can_frame *cf;
        struct sk_buff *skb;
        u32 timestamp;
+        int err;
-        /* propagate the error condition to the can stack */
+        if (err_status & HECC_BUS_ERROR) {
-        skb = alloc_can_err_skb(ndev, &cf);
+                /* propagate the error condition to the can stack */
-        if (!skb) {
+                skb = alloc_can_err_skb(ndev, &cf);
-                if (printk_ratelimit())
+                if (!skb) {
-                        netdev_err(priv->ndev,
+                        if (net_ratelimit())
-                                   "%s: alloc_can_err_skb() failed\n",
+                                netdev_err(priv->ndev,
-                                   __func__);
+                                           "%s: alloc_can_err_skb() failed\n",
-                return -ENOMEM;
+                                           __func__);
-        }
+                        return -ENOMEM;
-        if (int_status & HECC_CANGIF_WLIF) { /* warning level int */
-                if ((int_status & HECC_CANGIF_BOIF) == 0) {
-                        priv->can.state = CAN_STATE_ERROR_WARNING;
-                        ++priv->can.can_stats.error_warning;
-                        cf->can_id |= CAN_ERR_CRTL;
-                        if (hecc_read(priv, HECC_CANTEC) > 96)
-                                cf->data[1] |= CAN_ERR_CRTL_TX_WARNING;
-                        if (hecc_read(priv, HECC_CANREC) > 96)
-                                cf->data[1] |= CAN_ERR_CRTL_RX_WARNING;
-                }
-                hecc_set_bit(priv, HECC_CANES, HECC_CANES_EW);
-                netdev_dbg(priv->ndev, "Error Warning interrupt\n");
-                hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR);
-        }
-        if (int_status & HECC_CANGIF_EPIF) { /* error passive int */
-                if ((int_status & HECC_CANGIF_BOIF) == 0) {
-                        priv->can.state = CAN_STATE_ERROR_PASSIVE;
-                        ++priv->can.can_stats.error_passive;
-                        cf->can_id |= CAN_ERR_CRTL;
-                        if (hecc_read(priv, HECC_CANTEC) > 127)
-                                cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;
-                        if (hecc_read(priv, HECC_CANREC) > 127)
-                                cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
                }
-                hecc_set_bit(priv, HECC_CANES, HECC_CANES_EP);
-                netdev_dbg(priv->ndev, "Error passive interrupt\n");
-                hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR);
-        }
-        /* Need to check busoff condition in error status register too to
-         * ensure warning interrupts don't hog the system
-         */
-        if ((int_status & HECC_CANGIF_BOIF) || (err_status & HECC_CANES_BO)) {
-                priv->can.state = CAN_STATE_BUS_OFF;
-                cf->can_id |= CAN_ERR_BUSOFF;
-                hecc_set_bit(priv, HECC_CANES, HECC_CANES_BO);
-                hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR);
-                /* Disable all interrupts in bus-off to avoid int hog */
-                hecc_write(priv, HECC_CANGIM, 0);
-                ++priv->can.can_stats.bus_off;
-                can_bus_off(ndev);
-        }
-        if (err_status & HECC_BUS_ERROR) {
                ++priv->can.can_stats.bus_error;
                cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
-                if (err_status & HECC_CANES_FE) {
+                if (err_status & HECC_CANES_FE)
-                        hecc_set_bit(priv, HECC_CANES, HECC_CANES_FE);
                        cf->data[2] |= CAN_ERR_PROT_FORM;
-                }
+                if (err_status & HECC_CANES_BE)
-                if (err_status & HECC_CANES_BE) {
-                        hecc_set_bit(priv, HECC_CANES, HECC_CANES_BE);
                        cf->data[2] |= CAN_ERR_PROT_BIT;
-                }
+                if (err_status & HECC_CANES_SE)
-                if (err_status & HECC_CANES_SE) {
-                        hecc_set_bit(priv, HECC_CANES, HECC_CANES_SE);
                        cf->data[2] |= CAN_ERR_PROT_STUFF;
-                }
+                if (err_status & HECC_CANES_CRCE)
-                if (err_status & HECC_CANES_CRCE) {
-                        hecc_set_bit(priv, HECC_CANES, HECC_CANES_CRCE);
                        cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
-                }
+                if (err_status & HECC_CANES_ACKE)
-                if (err_status & HECC_CANES_ACKE) {
-                        hecc_set_bit(priv, HECC_CANES, HECC_CANES_ACKE);
                        cf->data[3] = CAN_ERR_PROT_LOC_ACK;
-                }
+                timestamp = hecc_read(priv, HECC_CANLNT);
+                err = can_rx_offload_queue_sorted(&priv->offload, skb,
+                                                  timestamp);
+                if (err)
+                        ndev->stats.rx_fifo_errors++;
        }
-        timestamp = hecc_read(priv, HECC_CANLNT);
+        hecc_write(priv, HECC_CANES, HECC_CANES_FLAGS);
-        can_rx_offload_queue_sorted(&priv->offload, skb, timestamp);
        return 0;
 }
+static void ti_hecc_change_state(struct net_device *ndev,
+                                 enum can_state rx_state,
+                                 enum can_state tx_state)
+{
+        struct ti_hecc_priv *priv = netdev_priv(ndev);
+        struct can_frame *cf;
+        struct sk_buff *skb;
+        u32 timestamp;
+        int err;
+        skb = alloc_can_err_skb(priv->ndev, &cf);
+        if (unlikely(!skb)) {
+                priv->can.state = max(tx_state, rx_state);
+                return;
+        }
+        can_change_state(priv->ndev, cf, tx_state, rx_state);
+        if (max(tx_state, rx_state) != CAN_STATE_BUS_OFF) {
+                cf->data[6] = hecc_read(priv, HECC_CANTEC);
+                cf->data[7] = hecc_read(priv, HECC_CANREC);
+        }
+        timestamp = hecc_read(priv, HECC_CANLNT);
+        err = can_rx_offload_queue_sorted(&priv->offload, skb, timestamp);
+        if (err)
+                ndev->stats.rx_fifo_errors++;
+}
 static irqreturn_t ti_hecc_interrupt(int irq, void *dev_id)
 {
        struct net_device *ndev = (struct net_device *)dev_id;
@@ -651,6 +666,7 @@ static irqreturn_t ti_hecc_interrupt(int irq, void *dev_id)
        struct net_device_stats *stats = &ndev->stats;
        u32 mbxno, mbx_mask, int_status, err_status, stamp;
        unsigned long flags, rx_pending;
+        u32 handled = 0;
        int_status = hecc_read(priv,
                               priv->use_hecc1int ?
@@ -660,17 +676,66 @@ static irqreturn_t ti_hecc_interrupt(int irq, void *dev_id)
                return IRQ_NONE;
        err_status = hecc_read(priv, HECC_CANES);
-        if (err_status & (HECC_BUS_ERROR | HECC_CANES_BO |
+        if (unlikely(err_status & HECC_CANES_FLAGS))
-                          HECC_CANES_EP | HECC_CANES_EW))
                ti_hecc_error(ndev, int_status, err_status);
+        if (unlikely(int_status & HECC_CANGIM_DEF_MASK)) {
+                enum can_state rx_state, tx_state;
+                u32 rec = hecc_read(priv, HECC_CANREC);
+                u32 tec = hecc_read(priv, HECC_CANTEC);
+                if (int_status & HECC_CANGIF_WLIF) {
+                        handled |= HECC_CANGIF_WLIF;
+                        rx_state = rec >= tec ? CAN_STATE_ERROR_WARNING : 0;
+                        tx_state = rec <= tec ? CAN_STATE_ERROR_WARNING : 0;
+                        netdev_dbg(priv->ndev, "Error Warning interrupt\n");
+                        ti_hecc_change_state(ndev, rx_state, tx_state);
+                }
+                if (int_status & HECC_CANGIF_EPIF) {
+                        handled |= HECC_CANGIF_EPIF;
+                        rx_state = rec >= tec ? CAN_STATE_ERROR_PASSIVE : 0;
+                        tx_state = rec <= tec ? CAN_STATE_ERROR_PASSIVE : 0;
+                        netdev_dbg(priv->ndev, "Error passive interrupt\n");
+                        ti_hecc_change_state(ndev, rx_state, tx_state);
+                }
+                if (int_status & HECC_CANGIF_BOIF) {
+                        handled |= HECC_CANGIF_BOIF;
+                        rx_state = CAN_STATE_BUS_OFF;
+                        tx_state = CAN_STATE_BUS_OFF;
+                        netdev_dbg(priv->ndev, "Bus off interrupt\n");
+                        /* Disable all interrupts */
+                        hecc_write(priv, HECC_CANGIM, 0);
+                        can_bus_off(ndev);
+                        ti_hecc_change_state(ndev, rx_state, tx_state);
+                }
+        } else if (unlikely(priv->can.state != CAN_STATE_ERROR_ACTIVE)) {
+                enum can_state new_state, tx_state, rx_state;
+                u32 rec = hecc_read(priv, HECC_CANREC);
+                u32 tec = hecc_read(priv, HECC_CANTEC);
+                if (rec >= 128 || tec >= 128)
+                        new_state = CAN_STATE_ERROR_PASSIVE;
+                else if (rec >= 96 || tec >= 96)
+                        new_state = CAN_STATE_ERROR_WARNING;
+                else
+                        new_state = CAN_STATE_ERROR_ACTIVE;
+                if (new_state < priv->can.state) {
+                        rx_state = rec >= tec ? new_state : 0;
+                        tx_state = rec <= tec ? new_state : 0;
+                        ti_hecc_change_state(ndev, rx_state, tx_state);
+                }
+        }
        if (int_status & HECC_CANGIF_GMIF) {
                while (priv->tx_tail - priv->tx_head > 0) {
                        mbxno = get_tx_tail_mb(priv);
                        mbx_mask = BIT(mbxno);
                        if (!(mbx_mask & hecc_read(priv, HECC_CANTA)))
                                break;
-                        hecc_clear_bit(priv, HECC_CANMIM, mbx_mask);
                        hecc_write(priv, HECC_CANTA, mbx_mask);
                        spin_lock_irqsave(&priv->mbx_lock, flags);
                        hecc_clear_bit(priv, HECC_CANME, mbx_mask);
@@ -695,16 +760,15 @@ static irqreturn_t ti_hecc_interrupt(int irq, void *dev_id)
                while ((rx_pending = hecc_read(priv, HECC_CANRMP))) {
                        can_rx_offload_irq_offload_timestamp(&priv->offload,
                                                             rx_pending);
-                        hecc_write(priv, HECC_CANRMP, rx_pending);
                }
        }
        /* clear all interrupt conditions - read back to avoid spurious ints */
        if (priv->use_hecc1int) {
-                hecc_write(priv, HECC_CANGIF1, HECC_SET_REG);
+                hecc_write(priv, HECC_CANGIF1, handled);
                int_status = hecc_read(priv, HECC_CANGIF1);
        } else {
-                hecc_write(priv, HECC_CANGIF0, HECC_SET_REG);
+                hecc_write(priv, HECC_CANGIF0, handled);
                int_status = hecc_read(priv, HECC_CANGIF0);
        }
@@ -877,7 +941,7 @@ static int ti_hecc_probe(struct platform_device *pdev)
        priv->offload.mailbox_read = ti_hecc_mailbox_read;
        priv->offload.mb_first = HECC_RX_FIRST_MBOX;
-        priv->offload.mb_last = HECC_MAX_TX_MBOX;
+        priv->offload.mb_last = HECC_RX_LAST_MBOX;
        err = can_rx_offload_add_timestamp(ndev, &priv->offload);
        if (err) {
                dev_err(&pdev->dev, "can_rx_offload_add_timestamp() failed\n");
diff --git a/drivers/net/can/usb/gs_usb.c b/drivers/net/can/usb/gs_usb.c
index bd6eb9967630..2f74f6704c12 100644
--- a/drivers/net/can/usb/gs_usb.c
+++ b/drivers/net/can/usb/gs_usb.c
@@ -623,6 +623,7 @@ static int gs_can_open(struct net_device *netdev)
                                           rc);
                                usb_unanchor_urb(urb);
+                                usb_free_urb(urb);
                                break;
                        }
diff --git a/drivers/net/can/usb/mcba_usb.c b/drivers/net/can/usb/mcba_usb.c
index 19a702ac49e4..21faa2ec4632 100644
--- a/drivers/net/can/usb/mcba_usb.c
+++ b/drivers/net/can/usb/mcba_usb.c
@@ -876,9 +876,8 @@ static void mcba_usb_disconnect(struct usb_interface *intf)
        netdev_info(priv->netdev, "device disconnected\n");
        unregister_candev(priv->netdev);
-        free_candev(priv->netdev);
        mcba_urb_unlink(priv);
+        free_candev(priv->netdev);
 }
 static struct usb_driver mcba_usb_driver = {
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb.c b/drivers/net/can/usb/peak_usb/pcan_usb.c
index 617da295b6c1..d2539c95adb6 100644
--- a/drivers/net/can/usb/peak_usb/pcan_usb.c
+++ b/drivers/net/can/usb/peak_usb/pcan_usb.c
@@ -100,7 +100,7 @@ struct pcan_usb_msg_context {
        u8 *end;
        u8 rec_cnt;
        u8 rec_idx;
-        u8 rec_data_idx;
+        u8 rec_ts_idx;
        struct net_device *netdev;
        struct pcan_usb *pdev;
 };
@@ -436,8 +436,8 @@ static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,
                }
                if ((n & PCAN_USB_ERROR_BUS_LIGHT) == 0) {
                        /* no error (back to active state) */
-                        mc->pdev->dev.can.state = CAN_STATE_ERROR_ACTIVE;
+                        new_state = CAN_STATE_ERROR_ACTIVE;
-                        return 0;
+                        break;
                }
                break;
@@ -460,9 +460,9 @@ static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,
                }
                if ((n & PCAN_USB_ERROR_BUS_HEAVY) == 0) {
-                        /* no error (back to active state) */
+                        /* no error (back to warning state) */
-                        mc->pdev->dev.can.state = CAN_STATE_ERROR_ACTIVE;
+                        new_state = CAN_STATE_ERROR_WARNING;
-                        return 0;
+                        break;
                }
                break;
@@ -501,6 +501,11 @@ static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,
                mc->pdev->dev.can.can_stats.error_warning++;
                break;
+        case CAN_STATE_ERROR_ACTIVE:
+                cf->can_id |= CAN_ERR_CRTL;
+                cf->data[1] = CAN_ERR_CRTL_ACTIVE;
+                break;
        default:
                /* CAN_STATE_MAX (trick to handle other errors) */
                cf->can_id |= CAN_ERR_CRTL;
@@ -547,10 +552,15 @@ static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc,
        mc->ptr += PCAN_USB_CMD_ARGS;
        if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
-                int err = pcan_usb_decode_ts(mc, !mc->rec_idx);
+                int err = pcan_usb_decode_ts(mc, !mc->rec_ts_idx);
                if (err)
                        return err;
+                /* Next packet in the buffer will have a timestamp on a single
+                 * byte
+                 */
+                mc->rec_ts_idx++;
        }
        switch (f) {
@@ -632,10 +642,13 @@ static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)
        cf->can_dlc = get_can_dlc(rec_len);
-        /* first data packet timestamp is a word */
+        /* Only first packet timestamp is a word */
-        if (pcan_usb_decode_ts(mc, !mc->rec_data_idx))
+        if (pcan_usb_decode_ts(mc, !mc->rec_ts_idx))
                goto decode_failed;
+        /* Next packet in the buffer will have a timestamp on a single byte */
+        mc->rec_ts_idx++;
        /* read data */
        memset(cf->data, 0x0, sizeof(cf->data));
        if (status_len & PCAN_USB_STATUSLEN_RTR) {
@@ -688,7 +701,6 @@ static int pcan_usb_decode_msg(struct peak_usb_device *dev, u8 *ibuf, u32 lbuf)
                /* handle normal can frames here */
                } else {
                        err = pcan_usb_decode_data(&mc, sl);
-                        mc.rec_data_idx++;
                }
        }
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_core.c b/drivers/net/can/usb/peak_usb/pcan_usb_core.c
index 65dce642b86b..0b7766b715fd 100644
--- a/drivers/net/can/usb/peak_usb/pcan_usb_core.c
+++ b/drivers/net/can/usb/peak_usb/pcan_usb_core.c
@@ -750,7 +750,7 @@ static int peak_usb_create_dev(const struct peak_usb_adapter *peak_usb_adapter,
        dev = netdev_priv(netdev);
        /* allocate a buffer large enough to send commands */
-        dev->cmd_buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_KERNEL);
+        dev->cmd_buf = kzalloc(PCAN_USB_MAX_CMD_LEN, GFP_KERNEL);
        if (!dev->cmd_buf) {
                err = -ENOMEM;
                goto lbl_free_candev;
diff --git a/drivers/net/can/usb/usb_8dev.c b/drivers/net/can/usb/usb_8dev.c
index d596a2ad7f78..8fa224b28218 100644
--- a/drivers/net/can/usb/usb_8dev.c
+++ b/drivers/net/can/usb/usb_8dev.c
@@ -996,9 +996,8 @@ static void usb_8dev_disconnect(struct usb_interface *intf)
                netdev_info(priv->netdev, "device disconnected\n");
                unregister_netdev(priv->netdev);
-                free_candev(priv->netdev);
                unlink_all_urbs(priv);
+                free_candev(priv->netdev);
        }
 }
diff --git a/drivers/net/can/xilinx_can.c b/drivers/net/can/xilinx_can.c
index 911b34316c9d..7c482b2d78d2 100644
--- a/drivers/net/can/xilinx_can.c
+++ b/drivers/net/can/xilinx_can.c
@@ -1599,7 +1599,6 @@ static const struct xcan_devtype_data xcan_zynq_data = {
 static const struct xcan_devtype_data xcan_axi_data = {
        .cantype = XAXI_CAN,
-        .flags = XCAN_FLAG_TXFEMP,
        .bittiming_const = &xcan_bittiming_const,
        .btr_ts2_shift = XCAN_BTR_TS2_SHIFT,
        .btr_sjw_shift = XCAN_BTR_SJW_SHIFT,
diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c
index d44651ad520c..69fc13046ac7 100644
--- a/drivers/net/dsa/bcm_sf2.c
+++ b/drivers/net/dsa/bcm_sf2.c
@@ -1215,10 +1215,10 @@ static int bcm_sf2_sw_remove(struct platform_device *pdev)
        struct bcm_sf2_priv *priv = platform_get_drvdata(pdev);
        priv->wol_ports_mask = 0;
+        /* Disable interrupts */
+        bcm_sf2_intr_disable(priv);
        dsa_unregister_switch(priv->dev->ds);
        bcm_sf2_cfp_exit(priv->dev->ds);
-        /* Disable all ports and interrupts */
-        bcm_sf2_sw_suspend(priv->dev->ds);
        bcm_sf2_mdio_unregister(priv);
        return 0;
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.c b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
index 0f138280315a..1de51811fcb4 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.c
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
@@ -1996,8 +1996,6 @@ static void reset_umac(struct bcmgenet_priv *priv)
        /* issue soft reset with (rg)mii loopback to ensure a stable rxclk */
        bcmgenet_umac_writel(priv, CMD_SW_RESET | CMD_LCL_LOOP_EN, UMAC_CMD);
-        udelay(2);
-        bcmgenet_umac_writel(priv, 0, UMAC_CMD);
 }
 static void bcmgenet_intr_disable(struct bcmgenet_priv *priv)
@@ -2614,8 +2612,10 @@ static void bcmgenet_irq_task(struct work_struct *work)
        spin_unlock_irq(&priv->lock);
        if (status & UMAC_IRQ_PHY_DET_R &&
-            priv->dev->phydev->autoneg != AUTONEG_ENABLE)
+            priv->dev->phydev->autoneg != AUTONEG_ENABLE) {
                phy_init_hw(priv->dev->phydev);
+                genphy_config_aneg(priv->dev->phydev);
+        }
        /* Link UP/DOWN event */
        if (status & UMAC_IRQ_LINK_EVENT)
@@ -2879,12 +2879,6 @@ static int bcmgenet_open(struct net_device *dev)
        if (priv->internal_phy)
                bcmgenet_power_up(priv, GENET_POWER_PASSIVE);
-        ret = bcmgenet_mii_connect(dev);
-        if (ret) {
-                netdev_err(dev, "failed to connect to PHY\n");
-                goto err_clk_disable;
-        }
        /* take MAC out of reset */
        bcmgenet_umac_reset(priv);
@@ -2894,12 +2888,6 @@ static int bcmgenet_open(struct net_device *dev)
        reg = bcmgenet_umac_readl(priv, UMAC_CMD);
        priv->crc_fwd_en = !!(reg & CMD_CRC_FWD);
-        ret = bcmgenet_mii_config(dev, true);
-        if (ret) {
-                netdev_err(dev, "unsupported PHY\n");
-                goto err_disconnect_phy;
-        }
        bcmgenet_set_hw_addr(priv, dev->dev_addr);
        if (priv->internal_phy) {
@@ -2915,7 +2903,7 @@ static int bcmgenet_open(struct net_device *dev)
        ret = bcmgenet_init_dma(priv);
        if (ret) {
                netdev_err(dev, "failed to initialize DMA\n");
-                goto err_disconnect_phy;
+                goto err_clk_disable;
        }
        /* Always enable ring 16 - descriptor ring */
@@ -2938,19 +2926,25 @@ static int bcmgenet_open(struct net_device *dev)
                goto err_irq0;
        }
+        ret = bcmgenet_mii_probe(dev);
+        if (ret) {
+                netdev_err(dev, "failed to connect to PHY\n");
+                goto err_irq1;
+        }
        bcmgenet_netif_start(dev);
        netif_tx_start_all_queues(dev);
        return 0;
+err_irq1:
+        free_irq(priv->irq1, priv);
 err_irq0:
        free_irq(priv->irq0, priv);
 err_fini_dma:
        bcmgenet_dma_teardown(priv);
        bcmgenet_fini_dma(priv);
-err_disconnect_phy:
-        phy_disconnect(dev->phydev);
 err_clk_disable:
        if (priv->internal_phy)
                bcmgenet_power_down(priv, GENET_POWER_PASSIVE);
@@ -3631,8 +3625,6 @@ static int bcmgenet_resume(struct device *d)
        if (priv->internal_phy)
                bcmgenet_power_up(priv, GENET_POWER_PASSIVE);
-        phy_init_hw(dev->phydev);
        bcmgenet_umac_reset(priv);
        init_umac(priv);
@@ -3641,7 +3633,10 @@ static int bcmgenet_resume(struct device *d)
        if (priv->wolopts)
                clk_disable_unprepare(priv->clk_wol);
+        phy_init_hw(dev->phydev);
        /* Speed settings must be restored */
+        genphy_config_aneg(dev->phydev);
        bcmgenet_mii_config(priv->dev, false);
        bcmgenet_set_hw_addr(priv, dev->dev_addr);
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.h b/drivers/net/ethernet/broadcom/genet/bcmgenet.h
index 7fbf573d8d52..dbc69d8fa05f 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.h
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.h
@@ -720,8 +720,8 @@ GENET_IO_MACRO(rbuf, GENET_RBUF_OFF);
 /* MDIO routines */
 int bcmgenet_mii_init(struct net_device *dev);
-int bcmgenet_mii_connect(struct net_device *dev);
 int bcmgenet_mii_config(struct net_device *dev, bool init);
+int bcmgenet_mii_probe(struct net_device *dev);
 void bcmgenet_mii_exit(struct net_device *dev);
 void bcmgenet_phy_power_set(struct net_device *dev, bool enable);
 void bcmgenet_mii_setup(struct net_device *dev);
diff --git a/drivers/net/ethernet/broadcom/genet/bcmmii.c b/drivers/net/ethernet/broadcom/genet/bcmmii.c
index 17bb8d60a157..dbe18cdf6c1b 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmmii.c
+++ b/drivers/net/ethernet/broadcom/genet/bcmmii.c
@@ -173,46 +173,6 @@ static void bcmgenet_moca_phy_setup(struct bcmgenet_priv *priv)
                                          bcmgenet_fixed_phy_link_update);
 }
-int bcmgenet_mii_connect(struct net_device *dev)
-{
-        struct bcmgenet_priv *priv = netdev_priv(dev);
-        struct device_node *dn = priv->pdev->dev.of_node;
-        struct phy_device *phydev;
-        u32 phy_flags = 0;
-        int ret;
-        /* Communicate the integrated PHY revision */
-        if (priv->internal_phy)
-                phy_flags = priv->gphy_rev;
-        /* Initialize link state variables that bcmgenet_mii_setup() uses */
-        priv->old_link = -1;
-        priv->old_speed = -1;
-        priv->old_duplex = -1;
-        priv->old_pause = -1;
-        if (dn) {
-                phydev = of_phy_connect(dev, priv->phy_dn, bcmgenet_mii_setup,
-                                        phy_flags, priv->phy_interface);
-                if (!phydev) {
-                        pr_err("could not attach to PHY\n");
-                        return -ENODEV;
-                }
-        } else {
-                phydev = dev->phydev;
-                phydev->dev_flags = phy_flags;
-                ret = phy_connect_direct(dev, phydev, bcmgenet_mii_setup,
-                                         priv->phy_interface);
-                if (ret) {
-                        pr_err("could not attach to PHY\n");
-                        return -ENODEV;
-                }
-        }
-        return 0;
-}
 int bcmgenet_mii_config(struct net_device *dev, bool init)
 {
        struct bcmgenet_priv *priv = netdev_priv(dev);
@@ -221,8 +181,38 @@ int bcmgenet_mii_config(struct net_device *dev, bool init)
        const char *phy_name = NULL;
        u32 id_mode_dis = 0;
        u32 port_ctrl;
+        int bmcr = -1;
+        int ret;
        u32 reg;
+        /* MAC clocking workaround during reset of umac state machines */
+        reg = bcmgenet_umac_readl(priv, UMAC_CMD);
+        if (reg & CMD_SW_RESET) {
+                /* An MII PHY must be isolated to prevent TXC contention */
+                if (priv->phy_interface == PHY_INTERFACE_MODE_MII) {
+                        ret = phy_read(phydev, MII_BMCR);
+                        if (ret >= 0) {
+                                bmcr = ret;
+                                ret = phy_write(phydev, MII_BMCR,
+                                                bmcr | BMCR_ISOLATE);
+                        }
+                        if (ret) {
+                                netdev_err(dev, "failed to isolate PHY\n");
+                                return ret;
+                        }
+                }
+                /* Switch MAC clocking to RGMII generated clock */
+                bcmgenet_sys_writel(priv, PORT_MODE_EXT_GPHY, SYS_PORT_CTRL);
+                /* Ensure 5 clks with Rx disabled
+                 * followed by 5 clks with Reset asserted
+                 */
+                udelay(4);
+                reg &= ~(CMD_SW_RESET | CMD_LCL_LOOP_EN);
+                bcmgenet_umac_writel(priv, reg, UMAC_CMD);
+                /* Ensure 5 more clocks before Rx is enabled */
+                udelay(2);
+        }
        priv->ext_phy = !priv->internal_phy &&
                        (priv->phy_interface != PHY_INTERFACE_MODE_MOCA);
@@ -254,6 +244,9 @@ int bcmgenet_mii_config(struct net_device *dev, bool init)
                phy_set_max_speed(phydev, SPEED_100);
                bcmgenet_sys_writel(priv,
                                    PORT_MODE_EXT_EPHY, SYS_PORT_CTRL);
+                /* Restore the MII PHY after isolation */
+                if (bmcr >= 0)
+                        phy_write(phydev, MII_BMCR, bmcr);
                break;
        case PHY_INTERFACE_MODE_REVMII:
@@ -306,21 +299,71 @@ int bcmgenet_mii_config(struct net_device *dev, bool init)
                bcmgenet_ext_writel(priv, reg, EXT_RGMII_OOB_CTRL);
        }
-        if (init) {
+        if (init)
-                linkmode_copy(phydev->advertising, phydev->supported);
+                dev_info(kdev, "configuring instance for %s\n", phy_name);
-                /* The internal PHY has its link interrupts routed to the
+        return 0;
-                 * Ethernet MAC ISRs. On GENETv5 there is a hardware issue
+}
-                 * that prevents the signaling of link UP interrupts when
-                 * the link operates at 10Mbps, so fallback to polling for
-                 * those versions of GENET.
-                 */
-                if (priv->internal_phy && !GENET_IS_V5(priv))
-                        phydev->irq = PHY_IGNORE_INTERRUPT;
-                dev_info(kdev, "configuring instance for %s\n", phy_name);
+int bcmgenet_mii_probe(struct net_device *dev)
+{
+        struct bcmgenet_priv *priv = netdev_priv(dev);
+        struct device_node *dn = priv->pdev->dev.of_node;
+        struct phy_device *phydev;
+        u32 phy_flags = 0;
+        int ret;
+        /* Communicate the integrated PHY revision */
+        if (priv->internal_phy)
+                phy_flags = priv->gphy_rev;
+        /* Initialize link state variables that bcmgenet_mii_setup() uses */
+        priv->old_link = -1;
+        priv->old_speed = -1;
+        priv->old_duplex = -1;
+        priv->old_pause = -1;
+        if (dn) {
+                phydev = of_phy_connect(dev, priv->phy_dn, bcmgenet_mii_setup,
+                                        phy_flags, priv->phy_interface);
+                if (!phydev) {
+                        pr_err("could not attach to PHY\n");
+                        return -ENODEV;
+                }
+        } else {
+                phydev = dev->phydev;
+                phydev->dev_flags = phy_flags;
+                ret = phy_connect_direct(dev, phydev, bcmgenet_mii_setup,
+                                         priv->phy_interface);
+                if (ret) {
+                        pr_err("could not attach to PHY\n");
+                        return -ENODEV;
+                }
        }
+        /* Configure port multiplexer based on what the probed PHY device since
+         * reading the 'max-speed' property determines the maximum supported
+         * PHY speed which is needed for bcmgenet_mii_config() to configure
+         * things appropriately.
+         */
+        ret = bcmgenet_mii_config(dev, true);
+        if (ret) {
+                phy_disconnect(dev->phydev);
+                return ret;
+        }
+        linkmode_copy(phydev->advertising, phydev->supported);
+        /* The internal PHY has its link interrupts routed to the
+         * Ethernet MAC ISRs. On GENETv5 there is a hardware issue
+         * that prevents the signaling of link UP interrupts when
+         * the link operates at 10Mbps, so fallback to polling for
+         * those versions of GENET.
+         */
+        if (priv->internal_phy && !GENET_IS_V5(priv))
+                dev->phydev->irq = PHY_IGNORE_INTERRUPT;
        return 0;
 }
diff --git a/drivers/net/ethernet/cavium/octeon/octeon_mgmt.c b/drivers/net/ethernet/cavium/octeon/octeon_mgmt.c
index 0e5de88fd6e8..cdd7e5da4a74 100644
--- a/drivers/net/ethernet/cavium/octeon/octeon_mgmt.c
+++ b/drivers/net/ethernet/cavium/octeon/octeon_mgmt.c
@@ -1499,7 +1499,7 @@ static int octeon_mgmt_probe(struct platform_device *pdev)
        netdev->ethtool_ops = &octeon_mgmt_ethtool_ops;
        netdev->min_mtu = 64 - OCTEON_MGMT_RX_HEADROOM;
-        netdev->max_mtu = 16383 - OCTEON_MGMT_RX_HEADROOM;
+        netdev->max_mtu = 16383 - OCTEON_MGMT_RX_HEADROOM - VLAN_HLEN;
        mac = of_get_mac_address(pdev->dev.of_node);
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index 22c01b224baa..a9c386b63581 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -3645,6 +3645,8 @@ fec_drv_remove(struct platform_device *pdev)
                regulator_disable(fep->reg_phy);
        pm_runtime_put(&pdev->dev);
        pm_runtime_disable(&pdev->dev);
+        clk_disable_unprepare(fep->clk_ahb);
+        clk_disable_unprepare(fep->clk_ipg);
        if (of_phy_is_fixed_link(np))
                of_phy_deregister_fixed_link(np);
        of_node_put(fep->phy_node);
diff --git a/drivers/net/ethernet/hisilicon/hns/hnae.c b/drivers/net/ethernet/hisilicon/hns/hnae.c
index 6d0457eb4faa..08339278c722 100644
--- a/drivers/net/ethernet/hisilicon/hns/hnae.c
+++ b/drivers/net/ethernet/hisilicon/hns/hnae.c
@@ -199,7 +199,6 @@ hnae_init_ring(struct hnae_queue *q, struct hnae_ring *ring, int flags)
        ring->q = q;
        ring->flags = flags;
-        spin_lock_init(&ring->lock);
        ring->coal_param = q->handle->coal_param;
        assert(!ring->desc && !ring->desc_cb && !ring->desc_dma_addr);
diff --git a/drivers/net/ethernet/hisilicon/hns/hnae.h b/drivers/net/ethernet/hisilicon/hns/hnae.h
index e9c67c06bfd2..6ab9458302e1 100644
--- a/drivers/net/ethernet/hisilicon/hns/hnae.h
+++ b/drivers/net/ethernet/hisilicon/hns/hnae.h
@@ -274,9 +274,6 @@ struct hnae_ring {
        /* statistic */
        struct ring_stats stats;
-        /* ring lock for poll one */
-        spinlock_t lock;
        dma_addr_t desc_dma_addr;
        u32 buf_size;       /* size for hnae_desc->addr, preset by AE */
        u16 desc_num;       /* total number of desc */
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_enet.c b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
index a48396dd4ebb..14ab20491fd0 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_enet.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
@@ -943,15 +943,6 @@ static int is_valid_clean_head(struct hnae_ring *ring, int h)
        return u > c ? (h > c && h <= u) : (h > c || h <= u);
 }
-/* netif_tx_lock will turn down the performance, set only when necessary */
-#ifdef CONFIG_NET_POLL_CONTROLLER
-#define NETIF_TX_LOCK(ring) spin_lock(&(ring)->lock)
-#define NETIF_TX_UNLOCK(ring) spin_unlock(&(ring)->lock)
-#else
-#define NETIF_TX_LOCK(ring)
-#define NETIF_TX_UNLOCK(ring)
-#endif
 /* reclaim all desc in one budget
 * return error or number of desc left
 */
@@ -965,21 +956,16 @@ static int hns_nic_tx_poll_one(struct hns_nic_ring_data *ring_data,
        int head;
        int bytes, pkts;
-        NETIF_TX_LOCK(ring);
        head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
        rmb(); /* make sure head is ready before touch any data */
-        if (is_ring_empty(ring) || head == ring->next_to_clean) {
+        if (is_ring_empty(ring) || head == ring->next_to_clean)
-                NETIF_TX_UNLOCK(ring);
                return 0; /* no data to poll */
-        }
        if (!is_valid_clean_head(ring, head)) {
                netdev_err(ndev, "wrong head (%d, %d-%d)\n", head,
                           ring->next_to_use, ring->next_to_clean);
                ring->stats.io_err_cnt++;
-                NETIF_TX_UNLOCK(ring);
                return -EIO;
        }
@@ -994,8 +980,6 @@ static int hns_nic_tx_poll_one(struct hns_nic_ring_data *ring_data,
        ring->stats.tx_pkts += pkts;
        ring->stats.tx_bytes += bytes;
-        NETIF_TX_UNLOCK(ring);
        dev_queue = netdev_get_tx_queue(ndev, ring_data->queue_index);
        netdev_tx_completed_queue(dev_queue, pkts, bytes);
@@ -1055,16 +1039,12 @@ static void hns_nic_tx_clr_all_bufs(struct hns_nic_ring_data *ring_data)
        int head;
        int bytes, pkts;
-        NETIF_TX_LOCK(ring);
        head = ring->next_to_use; /* ntu :soft setted ring position*/
        bytes = 0;
        pkts = 0;
        while (head != ring->next_to_clean)
                hns_nic_reclaim_one_desc(ring, &bytes, &pkts);
-        NETIF_TX_UNLOCK(ring);
        dev_queue = netdev_get_tx_queue(ndev, ring_data->queue_index);
        netdev_tx_reset_queue(dev_queue);
 }
diff --git a/drivers/net/ethernet/hisilicon/hns3/hnae3.h b/drivers/net/ethernet/hisilicon/hns3/hnae3.h
index 75ccc1e7076b..a0998937727d 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hnae3.h
+++ b/drivers/net/ethernet/hisilicon/hns3/hnae3.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 // Copyright (c) 2016-2017 Hisilicon Limited.
 #ifndef __HNAE3_H
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.h b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.h
index 2110fa3b4479..5d468ed404a6 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.h
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 // Copyright (c) 2016-2017 Hisilicon Limited.
 #ifndef __HNS3_ENET_H
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.h b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.h
index 4821fe08b5e4..1426eb5ddf3d 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.h
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 // Copyright (c) 2016-2017 Hisilicon Limited.
 #ifndef __HCLGE_CMD_H
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.h b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.h
index 278f21e02736..b04702e65689 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.h
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 // Copyright (c) 2016-2017 Hisilicon Limited.
 #ifndef __HCLGE_DCB_H__
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
index e02e01bd9eff..16f7d0e15b4f 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
@@ -3587,12 +3587,28 @@ static int hclge_set_rst_done(struct hclge_dev *hdev)
 {
        struct hclge_pf_rst_done_cmd *req;
        struct hclge_desc desc;
+        int ret;
        req = (struct hclge_pf_rst_done_cmd *)desc.data;
        hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_PF_RST_DONE, false);
        req->pf_rst_done |= HCLGE_PF_RESET_DONE_BIT;
-        return hclge_cmd_send(&hdev->hw, &desc, 1);
+        ret = hclge_cmd_send(&hdev->hw, &desc, 1);
+        /* To be compatible with the old firmware, which does not support
+         * command HCLGE_OPC_PF_RST_DONE, just print a warning and
+         * return success
+         */
+        if (ret == -EOPNOTSUPP) {
+                dev_warn(&hdev->pdev->dev,
+                         "current firmware does not support command(0x%x)!\n",
+                         HCLGE_OPC_PF_RST_DONE);
+                return 0;
+        } else if (ret) {
+                dev_err(&hdev->pdev->dev, "assert PF reset done fail %d!\n",
+                        ret);
+        }
+        return ret;
 }
 static int hclge_reset_prepare_up(struct hclge_dev *hdev)
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h
index c3d56b872ed7..59b824347ba4 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 // Copyright (c) 2016-2017 Hisilicon Limited.
 #ifndef __HCLGE_MAIN_H
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mdio.h b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mdio.h
index ef095d9c566f..dd9a1218a7b0 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mdio.h
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mdio.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 // Copyright (c) 2016-2017 Hisilicon Limited.
 #ifndef __HCLGE_MDIO_H
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.h b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.h
index 818610988d34..260f22d19d81 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.h
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 // Copyright (c) 2016-2017 Hisilicon Limited.
 #ifndef __HCLGE_TM_H
diff --git a/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h b/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
index 530613f31527..69a2daaca5c5 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_adminq_cmd.h
@@ -20,6 +20,8 @@
 /* API version 1.7 implements additional link and PHY-specific APIs  */
 #define I40E_MINOR_VER_GET_LINK_INFO_XL710 0x0007
+/* API version 1.9 for X722 implements additional link and PHY-specific APIs */
+#define I40E_MINOR_VER_GET_LINK_INFO_X722 0x0009
 /* API version 1.6 for X722 devices adds ability to stop FW LLDP agent */
 #define I40E_MINOR_VER_FW_LLDP_STOPPABLE_X722 0x0006
diff --git a/drivers/net/ethernet/intel/i40e/i40e_common.c b/drivers/net/ethernet/intel/i40e/i40e_common.c
index d37c6e0e5f08..7560f06768e0 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_common.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_common.c
@@ -1876,7 +1876,8 @@ i40e_status i40e_aq_get_link_info(struct i40e_hw *hw,
             hw->aq.fw_min_ver < 40)) && hw_link_info->phy_type == 0xE)
                hw_link_info->phy_type = I40E_PHY_TYPE_10GBASE_SFPP_CU;
-        if (hw->flags & I40E_HW_FLAG_AQ_PHY_ACCESS_CAPABLE) {
+        if (hw->flags & I40E_HW_FLAG_AQ_PHY_ACCESS_CAPABLE &&
+            hw->mac.type != I40E_MAC_X722) {
                __le32 tmp;
                memcpy(&tmp, resp->link_type, sizeof(tmp));
diff --git a/drivers/net/ethernet/intel/i40e/i40e_xsk.c b/drivers/net/ethernet/intel/i40e/i40e_xsk.c
index a05dfecdd9b4..d07e1a890428 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_xsk.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_xsk.c
@@ -689,8 +689,6 @@ static bool i40e_xmit_zc(struct i40e_ring *xdp_ring, unsigned int budget)
                i40e_xdp_ring_update_tail(xdp_ring);
                xsk_umem_consume_tx_done(xdp_ring->xsk_umem);
-                if (xsk_umem_uses_need_wakeup(xdp_ring->xsk_umem))
-                        xsk_clear_tx_need_wakeup(xdp_ring->xsk_umem);
        }
        return !!budget && work_done;
@@ -769,12 +767,8 @@ bool i40e_clean_xdp_tx_irq(struct i40e_vsi *vsi,
        i40e_update_tx_stats(tx_ring, completed_frames, total_bytes);
 out_xmit:
-        if (xsk_umem_uses_need_wakeup(tx_ring->xsk_umem)) {
+        if (xsk_umem_uses_need_wakeup(tx_ring->xsk_umem))
-                if (tx_ring->next_to_clean == tx_ring->next_to_use)
+                xsk_set_tx_need_wakeup(tx_ring->xsk_umem);
-                        xsk_set_tx_need_wakeup(tx_ring->xsk_umem);
-                else
-                        xsk_clear_tx_need_wakeup(tx_ring->xsk_umem);
-        }
        xmit_done = i40e_xmit_zc(tx_ring, budget);
diff --git a/drivers/net/ethernet/intel/iavf/iavf_main.c b/drivers/net/ethernet/intel/iavf/iavf_main.c
index 8f310e520b06..821987da5698 100644
--- a/drivers/net/ethernet/intel/iavf/iavf_main.c
+++ b/drivers/net/ethernet/intel/iavf/iavf_main.c
@@ -314,7 +314,7 @@ iavf_map_vector_to_rxq(struct iavf_adapter *adapter, int v_idx, int r_idx)
        q_vector->rx.target_itr = ITR_TO_REG(rx_ring->itr_setting);
        q_vector->ring_mask |= BIT(r_idx);
        wr32(hw, IAVF_VFINT_ITRN1(IAVF_RX_ITR, q_vector->reg_idx),
-             q_vector->rx.current_itr);
+             q_vector->rx.current_itr >> 1);
        q_vector->rx.current_itr = q_vector->rx.target_itr;
 }
@@ -340,7 +340,7 @@ iavf_map_vector_to_txq(struct iavf_adapter *adapter, int v_idx, int t_idx)
        q_vector->tx.target_itr = ITR_TO_REG(tx_ring->itr_setting);
        q_vector->num_ringpairs++;
        wr32(hw, IAVF_VFINT_ITRN1(IAVF_TX_ITR, q_vector->reg_idx),
-             q_vector->tx.target_itr);
+             q_vector->tx.target_itr >> 1);
        q_vector->tx.current_itr = q_vector->tx.target_itr;
 }
diff --git a/drivers/net/ethernet/intel/ice/ice_sched.c b/drivers/net/ethernet/intel/ice/ice_sched.c
index fc624b73d05d..2fde9653a608 100644
--- a/drivers/net/ethernet/intel/ice/ice_sched.c
+++ b/drivers/net/ethernet/intel/ice/ice_sched.c
@@ -1036,7 +1036,7 @@ enum ice_status ice_sched_query_res_alloc(struct ice_hw *hw)
        struct ice_aqc_query_txsched_res_resp *buf;
        enum ice_status status = 0;
        __le16 max_sibl;
-        u8 i;
+        u16 i;
        if (hw->layer_info)
                return status;
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index 9148c62d9ac5..ed7e667d7eb2 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -5675,8 +5675,8 @@ static void igb_tx_ctxtdesc(struct igb_ring *tx_ring,
         * should have been handled by the upper layers.
         */
        if (tx_ring->launchtime_enable) {
-                ts = ns_to_timespec64(first->skb->tstamp);
+                ts = ktime_to_timespec64(first->skb->tstamp);
-                first->skb->tstamp = 0;
+                first->skb->tstamp = ktime_set(0, 0);
                context_desc->seqnum_seed = cpu_to_le32(ts.tv_nsec / 32);
        } else {
                context_desc->seqnum_seed = 0;
diff --git a/drivers/net/ethernet/intel/igc/igc_main.c b/drivers/net/ethernet/intel/igc/igc_main.c
index 8e424dfab12e..24888676f69b 100644
--- a/drivers/net/ethernet/intel/igc/igc_main.c
+++ b/drivers/net/ethernet/intel/igc/igc_main.c
@@ -824,8 +824,8 @@ static void igc_tx_ctxtdesc(struct igc_ring *tx_ring,
         * should have been handled by the upper layers.
         */
        if (tx_ring->launchtime_enable) {
-                ts = ns_to_timespec64(first->skb->tstamp);
+                ts = ktime_to_timespec64(first->skb->tstamp);
-                first->skb->tstamp = 0;
+                first->skb->tstamp = ktime_set(0, 0);
                context_desc->launch_time = cpu_to_le32(ts.tv_nsec / 32);
        } else {
                context_desc->launch_time = 0;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c
index 100ac89b345d..d6feaacfbf89 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c
@@ -622,8 +622,6 @@ static bool ixgbe_xmit_zc(struct ixgbe_ring *xdp_ring, unsigned int budget)
        if (tx_desc) {
                ixgbe_xdp_ring_update_tail(xdp_ring);
                xsk_umem_consume_tx_done(xdp_ring->xsk_umem);
-                if (xsk_umem_uses_need_wakeup(xdp_ring->xsk_umem))
-                        xsk_clear_tx_need_wakeup(xdp_ring->xsk_umem);
        }
        return !!budget && work_done;
@@ -691,12 +689,8 @@ bool ixgbe_clean_xdp_tx_irq(struct ixgbe_q_vector *q_vector,
        if (xsk_frames)
                xsk_umem_complete_tx(umem, xsk_frames);
-        if (xsk_umem_uses_need_wakeup(tx_ring->xsk_umem)) {
+        if (xsk_umem_uses_need_wakeup(tx_ring->xsk_umem))
-                if (tx_ring->next_to_clean == tx_ring->next_to_use)
+                xsk_set_tx_need_wakeup(tx_ring->xsk_umem);
-                        xsk_set_tx_need_wakeup(tx_ring->xsk_umem);
-                else
-                        xsk_clear_tx_need_wakeup(tx_ring->xsk_umem);
-        }
        return ixgbe_xmit_zc(tx_ring, q_vector->tx.work_limit);
 }
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index fce9b3a24347..69bb6bb06e76 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -514,8 +514,7 @@ static int mlx4_dev_cap(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
        dev->caps.max_rq_desc_sz     = dev_cap->max_rq_desc_sz;
        /*
         * Subtract 1 from the limit because we need to allocate a
-         * spare CQE so the HCA HW can tell the difference between an
+         * spare CQE to enable resizing the CQ.
-         * empty CQ and a full CQ.
         */
        dev->caps.max_cqes           = dev_cap->max_cq_sz - 1;
        dev->caps.reserved_cqs       = dev_cap->reserved_cqs;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c
index 369499e88fe8..9004a07e457a 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c
@@ -1079,7 +1079,7 @@ static int esw_create_offloads_fdb_tables(struct mlx5_eswitch *esw, int nvports)
                            MLX5_CAP_GEN(dev, max_flow_counter_15_0);
        fdb_max = 1 << MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size);
-        esw_debug(dev, "Create offloads FDB table, min (max esw size(2^%d), max counters(%d), groups(%d), max flow table size(2^%d))\n",
+        esw_debug(dev, "Create offloads FDB table, min (max esw size(2^%d), max counters(%d), groups(%d), max flow table size(%d))\n",
                  MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size),
                  max_flow_counter, ESW_OFFLOADS_NUM_GROUPS,
                  fdb_max);
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads_termtbl.c b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads_termtbl.c
index 7879e1746297..366bda1bb1c3 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads_termtbl.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads_termtbl.c
@@ -183,7 +183,8 @@ static bool mlx5_eswitch_offload_is_uplink_port(const struct mlx5_eswitch *esw,
        u32 port_mask, port_value;
        if (MLX5_CAP_ESW_FLOWTABLE(esw->dev, flow_source))
-                return spec->flow_context.flow_source == MLX5_VPORT_UPLINK;
+                return spec->flow_context.flow_source ==
+                                        MLX5_FLOW_CONTEXT_FLOW_SOURCE_UPLINK;
        port_mask = MLX5_GET(fte_match_param, spec->match_criteria,
                             misc_parameters.source_port);
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_action.c b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_action.c
index b74b7d0f6590..004c56c2fc0c 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_action.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_action.c
@@ -1577,6 +1577,7 @@ int mlx5dr_action_destroy(struct mlx5dr_action *action)
                break;
        case DR_ACTION_TYP_MODIFY_HDR:
                mlx5dr_icm_free_chunk(action->rewrite.chunk);
+                kfree(action->rewrite.data);
                refcount_dec(&action->rewrite.dmn->refcount);
                break;
        default:
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c
index e8b656075c6f..5dcb8baf491a 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c
@@ -1096,6 +1096,8 @@ dr_rule_create_rule_nic(struct mlx5dr_rule *rule,
        if (htbl)
                mlx5dr_htbl_put(htbl);
+        kfree(hw_ste_arr);
        return 0;
 free_ste:
diff --git a/drivers/net/ethernet/mscc/ocelot.c b/drivers/net/ethernet/mscc/ocelot.c
index 344539c0d3aa..672ea1342add 100644
--- a/drivers/net/ethernet/mscc/ocelot.c
+++ b/drivers/net/ethernet/mscc/ocelot.c
@@ -1680,9 +1680,6 @@ static int ocelot_netdevice_port_event(struct net_device *dev,
        struct ocelot_port *ocelot_port = netdev_priv(dev);
        int err = 0;
-        if (!ocelot_netdevice_dev_check(dev))
-                return 0;
        switch (event) {
        case NETDEV_CHANGEUPPER:
                if (netif_is_bridge_master(info->upper_dev)) {
@@ -1719,12 +1716,16 @@ static int ocelot_netdevice_event(struct notifier_block *unused,
        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        int ret = 0;
+        if (!ocelot_netdevice_dev_check(dev))
+                return 0;
        if (event == NETDEV_PRECHANGEUPPER &&
            netif_is_lag_master(info->upper_dev)) {
                struct netdev_lag_upper_info *lag_upper_info = info->upper_info;
                struct netlink_ext_ack *extack;
-                if (lag_upper_info->tx_type != NETDEV_LAG_TX_TYPE_HASH) {
+                if (lag_upper_info &&
+                    lag_upper_info->tx_type != NETDEV_LAG_TX_TYPE_HASH) {
                        extack = netdev_notifier_info_to_extack(&info->info);
                        NL_SET_ERR_MSG_MOD(extack, "LAG device using unsupported Tx type");
diff --git a/drivers/net/ethernet/mscc/ocelot.h b/drivers/net/ethernet/mscc/ocelot.h
index e40773c01a44..06ac806052bc 100644
--- a/drivers/net/ethernet/mscc/ocelot.h
+++ b/drivers/net/ethernet/mscc/ocelot.h
@@ -523,7 +523,7 @@ void __ocelot_write_ix(struct ocelot *ocelot, u32 val, u32 reg, u32 offset);
 #define ocelot_write_rix(ocelot, val, reg, ri) __ocelot_write_ix(ocelot, val, reg, reg##_RSZ * (ri))
 #define ocelot_write(ocelot, val, reg) __ocelot_write_ix(ocelot, val, reg, 0)
-void __ocelot_rmw_ix(struct ocelot *ocelot, u32 val, u32 reg, u32 mask,
+void __ocelot_rmw_ix(struct ocelot *ocelot, u32 val, u32 mask, u32 reg,
                     u32 offset);
 #define ocelot_rmw_ix(ocelot, val, m, reg, gi, ri) __ocelot_rmw_ix(ocelot, val, m, reg, reg##_GSZ * (gi) + reg##_RSZ * (ri))
 #define ocelot_rmw_gix(ocelot, val, m, reg, gi) __ocelot_rmw_ix(ocelot, val, m, reg, reg##_GSZ * (gi))
diff --git a/drivers/net/ethernet/qlogic/qede/qede_main.c b/drivers/net/ethernet/qlogic/qede/qede_main.c
index 8d1c208f778f..a220cc7c947a 100644
--- a/drivers/net/ethernet/qlogic/qede/qede_main.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_main.c
@@ -1208,8 +1208,16 @@ enum qede_remove_mode {
 static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode)
 {
        struct net_device *ndev = pci_get_drvdata(pdev);
-        struct qede_dev *edev = netdev_priv(ndev);
+        struct qede_dev *edev;
-        struct qed_dev *cdev = edev->cdev;
+        struct qed_dev *cdev;
+        if (!ndev) {
+                dev_info(&pdev->dev, "Device has already been removed\n");
+                return;
+        }
+        edev = netdev_priv(ndev);
+        cdev = edev->cdev;
        DP_INFO(edev, "Starting qede_remove\n");
diff --git a/drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c b/drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c
index 9c54b715228e..06de59521fc4 100644
--- a/drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c
+++ b/drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c
@@ -57,10 +57,10 @@ static int rmnet_unregister_real_device(struct net_device *real_dev,
        if (port->nr_rmnet_devs)
                return -EINVAL;
-        kfree(port);
        netdev_rx_handler_unregister(real_dev);
+        kfree(port);
        /* release reference on real_dev */
        dev_put(real_dev);
diff --git a/drivers/net/ethernet/realtek/r8169_main.c b/drivers/net/ethernet/realtek/r8169_main.c
index 5064c292b873..c4e961ea44d5 100644
--- a/drivers/net/ethernet/realtek/r8169_main.c
+++ b/drivers/net/ethernet/realtek/r8169_main.c
@@ -916,6 +916,9 @@ static void r8168g_mdio_write(struct rtl8169_private *tp, int reg, int value)
 static int r8168g_mdio_read(struct rtl8169_private *tp, int reg)
 {
+        if (reg == 0x1f)
+                return tp->ocp_base == OCP_STD_PHY_BASE ? 0 : tp->ocp_base >> 4;
        if (tp->ocp_base != OCP_STD_PHY_BASE)
                reg -= 0x10;
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c b/drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c
index 5a7b0aca1d31..66e60c7e9850 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c
@@ -432,7 +432,7 @@ static void dwmac4_set_filter(struct mac_device_info *hw,
                         * bits used depends on the hardware configuration
                         * selected at core configuration time.
                         */
-                        int bit_nr = bitrev32(~crc32_le(~0, ha->addr,
+                        u32 bit_nr = bitrev32(~crc32_le(~0, ha->addr,
                                        ETH_ALEN)) >> (32 - mcbitslog2);
                        /* The most significant bit determines the register to
                         * use (H/L) while the other 5 bits determine the bit
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_core.c b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_core.c
index 5031398e612c..070bd7d1ae4c 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_core.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_core.c
@@ -224,6 +224,7 @@ static void dwxgmac2_config_cbs(struct mac_device_info *hw,
        writel(low_credit, ioaddr + XGMAC_MTL_TCx_LOCREDIT(queue));
        value = readl(ioaddr + XGMAC_MTL_TCx_ETS_CONTROL(queue));
+        value &= ~XGMAC_TSA;
        value |= XGMAC_CC | XGMAC_CBS;
        writel(value, ioaddr + XGMAC_MTL_TCx_ETS_CONTROL(queue));
 }
@@ -463,7 +464,7 @@ static void dwxgmac2_set_filter(struct mac_device_info *hw,
                value |= XGMAC_FILTER_HMC;
                netdev_for_each_mc_addr(ha, dev) {
-                        int nr = (bitrev32(~crc32_le(~0, ha->addr, 6)) >>
+                        u32 nr = (bitrev32(~crc32_le(~0, ha->addr, 6)) >>
                                        (32 - mcbitslog2));
                        mc_filter[nr >> 5] |= (1 << (nr & 0x1F));
                }
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c
index ae48154f933c..bd5838ce1e8a 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c
@@ -288,7 +288,8 @@ static int dwxgmac2_get_rx_hash(struct dma_desc *p, u32 *hash,
 static int dwxgmac2_get_rx_header_len(struct dma_desc *p, unsigned int *len)
 {
-        *len = le32_to_cpu(p->des2) & XGMAC_RDES2_HL;
+        if (le32_to_cpu(p->des3) & XGMAC_RDES3_L34T)
+                *len = le32_to_cpu(p->des2) & XGMAC_RDES2_HL;
        return 0;
 }
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c
index 965cbe3e6f51..f70ca5300b82 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c
@@ -369,7 +369,7 @@ static void dwxgmac2_get_hw_feature(void __iomem *ioaddr,
        dma_cap->eee = (hw_cap & XGMAC_HWFEAT_EEESEL) >> 13;
        dma_cap->atime_stamp = (hw_cap & XGMAC_HWFEAT_TSSEL) >> 12;
        dma_cap->av = (hw_cap & XGMAC_HWFEAT_AVSEL) >> 11;
-        dma_cap->av &= !(hw_cap & XGMAC_HWFEAT_RAVSEL) >> 10;
+        dma_cap->av &= !((hw_cap & XGMAC_HWFEAT_RAVSEL) >> 10);
        dma_cap->arpoffsel = (hw_cap & XGMAC_HWFEAT_ARPOFFSEL) >> 9;
        dma_cap->rmon = (hw_cap & XGMAC_HWFEAT_MMCSEL) >> 8;
        dma_cap->pmt_magic_frame = (hw_cap & XGMAC_HWFEAT_MGKSEL) >> 7;
@@ -470,6 +470,7 @@ static void dwxgmac2_enable_tso(void __iomem *ioaddr, bool en, u32 chan)
 static void dwxgmac2_qmode(void __iomem *ioaddr, u32 channel, u8 qmode)
 {
        u32 value = readl(ioaddr + XGMAC_MTL_TXQ_OPMODE(channel));
+        u32 flow = readl(ioaddr + XGMAC_RX_FLOW_CTRL);
        value &= ~XGMAC_TXQEN;
        if (qmode != MTL_QUEUE_AVB) {
@@ -477,6 +478,7 @@ static void dwxgmac2_qmode(void __iomem *ioaddr, u32 channel, u8 qmode)
                writel(0, ioaddr + XGMAC_MTL_TCx_ETS_CONTROL(channel));
        } else {
                value |= 0x1 << XGMAC_TXQEN_SHIFT;
+                writel(flow & (~XGMAC_RFE), ioaddr + XGMAC_RX_FLOW_CTRL);
        }
        writel(value, ioaddr +  XGMAC_MTL_TXQ_OPMODE(channel));
diff --git a/drivers/net/ethernet/stmicro/stmmac/mmc_core.c b/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
index a223584f5f9a..252cf48c5816 100644
--- a/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
+++ b/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
@@ -176,6 +176,7 @@
 #define MMC_XGMAC_RX_PKT_SMD_ERR        0x22c
 #define MMC_XGMAC_RX_PKT_ASSEMBLY_OK    0x230
 #define MMC_XGMAC_RX_FPE_FRAG           0x234
+#define MMC_XGMAC_RX_IPC_INTR_MASK      0x25c
 static void dwmac_mmc_ctrl(void __iomem *mmcaddr, unsigned int mode)
 {
@@ -333,8 +334,9 @@ static void dwxgmac_mmc_ctrl(void __iomem *mmcaddr, unsigned int mode)
 static void dwxgmac_mmc_intr_all_mask(void __iomem *mmcaddr)
 {
-        writel(MMC_DEFAULT_MASK, mmcaddr + MMC_RX_INTR_MASK);
+        writel(0x0, mmcaddr + MMC_RX_INTR_MASK);
-        writel(MMC_DEFAULT_MASK, mmcaddr + MMC_TX_INTR_MASK);
+        writel(0x0, mmcaddr + MMC_TX_INTR_MASK);
+        writel(MMC_DEFAULT_MASK, mmcaddr + MMC_XGMAC_RX_IPC_INTR_MASK);
 }
 static void dwxgmac_read_mmc_reg(void __iomem *addr, u32 reg, u32 *dest)
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 4e9c848c67cc..f826365c979d 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -2996,6 +2996,7 @@ static netdev_tx_t stmmac_tso_xmit(struct sk_buff *skb, struct net_device *dev)
                stmmac_set_desc_addr(priv, first, des);
                tmp_pay_len = pay_len;
                des += proto_hdr_len;
+                pay_len = 0;
        }
        stmmac_tso_allocator(priv, des, tmp_pay_len, (nfrags == 0), queue);
@@ -3023,6 +3024,19 @@ static netdev_tx_t stmmac_tso_xmit(struct sk_buff *skb, struct net_device *dev)
        /* Only the last descriptor gets to point to the skb. */
        tx_q->tx_skbuff[tx_q->cur_tx] = skb;
+        /* Manage tx mitigation */
+        tx_q->tx_count_frames += nfrags + 1;
+        if (likely(priv->tx_coal_frames > tx_q->tx_count_frames) &&
+            !((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
+              priv->hwts_tx_en)) {
+                stmmac_tx_timer_arm(priv, queue);
+        } else {
+                desc = &tx_q->dma_tx[tx_q->cur_tx];
+                tx_q->tx_count_frames = 0;
+                stmmac_set_tx_ic(priv, desc);
+                priv->xstats.tx_set_ic_bit++;
+        }
        /* We've used all descriptors we need for this skb, however,
         * advance cur_tx so that it references a fresh descriptor.
         * ndo_start_xmit will fill this descriptor the next time it's
@@ -3040,19 +3054,6 @@ static netdev_tx_t stmmac_tso_xmit(struct sk_buff *skb, struct net_device *dev)
        priv->xstats.tx_tso_frames++;
        priv->xstats.tx_tso_nfrags += nfrags;
-        /* Manage tx mitigation */
-        tx_q->tx_count_frames += nfrags + 1;
-        if (likely(priv->tx_coal_frames > tx_q->tx_count_frames) &&
-            !(priv->synopsys_id >= DWMAC_CORE_4_00 &&
-            (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
-            priv->hwts_tx_en)) {
-                stmmac_tx_timer_arm(priv, queue);
-        } else {
-                tx_q->tx_count_frames = 0;
-                stmmac_set_tx_ic(priv, desc);
-                priv->xstats.tx_set_ic_bit++;
-        }
        if (priv->sarc_type)
                stmmac_set_desc_sarc(priv, first, priv->sarc_type);
@@ -3224,6 +3225,27 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
        /* Only the last descriptor gets to point to the skb. */
        tx_q->tx_skbuff[entry] = skb;
+        /* According to the coalesce parameter the IC bit for the latest
+         * segment is reset and the timer re-started to clean the tx status.
+         * This approach takes care about the fragments: desc is the first
+         * element in case of no SG.
+         */
+        tx_q->tx_count_frames += nfrags + 1;
+        if (likely(priv->tx_coal_frames > tx_q->tx_count_frames) &&
+            !((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
+              priv->hwts_tx_en)) {
+                stmmac_tx_timer_arm(priv, queue);
+        } else {
+                if (likely(priv->extend_desc))
+                        desc = &tx_q->dma_etx[entry].basic;
+                else
+                        desc = &tx_q->dma_tx[entry];
+                tx_q->tx_count_frames = 0;
+                stmmac_set_tx_ic(priv, desc);
+                priv->xstats.tx_set_ic_bit++;
+        }
        /* We've used all descriptors we need for this skb, however,
         * advance cur_tx so that it references a fresh descriptor.
         * ndo_start_xmit will fill this descriptor the next time it's
@@ -3259,23 +3281,6 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
        dev->stats.tx_bytes += skb->len;
-        /* According to the coalesce parameter the IC bit for the latest
-         * segment is reset and the timer re-started to clean the tx status.
-         * This approach takes care about the fragments: desc is the first
-         * element in case of no SG.
-         */
-        tx_q->tx_count_frames += nfrags + 1;
-        if (likely(priv->tx_coal_frames > tx_q->tx_count_frames) &&
-            !(priv->synopsys_id >= DWMAC_CORE_4_00 &&
-            (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
-            priv->hwts_tx_en)) {
-                stmmac_tx_timer_arm(priv, queue);
-        } else {
-                tx_q->tx_count_frames = 0;
-                stmmac_set_tx_ic(priv, desc);
-                priv->xstats.tx_set_ic_bit++;
-        }
        if (priv->sarc_type)
                stmmac_set_desc_sarc(priv, first, priv->sarc_type);
@@ -3506,8 +3511,6 @@ read_again:
                if (unlikely(status & dma_own))
                        break;
-                count++;
                rx_q->cur_rx = STMMAC_GET_ENTRY(rx_q->cur_rx, DMA_RX_SIZE);
                next_entry = rx_q->cur_rx;
@@ -3534,6 +3537,7 @@ read_again:
                        goto read_again;
                if (unlikely(error)) {
                        dev_kfree_skb(skb);
+                        count++;
                        continue;
                }
@@ -3573,6 +3577,7 @@ read_again:
                        skb = napi_alloc_skb(&ch->rx_napi, len);
                        if (!skb) {
                                priv->dev->stats.rx_dropped++;
+                                count++;
                                continue;
                        }
@@ -3638,6 +3643,7 @@ read_again:
                priv->dev->stats.rx_packets++;
                priv->dev->stats.rx_bytes += len;
+                count++;
        }
        if (status & rx_not_ls) {
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c
index e4ac3c401432..ac3f658105c0 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c
@@ -6,7 +6,9 @@
 * Author: Jose Abreu <joabreu@synopsys.com>
 */
+#include <linux/bitrev.h>
 #include <linux/completion.h>
+#include <linux/crc32.h>
 #include <linux/ethtool.h>
 #include <linux/ip.h>
 #include <linux/phy.h>
@@ -485,12 +487,48 @@ static int stmmac_filter_check(struct stmmac_priv *priv)
        return -EOPNOTSUPP;
 }
+static bool stmmac_hash_check(struct stmmac_priv *priv, unsigned char *addr)
+{
+        int mc_offset = 32 - priv->hw->mcast_bits_log2;
+        struct netdev_hw_addr *ha;
+        u32 hash, hash_nr;
+        /* First compute the hash for desired addr */
+        hash = bitrev32(~crc32_le(~0, addr, 6)) >> mc_offset;
+        hash_nr = hash >> 5;
+        hash = 1 << (hash & 0x1f);
+        /* Now, check if it collides with any existing one */
+        netdev_for_each_mc_addr(ha, priv->dev) {
+                u32 nr = bitrev32(~crc32_le(~0, ha->addr, ETH_ALEN)) >> mc_offset;
+                if (((nr >> 5) == hash_nr) && ((1 << (nr & 0x1f)) == hash))
+                        return false;
+        }
+        /* No collisions, address is good to go */
+        return true;
+}
+static bool stmmac_perfect_check(struct stmmac_priv *priv, unsigned char *addr)
+{
+        struct netdev_hw_addr *ha;
+        /* Check if it collides with any existing one */
+        netdev_for_each_uc_addr(ha, priv->dev) {
+                if (!memcmp(ha->addr, addr, ETH_ALEN))
+                        return false;
+        }
+        /* No collisions, address is good to go */
+        return true;
+}
 static int stmmac_test_hfilt(struct stmmac_priv *priv)
 {
-        unsigned char gd_addr[ETH_ALEN] = {0x01, 0xee, 0xdd, 0xcc, 0xbb, 0xaa};
+        unsigned char gd_addr[ETH_ALEN] = {0xf1, 0xee, 0xdd, 0xcc, 0xbb, 0xaa};
-        unsigned char bd_addr[ETH_ALEN] = {0x01, 0x01, 0x02, 0x03, 0x04, 0x05};
+        unsigned char bd_addr[ETH_ALEN] = {0xf1, 0xff, 0xff, 0xff, 0xff, 0xff};
        struct stmmac_packet_attrs attr = { };
-        int ret;
+        int ret, tries = 256;
        ret = stmmac_filter_check(priv);
        if (ret)
@@ -499,6 +537,16 @@ static int stmmac_test_hfilt(struct stmmac_priv *priv)
        if (netdev_mc_count(priv->dev) >= priv->hw->multicast_filter_bins)
                return -EOPNOTSUPP;
+        while (--tries) {
+                /* We only need to check the bd_addr for collisions */
+                bd_addr[ETH_ALEN - 1] = tries;
+                if (stmmac_hash_check(priv, bd_addr))
+                        break;
+        }
+        if (!tries)
+                return -EOPNOTSUPP;
        ret = dev_mc_add(priv->dev, gd_addr);
        if (ret)
                return ret;
@@ -523,13 +571,25 @@ cleanup:
 static int stmmac_test_pfilt(struct stmmac_priv *priv)
 {
-        unsigned char gd_addr[ETH_ALEN] = {0x00, 0x01, 0x44, 0x55, 0x66, 0x77};
+        unsigned char gd_addr[ETH_ALEN] = {0xf0, 0x01, 0x44, 0x55, 0x66, 0x77};
-        unsigned char bd_addr[ETH_ALEN] = {0x08, 0x00, 0x22, 0x33, 0x44, 0x55};
+        unsigned char bd_addr[ETH_ALEN] = {0xf0, 0xff, 0xff, 0xff, 0xff, 0xff};
        struct stmmac_packet_attrs attr = { };
-        int ret;
+        int ret, tries = 256;
        if (stmmac_filter_check(priv))
                return -EOPNOTSUPP;
+        if (netdev_uc_count(priv->dev) >= priv->hw->unicast_filter_entries)
+                return -EOPNOTSUPP;
+        while (--tries) {
+                /* We only need to check the bd_addr for collisions */
+                bd_addr[ETH_ALEN - 1] = tries;
+                if (stmmac_perfect_check(priv, bd_addr))
+                        break;
+        }
+        if (!tries)
+                return -EOPNOTSUPP;
        ret = dev_uc_add(priv->dev, gd_addr);
        if (ret)
@@ -553,39 +613,31 @@ cleanup:
        return ret;
 }
-static int stmmac_dummy_sync(struct net_device *netdev, const u8 *addr)
-{
-        return 0;
-}
-static void stmmac_test_set_rx_mode(struct net_device *netdev)
-{
-        /* As we are in test mode of ethtool we already own the rtnl lock
-         * so no address will change from user. We can just call the
-         * ndo_set_rx_mode() callback directly */
-        if (netdev->netdev_ops->ndo_set_rx_mode)
-                netdev->netdev_ops->ndo_set_rx_mode(netdev);
-}
 static int stmmac_test_mcfilt(struct stmmac_priv *priv)
 {
-        unsigned char uc_addr[ETH_ALEN] = {0x00, 0x01, 0x44, 0x55, 0x66, 0x77};
+        unsigned char uc_addr[ETH_ALEN] = {0xf0, 0xff, 0xff, 0xff, 0xff, 0xff};
-        unsigned char mc_addr[ETH_ALEN] = {0x01, 0x01, 0x44, 0x55, 0x66, 0x77};
+        unsigned char mc_addr[ETH_ALEN] = {0xf1, 0xff, 0xff, 0xff, 0xff, 0xff};
        struct stmmac_packet_attrs attr = { };
-        int ret;
+        int ret, tries = 256;
        if (stmmac_filter_check(priv))
                return -EOPNOTSUPP;
-        if (!priv->hw->multicast_filter_bins)
+        if (netdev_uc_count(priv->dev) >= priv->hw->unicast_filter_entries)
                return -EOPNOTSUPP;
-        /* Remove all MC addresses */
+        while (--tries) {
-        __dev_mc_unsync(priv->dev, NULL);
+                /* We only need to check the mc_addr for collisions */
-        stmmac_test_set_rx_mode(priv->dev);
+                mc_addr[ETH_ALEN - 1] = tries;
+                if (stmmac_hash_check(priv, mc_addr))
+                        break;
+        }
+        if (!tries)
+                return -EOPNOTSUPP;
        ret = dev_uc_add(priv->dev, uc_addr);
        if (ret)
-                goto cleanup;
+                return ret;
        attr.dst = uc_addr;
@@ -602,30 +654,34 @@ static int stmmac_test_mcfilt(struct stmmac_priv *priv)
 cleanup:
        dev_uc_del(priv->dev, uc_addr);
-        __dev_mc_sync(priv->dev, stmmac_dummy_sync, NULL);
-        stmmac_test_set_rx_mode(priv->dev);
        return ret;
 }
 static int stmmac_test_ucfilt(struct stmmac_priv *priv)
 {
-        unsigned char uc_addr[ETH_ALEN] = {0x00, 0x01, 0x44, 0x55, 0x66, 0x77};
+        unsigned char uc_addr[ETH_ALEN] = {0xf0, 0xff, 0xff, 0xff, 0xff, 0xff};
-        unsigned char mc_addr[ETH_ALEN] = {0x01, 0x01, 0x44, 0x55, 0x66, 0x77};
+        unsigned char mc_addr[ETH_ALEN] = {0xf1, 0xff, 0xff, 0xff, 0xff, 0xff};
        struct stmmac_packet_attrs attr = { };
-        int ret;
+        int ret, tries = 256;
        if (stmmac_filter_check(priv))
                return -EOPNOTSUPP;
-        if (!priv->hw->multicast_filter_bins)
+        if (netdev_mc_count(priv->dev) >= priv->hw->multicast_filter_bins)
                return -EOPNOTSUPP;
-        /* Remove all UC addresses */
+        while (--tries) {
-        __dev_uc_unsync(priv->dev, NULL);
+                /* We only need to check the uc_addr for collisions */
-        stmmac_test_set_rx_mode(priv->dev);
+                uc_addr[ETH_ALEN - 1] = tries;
+                if (stmmac_perfect_check(priv, uc_addr))
+                        break;
+        }
+        if (!tries)
+                return -EOPNOTSUPP;
        ret = dev_mc_add(priv->dev, mc_addr);
        if (ret)
-                goto cleanup;
+                return ret;
        attr.dst = mc_addr;
@@ -642,8 +698,6 @@ static int stmmac_test_ucfilt(struct stmmac_priv *priv)
 cleanup:
        dev_mc_del(priv->dev, mc_addr);
-        __dev_uc_sync(priv->dev, stmmac_dummy_sync, NULL);
-        stmmac_test_set_rx_mode(priv->dev);
        return ret;
 }
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index 00cab3f43a4c..a245597a3902 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -578,8 +578,8 @@ static void cdc_ncm_set_dgram_size(struct usbnet *dev, int new_size)
        /* read current mtu value from device */
        err = usbnet_read_cmd(dev, USB_CDC_GET_MAX_DATAGRAM_SIZE,
                              USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE,
-                              0, iface_no, &max_datagram_size, 2);
+                              0, iface_no, &max_datagram_size, sizeof(max_datagram_size));
-        if (err < 0) {
+        if (err < sizeof(max_datagram_size)) {
                dev_dbg(&dev->intf->dev, "GET_MAX_DATAGRAM_SIZE failed\n");
                goto out;
        }
@@ -590,7 +590,7 @@ static void cdc_ncm_set_dgram_size(struct usbnet *dev, int new_size)
        max_datagram_size = cpu_to_le16(ctx->max_datagram_size);
        err = usbnet_write_cmd(dev, USB_CDC_SET_MAX_DATAGRAM_SIZE,
                               USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE,
-                               0, iface_no, &max_datagram_size, 2);
+                               0, iface_no, &max_datagram_size, sizeof(max_datagram_size));
        if (err < 0)
                dev_dbg(&dev->intf->dev, "SET_MAX_DATAGRAM_SIZE failed\n");
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 596428ec71df..56d334b9ad45 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -1362,6 +1362,7 @@ static const struct usb_device_id products[] = {
        {QMI_FIXED_INTF(0x413c, 0x81b6, 8)},    /* Dell Wireless 5811e */
        {QMI_FIXED_INTF(0x413c, 0x81b6, 10)},   /* Dell Wireless 5811e */
        {QMI_FIXED_INTF(0x413c, 0x81d7, 0)},    /* Dell Wireless 5821e */
+        {QMI_FIXED_INTF(0x413c, 0x81e0, 0)},    /* Dell Wireless 5821e with eSIM support*/
        {QMI_FIXED_INTF(0x03f0, 0x4e1d, 8)},    /* HP lt4111 LTE/EV-DO/HSPA+ Gobi 4G Module */
        {QMI_FIXED_INTF(0x03f0, 0x9d1d, 1)},    /* HP lt4120 Snapdragon X5 LTE */
        {QMI_FIXED_INTF(0x22de, 0x9061, 3)},    /* WeTelecom WPD-600N */
diff --git a/drivers/nfc/fdp/i2c.c b/drivers/nfc/fdp/i2c.c
index 1cd113c8d7cb..ad0abb1f0bae 100644
--- a/drivers/nfc/fdp/i2c.c
+++ b/drivers/nfc/fdp/i2c.c
@@ -259,7 +259,7 @@ static void fdp_nci_i2c_read_device_properties(struct device *dev,
                                                  *fw_vsc_cfg, len);
                if (r) {
-                        devm_kfree(dev, fw_vsc_cfg);
+                        devm_kfree(dev, *fw_vsc_cfg);
                        goto vsc_read_err;
                }
        } else {
diff --git a/drivers/nfc/st21nfca/core.c b/drivers/nfc/st21nfca/core.c
index f9ac176cf257..2ce17932a073 100644
--- a/drivers/nfc/st21nfca/core.c
+++ b/drivers/nfc/st21nfca/core.c
@@ -708,6 +708,7 @@ static int st21nfca_hci_complete_target_discovered(struct nfc_hci_dev *hdev,
                                                        NFC_PROTO_FELICA_MASK;
                } else {
                        kfree_skb(nfcid_skb);
+                        nfcid_skb = NULL;
                        /* P2P in type A */
                        r = nfc_hci_get_param(hdev, ST21NFCA_RF_READER_F_GATE,
                                        ST21NFCA_RF_READER_F_NFCID1,
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 5b9d22338606..3bf3835d0e86 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -656,11 +656,11 @@ void bpf_map_put_with_uref(struct bpf_map *map);
 void bpf_map_put(struct bpf_map *map);
 int bpf_map_charge_memlock(struct bpf_map *map, u32 pages);
 void bpf_map_uncharge_memlock(struct bpf_map *map, u32 pages);
-int bpf_map_charge_init(struct bpf_map_memory *mem, size_t size);
+int bpf_map_charge_init(struct bpf_map_memory *mem, u64 size);
 void bpf_map_charge_finish(struct bpf_map_memory *mem);
 void bpf_map_charge_move(struct bpf_map_memory *dst,
                         struct bpf_map_memory *src);
-void *bpf_map_area_alloc(size_t size, int numa_node);
+void *bpf_map_area_alloc(u64 size, int numa_node);
 void bpf_map_area_free(void *base);
 void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr);
diff --git a/include/linux/skmsg.h b/include/linux/skmsg.h
index e4b3fb4bb77c..ce7055259877 100644
--- a/include/linux/skmsg.h
+++ b/include/linux/skmsg.h
@@ -139,6 +139,11 @@ static inline void sk_msg_apply_bytes(struct sk_psock *psock, u32 bytes)
        }
 }
+static inline u32 sk_msg_iter_dist(u32 start, u32 end)
+{
+        return end >= start ? end - start : end + (MAX_MSG_FRAGS - start);
+}
 #define sk_msg_iter_var_prev(var)                       \
        do {                                            \
                if (var == 0)                           \
@@ -198,9 +203,7 @@ static inline u32 sk_msg_elem_used(const struct sk_msg *msg)
        if (sk_msg_full(msg))
                return MAX_MSG_FRAGS;
-        return msg->sg.end >= msg->sg.start ?
+        return sk_msg_iter_dist(msg->sg.start, msg->sg.end);
-                msg->sg.end - msg->sg.start :
-                msg->sg.end + (MAX_MSG_FRAGS - msg->sg.start);
 }
 static inline struct scatterlist *sk_msg_elem(struct sk_msg *msg, int which)
diff --git a/include/net/bonding.h b/include/net/bonding.h
index 1afc125014da..3d56b026bb9e 100644
--- a/include/net/bonding.h
+++ b/include/net/bonding.h
@@ -159,7 +159,6 @@ struct slave {
        unsigned long target_last_arp_rx[BOND_MAX_ARP_TARGETS];
        s8     link;            /* one of BOND_LINK_XXXX */
        s8     link_new_state;  /* one of BOND_LINK_XXXX */
-        s8     new_link;
        u8     backup:1,   /* indicates backup slave. Value corresponds with
                              BOND_STATE_ACTIVE and BOND_STATE_BACKUP */
               inactive:1, /* indicates inactive slave */
@@ -549,7 +548,7 @@ static inline void bond_propose_link_state(struct slave *slave, int state)
 static inline void bond_commit_link_state(struct slave *slave, bool notify)
 {
-        if (slave->link == slave->link_new_state)
+        if (slave->link_new_state == BOND_LINK_NOCHANGE)
                return;
        slave->link = slave->link_new_state;
diff --git a/include/net/fq_impl.h b/include/net/fq_impl.h
index 107c0d700ed6..38a9a3d1222b 100644
--- a/include/net/fq_impl.h
+++ b/include/net/fq_impl.h
@@ -313,7 +313,7 @@ static int fq_init(struct fq *fq, int flows_cnt)
        fq->limit = 8192;
        fq->memory_limit = 16 << 20; /* 16 MBytes */
-        fq->flows = kcalloc(fq->flows_cnt, sizeof(fq->flows[0]), GFP_KERNEL);
+        fq->flows = kvcalloc(fq->flows_cnt, sizeof(fq->flows[0]), GFP_KERNEL);
        if (!fq->flows)
                return -ENOMEM;
@@ -331,7 +331,7 @@ static void fq_reset(struct fq *fq,
        for (i = 0; i < fq->flows_cnt; i++)
                fq_flow_reset(fq, &fq->flows[i], free_func);
-        kfree(fq->flows);
+        kvfree(fq->flows);
        fq->flows = NULL;
 }
diff --git a/include/net/neighbour.h b/include/net/neighbour.h
index 50a67bd6a434..b8452cc0e059 100644
--- a/include/net/neighbour.h
+++ b/include/net/neighbour.h
@@ -439,8 +439,8 @@ static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
 {
        unsigned long now = jiffies;
        
-        if (neigh->used != now)
+        if (READ_ONCE(neigh->used) != now)
-                neigh->used = now;
+                WRITE_ONCE(neigh->used, now);
        if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE)))
                return __neigh_event_send(neigh, skb);
        return 0;
diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index 001d294edf57..2d0275f13bbf 100644
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -820,7 +820,8 @@ struct nft_expr_ops {
 */
 struct nft_expr {
        const struct nft_expr_ops       *ops;
-        unsigned char                   data[];
+        unsigned char                   data[]
+                __attribute__((aligned(__alignof__(u64))));
 };
 static inline void *nft_expr_priv(const struct nft_expr *expr)
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 637548d54b3e..d80acda231ae 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -15,6 +15,7 @@
 #include <linux/mutex.h>
 #include <linux/rwsem.h>
 #include <linux/atomic.h>
+#include <linux/hashtable.h>
 #include <net/gen_stats.h>
 #include <net/rtnetlink.h>
 #include <net/flow_offload.h>
@@ -362,6 +363,7 @@ struct tcf_proto {
        bool                    deleting;
        refcount_t              refcnt;
        struct rcu_head         rcu;
+        struct hlist_node       destroy_ht_node;
 };
 struct qdisc_skb_cb {
@@ -414,6 +416,8 @@ struct tcf_block {
                struct list_head filter_chain_list;
        } chain0;
        struct rcu_head rcu;
+        DECLARE_HASHTABLE(proto_destroy_ht, 7);
+        struct mutex proto_destroy_lock; /* Lock for proto_destroy hashtable. */
 };
 #ifdef CONFIG_PROVE_LOCKING
diff --git a/include/net/sock.h b/include/net/sock.h
index 8f9adcfac41b..718e62fbe869 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -2342,7 +2342,7 @@ static inline ktime_t sock_read_timestamp(struct sock *sk)
        return kt;
 #else
-        return sk->sk_stamp;
+        return READ_ONCE(sk->sk_stamp);
 #endif
 }
@@ -2353,7 +2353,7 @@ static inline void sock_write_timestamp(struct sock *sk, ktime_t kt)
        sk->sk_stamp = kt;
        write_sequnlock(&sk->sk_stamp_seq);
 #else
-        sk->sk_stamp = kt;
+        WRITE_ONCE(sk->sk_stamp, kt);
 #endif
 }
diff --git a/include/net/tls.h b/include/net/tls.h
index c664e6dba0d1..794e297483ea 100644
--- a/include/net/tls.h
+++ b/include/net/tls.h
@@ -40,6 +40,7 @@
 #include <linux/socket.h>
 #include <linux/tcp.h>
 #include <linux/skmsg.h>
+#include <linux/mutex.h>
 #include <linux/netdevice.h>
 #include <linux/rcupdate.h>
@@ -269,6 +270,10 @@ struct tls_context {
        bool in_tcp_sendpages;
        bool pending_open_record_frags;
+        struct mutex tx_lock; /* protects partially_sent_* fields and
+                               * per-type TX fields
+                               */
        unsigned long flags;
        /* cache cold stuff */
diff --git a/include/uapi/linux/can.h b/include/uapi/linux/can.h
index 1e988fdeba34..6a6d2c7655ff 100644
--- a/include/uapi/linux/can.h
+++ b/include/uapi/linux/can.h
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* SPDX-License-Identifier: ((GPL-2.0-only WITH Linux-syscall-note) OR BSD-3-Clause) */
 /*
 * linux/can.h
 *
diff --git a/include/uapi/linux/can/bcm.h b/include/uapi/linux/can/bcm.h
index 0fb328d93148..dd2b925b09ac 100644
--- a/include/uapi/linux/can/bcm.h
+++ b/include/uapi/linux/can/bcm.h
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* SPDX-License-Identifier: ((GPL-2.0-only WITH Linux-syscall-note) OR BSD-3-Clause) */
 /*
 * linux/can/bcm.h
 *
diff --git a/include/uapi/linux/can/error.h b/include/uapi/linux/can/error.h
index bfc4b5d22a5e..34633283de64 100644
--- a/include/uapi/linux/can/error.h
+++ b/include/uapi/linux/can/error.h
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* SPDX-License-Identifier: ((GPL-2.0-only WITH Linux-syscall-note) OR BSD-3-Clause) */
 /*
 * linux/can/error.h
 *
diff --git a/include/uapi/linux/can/gw.h b/include/uapi/linux/can/gw.h
index 3aea5388c8e4..c2190bbe21d8 100644
--- a/include/uapi/linux/can/gw.h
+++ b/include/uapi/linux/can/gw.h
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* SPDX-License-Identifier: ((GPL-2.0-only WITH Linux-syscall-note) OR BSD-3-Clause) */
 /*
 * linux/can/gw.h
 *
diff --git a/include/uapi/linux/can/j1939.h b/include/uapi/linux/can/j1939.h
index c32325342d30..df6e821075c1 100644
--- a/include/uapi/linux/can/j1939.h
+++ b/include/uapi/linux/can/j1939.h
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */
 /*
 * j1939.h
 *
diff --git a/include/uapi/linux/can/netlink.h b/include/uapi/linux/can/netlink.h
index 1bc70d3a4d39..6f598b73839e 100644
--- a/include/uapi/linux/can/netlink.h
+++ b/include/uapi/linux/can/netlink.h
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */
 /*
 * linux/can/netlink.h
 *
diff --git a/include/uapi/linux/can/raw.h b/include/uapi/linux/can/raw.h
index be3b36e7ff61..6a11d308eb5c 100644
--- a/include/uapi/linux/can/raw.h
+++ b/include/uapi/linux/can/raw.h
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* SPDX-License-Identifier: ((GPL-2.0-only WITH Linux-syscall-note) OR BSD-3-Clause) */
 /*
 * linux/can/raw.h
 *
diff --git a/include/uapi/linux/can/vxcan.h b/include/uapi/linux/can/vxcan.h
index 066812d118a2..4fa9d8777a07 100644
--- a/include/uapi/linux/can/vxcan.h
+++ b/include/uapi/linux/can/vxcan.h
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */
 #ifndef _UAPI_CAN_VXCAN_H
 #define _UAPI_CAN_VXCAN_H
diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c
index ddd8addcdb5c..a3eaf08e7dd3 100644
--- a/kernel/bpf/cgroup.c
+++ b/kernel/bpf/cgroup.c
@@ -1311,12 +1311,12 @@ static bool sysctl_is_valid_access(int off, int size, enum bpf_access_type type,
                return false;
        switch (off) {
-        case offsetof(struct bpf_sysctl, write):
+        case bpf_ctx_range(struct bpf_sysctl, write):
                if (type != BPF_READ)
                        return false;
                bpf_ctx_record_field_size(info, size_default);
                return bpf_ctx_narrow_access_ok(off, size, size_default);
-        case offsetof(struct bpf_sysctl, file_pos):
+        case bpf_ctx_range(struct bpf_sysctl, file_pos):
                if (type == BPF_READ) {
                        bpf_ctx_record_field_size(info, size_default);
                        return bpf_ctx_narrow_access_ok(off, size, size_default);
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 0937719b87e2..ace1cfaa24b6 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -126,7 +126,7 @@ static struct bpf_map *find_and_alloc_map(union bpf_attr *attr)
        return map;
 }
-void *bpf_map_area_alloc(size_t size, int numa_node)
+void *bpf_map_area_alloc(u64 size, int numa_node)
 {
        /* We really just want to fail instead of triggering OOM killer
         * under memory pressure, therefore we set __GFP_NORETRY to kmalloc,
@@ -141,6 +141,9 @@ void *bpf_map_area_alloc(size_t size, int numa_node)
        const gfp_t flags = __GFP_NOWARN | __GFP_ZERO;
        void *area;
+        if (size >= SIZE_MAX)
+                return NULL;
        if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) {
                area = kmalloc_node(size, GFP_USER | __GFP_NORETRY | flags,
                                    numa_node);
@@ -197,7 +200,7 @@ static void bpf_uncharge_memlock(struct user_struct *user, u32 pages)
                atomic_long_sub(pages, &user->locked_vm);
 }
-int bpf_map_charge_init(struct bpf_map_memory *mem, size_t size)
+int bpf_map_charge_init(struct bpf_map_memory *mem, u64 size)
 {
        u32 pages = round_up(size, PAGE_SIZE) >> PAGE_SHIFT;
        struct user_struct *user;
diff --git a/net/bridge/netfilter/ebt_dnat.c b/net/bridge/netfilter/ebt_dnat.c
index ed91ea31978a..12a4f4d93681 100644
--- a/net/bridge/netfilter/ebt_dnat.c
+++ b/net/bridge/netfilter/ebt_dnat.c
@@ -20,7 +20,6 @@ static unsigned int
 ebt_dnat_tg(struct sk_buff *skb, const struct xt_action_param *par)
 {
        const struct ebt_nat_info *info = par->targinfo;
-        struct net_device *dev;
        if (skb_ensure_writable(skb, ETH_ALEN))
                return EBT_DROP;
@@ -33,10 +32,22 @@ ebt_dnat_tg(struct sk_buff *skb, const struct xt_action_param *par)
                else
                        skb->pkt_type = PACKET_MULTICAST;
        } else {
-                if (xt_hooknum(par) != NF_BR_BROUTING)
+                const struct net_device *dev;
-                        dev = br_port_get_rcu(xt_in(par))->br->dev;
-                else
+                switch (xt_hooknum(par)) {
+                case NF_BR_BROUTING:
                        dev = xt_in(par);
+                        break;
+                case NF_BR_PRE_ROUTING:
+                        dev = br_port_get_rcu(xt_in(par))->br->dev;
+                        break;
+                default:
+                        dev = NULL;
+                        break;
+                }
+                if (!dev) /* NF_BR_LOCAL_OUT */
+                        return info->target;
                if (ether_addr_equal(info->mac, dev->dev_addr))
                        skb->pkt_type = PACKET_HOST;
diff --git a/net/can/j1939/socket.c b/net/can/j1939/socket.c
index 37c1040bcb9c..4d8ba701e15d 100644
--- a/net/can/j1939/socket.c
+++ b/net/can/j1939/socket.c
@@ -580,6 +580,7 @@ static int j1939_sk_release(struct socket *sock)
                j1939_netdev_stop(priv);
        }
+        kfree(jsk->filters);
        sock_orphan(sk);
        sock->sk = NULL;
@@ -909,8 +910,10 @@ void j1939_sk_errqueue(struct j1939_session *session,
        memset(serr, 0, sizeof(*serr));
        switch (type) {
        case J1939_ERRQUEUE_ACK:
-                if (!(sk->sk_tsflags & SOF_TIMESTAMPING_TX_ACK))
+                if (!(sk->sk_tsflags & SOF_TIMESTAMPING_TX_ACK)) {
+                        kfree_skb(skb);
                        return;
+                }
                serr->ee.ee_errno = ENOMSG;
                serr->ee.ee_origin = SO_EE_ORIGIN_TIMESTAMPING;
@@ -918,8 +921,10 @@ void j1939_sk_errqueue(struct j1939_session *session,
                state = "ACK";
                break;
        case J1939_ERRQUEUE_SCHED:
-                if (!(sk->sk_tsflags & SOF_TIMESTAMPING_TX_SCHED))
+                if (!(sk->sk_tsflags & SOF_TIMESTAMPING_TX_SCHED)) {
+                        kfree_skb(skb);
                        return;
+                }
                serr->ee.ee_errno = ENOMSG;
                serr->ee.ee_origin = SO_EE_ORIGIN_TIMESTAMPING;
diff --git a/net/can/j1939/transport.c b/net/can/j1939/transport.c
index fe000ea757ea..e5f1a56994c6 100644
--- a/net/can/j1939/transport.c
+++ b/net/can/j1939/transport.c
@@ -1273,9 +1273,27 @@ j1939_xtp_rx_abort(struct j1939_priv *priv, struct sk_buff *skb,
 static void
 j1939_xtp_rx_eoma_one(struct j1939_session *session, struct sk_buff *skb)
 {
+        struct j1939_sk_buff_cb *skcb = j1939_skb_to_cb(skb);
+        const u8 *dat;
+        int len;
        if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
                return;
+        dat = skb->data;
+        if (skcb->addr.type == J1939_ETP)
+                len = j1939_etp_ctl_to_size(dat);
+        else
+                len = j1939_tp_ctl_to_size(dat);
+        if (session->total_message_size != len) {
+                netdev_warn_once(session->priv->ndev,
+                                 "%s: 0x%p: Incorrect size. Expected: %i; got: %i.\n",
+                                 __func__, session, session->total_message_size,
+                                 len);
+        }
        netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
        session->pkt.tx_acked = session->pkt.total;
@@ -1432,7 +1450,7 @@ j1939_session *j1939_session_fresh_new(struct j1939_priv *priv,
        skcb = j1939_skb_to_cb(skb);
        memcpy(skcb, rel_skcb, sizeof(*skcb));
-        session = j1939_session_new(priv, skb, skb->len);
+        session = j1939_session_new(priv, skb, size);
        if (!session) {
                kfree_skb(skb);
                return NULL;
diff --git a/net/core/skmsg.c b/net/core/skmsg.c
index cf390e0aa73d..ad31e4e53d0a 100644
--- a/net/core/skmsg.c
+++ b/net/core/skmsg.c
@@ -270,18 +270,28 @@ void sk_msg_trim(struct sock *sk, struct sk_msg *msg, int len)
        msg->sg.data[i].length -= trim;
        sk_mem_uncharge(sk, trim);
+        /* Adjust copybreak if it falls into the trimmed part of last buf */
+        if (msg->sg.curr == i && msg->sg.copybreak > msg->sg.data[i].length)
+                msg->sg.copybreak = msg->sg.data[i].length;
 out:
-        /* If we trim data before curr pointer update copybreak and current
+        sk_msg_iter_var_next(i);
-         * so that any future copy operations start at new copy location.
+        msg->sg.end = i;
+        /* If we trim data a full sg elem before curr pointer update
+         * copybreak and current so that any future copy operations
+         * start at new copy location.
         * However trimed data that has not yet been used in a copy op
         * does not require an update.
         */
-        if (msg->sg.curr >= i) {
+        if (!msg->sg.size) {
+                msg->sg.curr = msg->sg.start;
+                msg->sg.copybreak = 0;
+        } else if (sk_msg_iter_dist(msg->sg.start, msg->sg.curr) >=
+                   sk_msg_iter_dist(msg->sg.start, msg->sg.end)) {
+                sk_msg_iter_var_prev(i);
                msg->sg.curr = i;
                msg->sg.copybreak = msg->sg.data[i].length;
        }
-        sk_msg_iter_var_next(i);
-        msg->sg.end = i;
 }
 EXPORT_SYMBOL_GPL(sk_msg_trim);
diff --git a/net/dccp/ipv4.c b/net/dccp/ipv4.c
index 0d8f782c25cc..d19557c6d04b 100644
--- a/net/dccp/ipv4.c
+++ b/net/dccp/ipv4.c
@@ -416,7 +416,7 @@ struct sock *dccp_v4_request_recv_sock(const struct sock *sk,
        RCU_INIT_POINTER(newinet->inet_opt, rcu_dereference(ireq->ireq_opt));
        newinet->mc_index  = inet_iif(skb);
        newinet->mc_ttl    = ip_hdr(skb)->ttl;
-        newinet->inet_id   = jiffies;
+        newinet->inet_id   = prandom_u32();
        if (dst == NULL && (dst = inet_csk_route_child_sock(sk, newsk, req)) == NULL)
                goto put_and_exit;
diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c
index 0913a090b2bf..f1888c683426 100644
--- a/net/ipv4/fib_semantics.c
+++ b/net/ipv4/fib_semantics.c
@@ -1814,8 +1814,8 @@ int fib_sync_down_addr(struct net_device *dev, __be32 local)
        int ret = 0;
        unsigned int hash = fib_laddr_hashfn(local);
        struct hlist_head *head = &fib_info_laddrhash[hash];
+        int tb_id = l3mdev_fib_table(dev) ? : RT_TABLE_MAIN;
        struct net *net = dev_net(dev);
-        int tb_id = l3mdev_fib_table(dev);
        struct fib_info *fi;
        if (!fib_info_laddrhash || local == 0)
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index a63ff85fe141..e60bf8e7dd1a 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -621,6 +621,7 @@ static void rt6_probe(struct fib6_nh *fib6_nh)
 {
        struct __rt6_probe_work *work = NULL;
        const struct in6_addr *nh_gw;
+        unsigned long last_probe;
        struct neighbour *neigh;
        struct net_device *dev;
        struct inet6_dev *idev;
@@ -639,6 +640,7 @@ static void rt6_probe(struct fib6_nh *fib6_nh)
        nh_gw = &fib6_nh->fib_nh_gw6;
        dev = fib6_nh->fib_nh_dev;
        rcu_read_lock_bh();
+        last_probe = READ_ONCE(fib6_nh->last_probe);
        idev = __in6_dev_get(dev);
        neigh = __ipv6_neigh_lookup_noref(dev, nh_gw);
        if (neigh) {
@@ -654,13 +656,15 @@ static void rt6_probe(struct fib6_nh *fib6_nh)
                                __neigh_set_probe_once(neigh);
                }
                write_unlock(&neigh->lock);
-        } else if (time_after(jiffies, fib6_nh->last_probe +
+        } else if (time_after(jiffies, last_probe +
                                       idev->cnf.rtr_probe_interval)) {
                work = kmalloc(sizeof(*work), GFP_ATOMIC);
        }
-        if (work) {
+        if (!work || cmpxchg(&fib6_nh->last_probe,
-                fib6_nh->last_probe = jiffies;
+                             last_probe, jiffies) != last_probe) {
+                kfree(work);
+        } else {
                INIT_WORK(&work->work, rt6_probe_deferred);
                work->target = *nh_gw;
                dev_hold(dev);
@@ -3383,6 +3387,9 @@ int fib6_nh_init(struct net *net, struct fib6_nh *fib6_nh,
        int err;
        fib6_nh->fib_nh_family = AF_INET6;
+#ifdef CONFIG_IPV6_ROUTER_PREF
+        fib6_nh->last_probe = jiffies;
+#endif
        err = -ENODEV;
        if (cfg->fc_ifindex) {
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index aba094b4ccfc..2d05c4cfaf6d 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -1292,8 +1292,8 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
        ieee80211_remove_interfaces(local);
 fail_rate:
        rtnl_unlock();
-        ieee80211_led_exit(local);
 fail_flows:
+        ieee80211_led_exit(local);
        destroy_workqueue(local->workqueue);
 fail_workqueue:
        wiphy_unregister(local->hw.wiphy);
diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c
index bd11fef2139f..8d3a2389b055 100644
--- a/net/mac80211/sta_info.c
+++ b/net/mac80211/sta_info.c
@@ -2457,7 +2457,8 @@ unsigned long ieee80211_sta_last_active(struct sta_info *sta)
 {
        struct ieee80211_sta_rx_stats *stats = sta_get_last_rx_stats(sta);
-        if (time_after(stats->last_rx, sta->status_stats.last_ack))
+        if (!sta->status_stats.last_ack ||
+            time_after(stats->last_rx, sta->status_stats.last_ack))
                return stats->last_rx;
        return sta->status_stats.last_ack;
 }
diff --git a/net/netfilter/ipset/ip_set_core.c b/net/netfilter/ipset/ip_set_core.c
index e64d5f9a89dd..d73d1828216a 100644
--- a/net/netfilter/ipset/ip_set_core.c
+++ b/net/netfilter/ipset/ip_set_core.c
@@ -296,7 +296,8 @@ ip_set_get_ipaddr4(struct nlattr *nla,  __be32 *ipaddr)
        if (unlikely(!flag_nested(nla)))
                return -IPSET_ERR_PROTOCOL;
-        if (nla_parse_nested_deprecated(tb, IPSET_ATTR_IPADDR_MAX, nla, ipaddr_policy, NULL))
+        if (nla_parse_nested(tb, IPSET_ATTR_IPADDR_MAX, nla,
+                             ipaddr_policy, NULL))
                return -IPSET_ERR_PROTOCOL;
        if (unlikely(!ip_set_attr_netorder(tb, IPSET_ATTR_IPADDR_IPV4)))
                return -IPSET_ERR_PROTOCOL;
@@ -314,7 +315,8 @@ ip_set_get_ipaddr6(struct nlattr *nla, union nf_inet_addr *ipaddr)
        if (unlikely(!flag_nested(nla)))
                return -IPSET_ERR_PROTOCOL;
-        if (nla_parse_nested_deprecated(tb, IPSET_ATTR_IPADDR_MAX, nla, ipaddr_policy, NULL))
+        if (nla_parse_nested(tb, IPSET_ATTR_IPADDR_MAX, nla,
+                             ipaddr_policy, NULL))
                return -IPSET_ERR_PROTOCOL;
        if (unlikely(!ip_set_attr_netorder(tb, IPSET_ATTR_IPADDR_IPV6)))
                return -IPSET_ERR_PROTOCOL;
@@ -934,7 +936,8 @@ static int ip_set_create(struct net *net, struct sock *ctnl,
        /* Without holding any locks, create private part. */
        if (attr[IPSET_ATTR_DATA] &&
-            nla_parse_nested_deprecated(tb, IPSET_ATTR_CREATE_MAX, attr[IPSET_ATTR_DATA], set->type->create_policy, NULL)) {
+            nla_parse_nested(tb, IPSET_ATTR_CREATE_MAX, attr[IPSET_ATTR_DATA],
+                             set->type->create_policy, NULL)) {
                ret = -IPSET_ERR_PROTOCOL;
                goto put_out;
        }
@@ -1281,6 +1284,14 @@ dump_attrs(struct nlmsghdr *nlh)
        }
 }
+static const struct nla_policy
+ip_set_dump_policy[IPSET_ATTR_CMD_MAX + 1] = {
+        [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
+        [IPSET_ATTR_SETNAME]    = { .type = NLA_NUL_STRING,
+                                    .len = IPSET_MAXNAMELEN - 1 },
+        [IPSET_ATTR_FLAGS]      = { .type = NLA_U32 },
+};
 static int
 dump_init(struct netlink_callback *cb, struct ip_set_net *inst)
 {
@@ -1292,9 +1303,9 @@ dump_init(struct netlink_callback *cb, struct ip_set_net *inst)
        ip_set_id_t index;
        int ret;
-        ret = nla_parse_deprecated(cda, IPSET_ATTR_CMD_MAX, attr,
+        ret = nla_parse(cda, IPSET_ATTR_CMD_MAX, attr,
-                                   nlh->nlmsg_len - min_len,
+                        nlh->nlmsg_len - min_len,
-                                   ip_set_setname_policy, NULL);
+                        ip_set_dump_policy, NULL);
        if (ret)
                return ret;
@@ -1543,9 +1554,9 @@ call_ad(struct sock *ctnl, struct sk_buff *skb, struct ip_set *set,
                memcpy(&errmsg->msg, nlh, nlh->nlmsg_len);
                cmdattr = (void *)&errmsg->msg + min_len;
-                ret = nla_parse_deprecated(cda, IPSET_ATTR_CMD_MAX, cmdattr,
+                ret = nla_parse(cda, IPSET_ATTR_CMD_MAX, cmdattr,
-                                           nlh->nlmsg_len - min_len,
+                                nlh->nlmsg_len - min_len, ip_set_adt_policy,
-                                           ip_set_adt_policy, NULL);
+                                NULL);
                if (ret) {
                        nlmsg_free(skb2);
@@ -1596,7 +1607,9 @@ static int ip_set_ad(struct net *net, struct sock *ctnl,
        use_lineno = !!attr[IPSET_ATTR_LINENO];
        if (attr[IPSET_ATTR_DATA]) {
-                if (nla_parse_nested_deprecated(tb, IPSET_ATTR_ADT_MAX, attr[IPSET_ATTR_DATA], set->type->adt_policy, NULL))
+                if (nla_parse_nested(tb, IPSET_ATTR_ADT_MAX,
+                                     attr[IPSET_ATTR_DATA],
+                                     set->type->adt_policy, NULL))
                        return -IPSET_ERR_PROTOCOL;
                ret = call_ad(ctnl, skb, set, tb, adt, flags,
                              use_lineno);
@@ -1606,7 +1619,8 @@ static int ip_set_ad(struct net *net, struct sock *ctnl,
                nla_for_each_nested(nla, attr[IPSET_ATTR_ADT], nla_rem) {
                        if (nla_type(nla) != IPSET_ATTR_DATA ||
                            !flag_nested(nla) ||
-                            nla_parse_nested_deprecated(tb, IPSET_ATTR_ADT_MAX, nla, set->type->adt_policy, NULL))
+                            nla_parse_nested(tb, IPSET_ATTR_ADT_MAX, nla,
+                                             set->type->adt_policy, NULL))
                                return -IPSET_ERR_PROTOCOL;
                        ret = call_ad(ctnl, skb, set, tb, adt,
                                      flags, use_lineno);
@@ -1655,7 +1669,8 @@ static int ip_set_utest(struct net *net, struct sock *ctnl, struct sk_buff *skb,
        if (!set)
                return -ENOENT;
-        if (nla_parse_nested_deprecated(tb, IPSET_ATTR_ADT_MAX, attr[IPSET_ATTR_DATA], set->type->adt_policy, NULL))
+        if (nla_parse_nested(tb, IPSET_ATTR_ADT_MAX, attr[IPSET_ATTR_DATA],
+                             set->type->adt_policy, NULL))
                return -IPSET_ERR_PROTOCOL;
        rcu_read_lock_bh();
@@ -1961,7 +1976,7 @@ static const struct nfnl_callback ip_set_netlink_subsys_cb[IPSET_MSG_MAX] = {
        [IPSET_CMD_LIST]        = {
                .call           = ip_set_dump,
                .attr_count     = IPSET_ATTR_CMD_MAX,
-                .policy         = ip_set_setname_policy,
+                .policy         = ip_set_dump_policy,
        },
        [IPSET_CMD_SAVE]        = {
                .call           = ip_set_dump,
@@ -2069,8 +2084,9 @@ ip_set_sockfn_get(struct sock *sk, int optval, void __user *user, int *len)
                }
                req_version->version = IPSET_PROTOCOL;
-                ret = copy_to_user(user, req_version,
+                if (copy_to_user(user, req_version,
-                                   sizeof(struct ip_set_req_version));
+                                 sizeof(struct ip_set_req_version)))
+                        ret = -EFAULT;
                goto done;
        }
        case IP_SET_OP_GET_BYNAME: {
@@ -2129,7 +2145,8 @@ ip_set_sockfn_get(struct sock *sk, int optval, void __user *user, int *len)
        }       /* end of switch(op) */
 copy:
-        ret = copy_to_user(user, data, copylen);
+        if (copy_to_user(user, data, copylen))
+                ret = -EFAULT;
 done:
        vfree(data);
diff --git a/net/netfilter/ipset/ip_set_hash_ipmac.c b/net/netfilter/ipset/ip_set_hash_ipmac.c
index 24d8f4df4230..4ce563eb927d 100644
--- a/net/netfilter/ipset/ip_set_hash_ipmac.c
+++ b/net/netfilter/ipset/ip_set_hash_ipmac.c
@@ -209,7 +209,7 @@ hash_ipmac6_kadt(struct ip_set *set, const struct sk_buff *skb,
            (skb_mac_header(skb) + ETH_HLEN) > skb->data)
                return -EINVAL;
-        if (opt->flags & IPSET_DIM_ONE_SRC)
+        if (opt->flags & IPSET_DIM_TWO_SRC)
                ether_addr_copy(e.ether, eth_hdr(skb)->h_source);
        else
                ether_addr_copy(e.ether, eth_hdr(skb)->h_dest);
diff --git a/net/netfilter/ipset/ip_set_hash_net.c b/net/netfilter/ipset/ip_set_hash_net.c
index c259cbc3ef45..3d932de0ad29 100644
--- a/net/netfilter/ipset/ip_set_hash_net.c
+++ b/net/netfilter/ipset/ip_set_hash_net.c
@@ -368,6 +368,7 @@ static struct ip_set_type hash_net_type __read_mostly = {
                [IPSET_ATTR_IP_TO]      = { .type = NLA_NESTED },
                [IPSET_ATTR_CIDR]       = { .type = NLA_U8 },
                [IPSET_ATTR_TIMEOUT]    = { .type = NLA_U32 },
+                [IPSET_ATTR_LINENO]     = { .type = NLA_U32 },
                [IPSET_ATTR_CADT_FLAGS] = { .type = NLA_U32 },
                [IPSET_ATTR_BYTES]      = { .type = NLA_U64 },
                [IPSET_ATTR_PACKETS]    = { .type = NLA_U64 },
diff --git a/net/netfilter/ipset/ip_set_hash_netnet.c b/net/netfilter/ipset/ip_set_hash_netnet.c
index a3ae69bfee66..4398322fad59 100644
--- a/net/netfilter/ipset/ip_set_hash_netnet.c
+++ b/net/netfilter/ipset/ip_set_hash_netnet.c
@@ -476,6 +476,7 @@ static struct ip_set_type hash_netnet_type __read_mostly = {
                [IPSET_ATTR_CIDR]       = { .type = NLA_U8 },
                [IPSET_ATTR_CIDR2]      = { .type = NLA_U8 },
                [IPSET_ATTR_TIMEOUT]    = { .type = NLA_U32 },
+                [IPSET_ATTR_LINENO]     = { .type = NLA_U32 },
                [IPSET_ATTR_CADT_FLAGS] = { .type = NLA_U32 },
                [IPSET_ATTR_BYTES]      = { .type = NLA_U64 },
                [IPSET_ATTR_PACKETS]    = { .type = NLA_U64 },
diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index d481f9baca2f..712a428509ad 100644
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -1922,6 +1922,7 @@ static int nf_tables_newchain(struct net *net, struct sock *nlsk,
                if (nlh->nlmsg_flags & NLM_F_REPLACE)
                        return -EOPNOTSUPP;
+                flags |= chain->flags & NFT_BASE_CHAIN;
                return nf_tables_updchain(&ctx, genmask, policy, flags);
        }
@@ -5143,9 +5144,6 @@ static int nf_tables_updobj(const struct nft_ctx *ctx,
        struct nft_trans *trans;
        int err;
-        if (!obj->ops->update)
-                return -EOPNOTSUPP;
        trans = nft_trans_alloc(ctx, NFT_MSG_NEWOBJ,
                                sizeof(struct nft_trans_obj));
        if (!trans)
@@ -6499,7 +6497,8 @@ static void nft_obj_commit_update(struct nft_trans *trans)
        obj = nft_trans_obj(trans);
        newobj = nft_trans_obj_newobj(trans);
-        obj->ops->update(obj, newobj);
+        if (obj->ops->update)
+                obj->ops->update(obj, newobj);
        kfree(newobj);
 }
diff --git a/net/netfilter/nf_tables_offload.c b/net/netfilter/nf_tables_offload.c
index ad783f4840ef..e25dab8128db 100644
--- a/net/netfilter/nf_tables_offload.c
+++ b/net/netfilter/nf_tables_offload.c
@@ -334,7 +334,8 @@ int nft_flow_rule_offload_commit(struct net *net)
                switch (trans->msg_type) {
                case NFT_MSG_NEWCHAIN:
-                        if (!(trans->ctx.chain->flags & NFT_CHAIN_HW_OFFLOAD))
+                        if (!(trans->ctx.chain->flags & NFT_CHAIN_HW_OFFLOAD) ||
+                            nft_trans_chain_update(trans))
                                continue;
                        policy = nft_trans_chain_policy(trans);
diff --git a/net/netfilter/nft_bitwise.c b/net/netfilter/nft_bitwise.c
index 974300178fa9..02afa752dd2e 100644
--- a/net/netfilter/nft_bitwise.c
+++ b/net/netfilter/nft_bitwise.c
@@ -134,12 +134,13 @@ static int nft_bitwise_offload(struct nft_offload_ctx *ctx,
                               const struct nft_expr *expr)
 {
        const struct nft_bitwise *priv = nft_expr_priv(expr);
+        struct nft_offload_reg *reg = &ctx->regs[priv->dreg];
        if (memcmp(&priv->xor, &zero, sizeof(priv->xor)) ||
-            priv->sreg != priv->dreg)
+            priv->sreg != priv->dreg || priv->len != reg->len)
                return -EOPNOTSUPP;
-        memcpy(&ctx->regs[priv->dreg].mask, &priv->mask, sizeof(priv->mask));
+        memcpy(&reg->mask, &priv->mask, sizeof(priv->mask));
        return 0;
 }
diff --git a/net/netfilter/nft_cmp.c b/net/netfilter/nft_cmp.c
index bd173b1824c6..0744b2bb46da 100644
--- a/net/netfilter/nft_cmp.c
+++ b/net/netfilter/nft_cmp.c
@@ -116,7 +116,7 @@ static int __nft_cmp_offload(struct nft_offload_ctx *ctx,
        u8 *mask = (u8 *)&flow->match.mask;
        u8 *key = (u8 *)&flow->match.key;
-        if (priv->op != NFT_CMP_EQ)
+        if (priv->op != NFT_CMP_EQ || reg->len != priv->len)
                return -EOPNOTSUPP;
        memcpy(key + reg->offset, &priv->data, priv->len);
diff --git a/net/nfc/netlink.c b/net/nfc/netlink.c
index 17e6ca62f1be..afde0d763039 100644
--- a/net/nfc/netlink.c
+++ b/net/nfc/netlink.c
@@ -1099,7 +1099,6 @@ static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
        local = nfc_llcp_find_local(dev);
        if (!local) {
-                nfc_put_device(dev);
                rc = -ENODEV;
                goto exit;
        }
@@ -1159,7 +1158,6 @@ static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info)
        local = nfc_llcp_find_local(dev);
        if (!local) {
-                nfc_put_device(dev);
                rc = -ENODEV;
                goto exit;
        }
diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index 8717c0b26c90..20d60b8fcb70 100644
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -21,6 +21,7 @@
 #include <linux/slab.h>
 #include <linux/idr.h>
 #include <linux/rhashtable.h>
+#include <linux/jhash.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/netlink.h>
@@ -47,6 +48,62 @@ static LIST_HEAD(tcf_proto_base);
 /* Protects list of registered TC modules. It is pure SMP lock. */
 static DEFINE_RWLOCK(cls_mod_lock);
+static u32 destroy_obj_hashfn(const struct tcf_proto *tp)
+{
+        return jhash_3words(tp->chain->index, tp->prio,
+                            (__force __u32)tp->protocol, 0);
+}
+static void tcf_proto_signal_destroying(struct tcf_chain *chain,
+                                        struct tcf_proto *tp)
+{
+        struct tcf_block *block = chain->block;
+        mutex_lock(&block->proto_destroy_lock);
+        hash_add_rcu(block->proto_destroy_ht, &tp->destroy_ht_node,
+                     destroy_obj_hashfn(tp));
+        mutex_unlock(&block->proto_destroy_lock);
+}
+static bool tcf_proto_cmp(const struct tcf_proto *tp1,
+                          const struct tcf_proto *tp2)
+{
+        return tp1->chain->index == tp2->chain->index &&
+               tp1->prio == tp2->prio &&
+               tp1->protocol == tp2->protocol;
+}
+static bool tcf_proto_exists_destroying(struct tcf_chain *chain,
+                                        struct tcf_proto *tp)
+{
+        u32 hash = destroy_obj_hashfn(tp);
+        struct tcf_proto *iter;
+        bool found = false;
+        rcu_read_lock();
+        hash_for_each_possible_rcu(chain->block->proto_destroy_ht, iter,
+                                   destroy_ht_node, hash) {
+                if (tcf_proto_cmp(tp, iter)) {
+                        found = true;
+                        break;
+                }
+        }
+        rcu_read_unlock();
+        return found;
+}
+static void
+tcf_proto_signal_destroyed(struct tcf_chain *chain, struct tcf_proto *tp)
+{
+        struct tcf_block *block = chain->block;
+        mutex_lock(&block->proto_destroy_lock);
+        if (hash_hashed(&tp->destroy_ht_node))
+                hash_del_rcu(&tp->destroy_ht_node);
+        mutex_unlock(&block->proto_destroy_lock);
+}
 /* Find classifier type by string name */
 static const struct tcf_proto_ops *__tcf_proto_lookup_ops(const char *kind)
@@ -234,9 +291,11 @@ static void tcf_proto_get(struct tcf_proto *tp)
 static void tcf_chain_put(struct tcf_chain *chain);
 static void tcf_proto_destroy(struct tcf_proto *tp, bool rtnl_held,
-                              struct netlink_ext_ack *extack)
+                              bool sig_destroy, struct netlink_ext_ack *extack)
 {
        tp->ops->destroy(tp, rtnl_held, extack);
+        if (sig_destroy)
+                tcf_proto_signal_destroyed(tp->chain, tp);
        tcf_chain_put(tp->chain);
        module_put(tp->ops->owner);
        kfree_rcu(tp, rcu);
@@ -246,7 +305,7 @@ static void tcf_proto_put(struct tcf_proto *tp, bool rtnl_held,
                          struct netlink_ext_ack *extack)
 {
        if (refcount_dec_and_test(&tp->refcnt))
-                tcf_proto_destroy(tp, rtnl_held, extack);
+                tcf_proto_destroy(tp, rtnl_held, true, extack);
 }
 static int walker_check_empty(struct tcf_proto *tp, void *fh,
@@ -370,6 +429,7 @@ static bool tcf_chain_detach(struct tcf_chain *chain)
 static void tcf_block_destroy(struct tcf_block *block)
 {
        mutex_destroy(&block->lock);
+        mutex_destroy(&block->proto_destroy_lock);
        kfree_rcu(block, rcu);
 }
@@ -545,6 +605,12 @@ static void tcf_chain_flush(struct tcf_chain *chain, bool rtnl_held)
        mutex_lock(&chain->filter_chain_lock);
        tp = tcf_chain_dereference(chain->filter_chain, chain);
+        while (tp) {
+                tp_next = rcu_dereference_protected(tp->next, 1);
+                tcf_proto_signal_destroying(chain, tp);
+                tp = tp_next;
+        }
+        tp = tcf_chain_dereference(chain->filter_chain, chain);
        RCU_INIT_POINTER(chain->filter_chain, NULL);
        tcf_chain0_head_change(chain, NULL);
        chain->flushing = true;
@@ -844,6 +910,7 @@ static struct tcf_block *tcf_block_create(struct net *net, struct Qdisc *q,
                return ERR_PTR(-ENOMEM);
        }
        mutex_init(&block->lock);
+        mutex_init(&block->proto_destroy_lock);
        init_rwsem(&block->cb_lock);
        flow_block_init(&block->flow_block);
        INIT_LIST_HEAD(&block->chain_list);
@@ -1621,6 +1688,12 @@ static struct tcf_proto *tcf_chain_tp_insert_unique(struct tcf_chain *chain,
        mutex_lock(&chain->filter_chain_lock);
+        if (tcf_proto_exists_destroying(chain, tp_new)) {
+                mutex_unlock(&chain->filter_chain_lock);
+                tcf_proto_destroy(tp_new, rtnl_held, false, NULL);
+                return ERR_PTR(-EAGAIN);
+        }
        tp = tcf_chain_tp_find(chain, &chain_info,
                               protocol, prio, false);
        if (!tp)
@@ -1628,10 +1701,10 @@ static struct tcf_proto *tcf_chain_tp_insert_unique(struct tcf_chain *chain,
        mutex_unlock(&chain->filter_chain_lock);
        if (tp) {
-                tcf_proto_destroy(tp_new, rtnl_held, NULL);
+                tcf_proto_destroy(tp_new, rtnl_held, false, NULL);
                tp_new = tp;
        } else if (err) {
-                tcf_proto_destroy(tp_new, rtnl_held, NULL);
+                tcf_proto_destroy(tp_new, rtnl_held, false, NULL);
                tp_new = ERR_PTR(err);
        }
@@ -1669,6 +1742,7 @@ static void tcf_chain_tp_delete_empty(struct tcf_chain *chain,
                return;
        }
+        tcf_proto_signal_destroying(chain, tp);
        next = tcf_chain_dereference(chain_info.next, chain);
        if (tp == chain->filter_chain)
                tcf_chain0_head_change(chain, next);
@@ -2188,6 +2262,7 @@ static int tc_del_tfilter(struct sk_buff *skb, struct nlmsghdr *n,
                err = -EINVAL;
                goto errout_locked;
        } else if (t->tcm_handle == 0) {
+                tcf_proto_signal_destroying(chain, tp);
                tcf_chain_tp_remove(chain, &chain_info, tp);
                mutex_unlock(&chain->filter_chain_lock);
diff --git a/net/sched/sch_taprio.c b/net/sched/sch_taprio.c
index 2121187229cd..7cd68628c637 100644
--- a/net/sched/sch_taprio.c
+++ b/net/sched/sch_taprio.c
@@ -1224,8 +1224,6 @@ static int taprio_enable_offload(struct net_device *dev,
                goto done;
        }
-        taprio_offload_config_changed(q);
 done:
        taprio_offload_free(offload);
@@ -1505,6 +1503,9 @@ static int taprio_change(struct Qdisc *sch, struct nlattr *opt,
                        call_rcu(&admin->rcu, taprio_free_sched_cb);
                spin_unlock_irqrestore(&q->current_entry_lock, flags);
+                if (FULL_OFFLOAD_IS_ENABLED(taprio_flags))
+                        taprio_offload_config_changed(q);
        }
        new_admin = NULL;
diff --git a/net/smc/smc_pnet.c b/net/smc/smc_pnet.c
index 2920b006f65c..571e6d84da3b 100644
--- a/net/smc/smc_pnet.c
+++ b/net/smc/smc_pnet.c
@@ -376,8 +376,6 @@ static int smc_pnet_fill_entry(struct net *net,
        return 0;
 error:
-        if (pnetelem->ndev)
-                dev_put(pnetelem->ndev);
        return rc;
 }
diff --git a/net/tls/tls_device.c b/net/tls/tls_device.c
index f959487c5cd1..683d00837693 100644
--- a/net/tls/tls_device.c
+++ b/net/tls/tls_device.c
@@ -523,8 +523,10 @@ last_record:
 int tls_device_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
 {
        unsigned char record_type = TLS_RECORD_TYPE_DATA;
+        struct tls_context *tls_ctx = tls_get_ctx(sk);
        int rc;
+        mutex_lock(&tls_ctx->tx_lock);
        lock_sock(sk);
        if (unlikely(msg->msg_controllen)) {
@@ -538,12 +540,14 @@ int tls_device_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
 out:
        release_sock(sk);
+        mutex_unlock(&tls_ctx->tx_lock);
        return rc;
 }
 int tls_device_sendpage(struct sock *sk, struct page *page,
                        int offset, size_t size, int flags)
 {
+        struct tls_context *tls_ctx = tls_get_ctx(sk);
        struct iov_iter msg_iter;
        char *kaddr = kmap(page);
        struct kvec iov;
@@ -552,6 +556,7 @@ int tls_device_sendpage(struct sock *sk, struct page *page,
        if (flags & MSG_SENDPAGE_NOTLAST)
                flags |= MSG_MORE;
+        mutex_lock(&tls_ctx->tx_lock);
        lock_sock(sk);
        if (flags & MSG_OOB) {
@@ -568,6 +573,7 @@ int tls_device_sendpage(struct sock *sk, struct page *page,
 out:
        release_sock(sk);
+        mutex_unlock(&tls_ctx->tx_lock);
        return rc;
 }
@@ -623,9 +629,11 @@ static int tls_device_push_pending_record(struct sock *sk, int flags)
 void tls_device_write_space(struct sock *sk, struct tls_context *ctx)
 {
-        if (!sk->sk_write_pending && tls_is_partially_sent_record(ctx)) {
+        if (tls_is_partially_sent_record(ctx)) {
                gfp_t sk_allocation = sk->sk_allocation;
+                WARN_ON_ONCE(sk->sk_write_pending);
                sk->sk_allocation = GFP_ATOMIC;
                tls_push_partial_record(sk, ctx,
                                        MSG_DONTWAIT | MSG_NOSIGNAL |
diff --git a/net/tls/tls_main.c b/net/tls/tls_main.c
index ac88877dcade..0775ae40fcfb 100644
--- a/net/tls/tls_main.c
+++ b/net/tls/tls_main.c
@@ -267,6 +267,7 @@ void tls_ctx_free(struct sock *sk, struct tls_context *ctx)
        memzero_explicit(&ctx->crypto_send, sizeof(ctx->crypto_send));
        memzero_explicit(&ctx->crypto_recv, sizeof(ctx->crypto_recv));
+        mutex_destroy(&ctx->tx_lock);
        if (sk)
                kfree_rcu(ctx, rcu);
@@ -612,6 +613,7 @@ static struct tls_context *create_ctx(struct sock *sk)
        if (!ctx)
                return NULL;
+        mutex_init(&ctx->tx_lock);
        rcu_assign_pointer(icsk->icsk_ulp_data, ctx);
        ctx->sk_proto = sk->sk_prot;
        return ctx;
diff --git a/net/tls/tls_sw.c b/net/tls/tls_sw.c
index c2b5e0d2ba1a..446f23c1f3ce 100644
--- a/net/tls/tls_sw.c
+++ b/net/tls/tls_sw.c
@@ -897,15 +897,9 @@ int tls_sw_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
        if (msg->msg_flags & ~(MSG_MORE | MSG_DONTWAIT | MSG_NOSIGNAL))
                return -ENOTSUPP;
+        mutex_lock(&tls_ctx->tx_lock);
        lock_sock(sk);
-        /* Wait till there is any pending write on socket */
-        if (unlikely(sk->sk_write_pending)) {
-                ret = wait_on_pending_writer(sk, &timeo);
-                if (unlikely(ret))
-                        goto send_end;
-        }
        if (unlikely(msg->msg_controllen)) {
                ret = tls_proccess_cmsg(sk, msg, &record_type);
                if (ret) {
@@ -1091,6 +1085,7 @@ send_end:
        ret = sk_stream_error(sk, msg->msg_flags, ret);
        release_sock(sk);
+        mutex_unlock(&tls_ctx->tx_lock);
        return copied ? copied : ret;
 }
@@ -1114,13 +1109,6 @@ static int tls_sw_do_sendpage(struct sock *sk, struct page *page,
        eor = !(flags & (MSG_MORE | MSG_SENDPAGE_NOTLAST));
        sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
-        /* Wait till there is any pending write on socket */
-        if (unlikely(sk->sk_write_pending)) {
-                ret = wait_on_pending_writer(sk, &timeo);
-                if (unlikely(ret))
-                        goto sendpage_end;
-        }
        /* Call the sk_stream functions to manage the sndbuf mem. */
        while (size > 0) {
                size_t copy, required_size;
@@ -1219,15 +1207,18 @@ sendpage_end:
 int tls_sw_sendpage(struct sock *sk, struct page *page,
                    int offset, size_t size, int flags)
 {
+        struct tls_context *tls_ctx = tls_get_ctx(sk);
        int ret;
        if (flags & ~(MSG_MORE | MSG_DONTWAIT | MSG_NOSIGNAL |
                      MSG_SENDPAGE_NOTLAST | MSG_SENDPAGE_NOPOLICY))
                return -ENOTSUPP;
+        mutex_lock(&tls_ctx->tx_lock);
        lock_sock(sk);
        ret = tls_sw_do_sendpage(sk, page, offset, size, flags);
        release_sock(sk);
+        mutex_unlock(&tls_ctx->tx_lock);
        return ret;
 }
@@ -2170,9 +2161,11 @@ static void tx_work_handler(struct work_struct *work)
        if (!test_and_clear_bit(BIT_TX_SCHEDULED, &ctx->tx_bitmask))
                return;
+        mutex_lock(&tls_ctx->tx_lock);
        lock_sock(sk);
        tls_tx_records(sk, -1);
        release_sock(sk);
+        mutex_unlock(&tls_ctx->tx_lock);
 }
 void tls_sw_write_space(struct sock *sk, struct tls_context *ctx)
@@ -2180,12 +2173,9 @@ void tls_sw_write_space(struct sock *sk, struct tls_context *ctx)
        struct tls_sw_context_tx *tx_ctx = tls_sw_ctx_tx(ctx);
        /* Schedule the transmission if tx list is ready */
-        if (is_tx_ready(tx_ctx) && !sk->sk_write_pending) {
+        if (is_tx_ready(tx_ctx) &&
-                /* Schedule the transmission */
+            !test_and_set_bit(BIT_TX_SCHEDULED, &tx_ctx->tx_bitmask))
-                if (!test_and_set_bit(BIT_TX_SCHEDULED,
+                schedule_delayed_work(&tx_ctx->tx_work.work, 0);
-                                      &tx_ctx->tx_bitmask))
-                        schedule_delayed_work(&tx_ctx->tx_work.work, 0);
-        }
 }
 void tls_sw_strparser_arm(struct sock *sk, struct tls_context *tls_ctx)
diff --git a/net/vmw_vsock/virtio_transport_common.c b/net/vmw_vsock/virtio_transport_common.c
index 481f7f8a1655..fb2060dffb0a 100644
--- a/net/vmw_vsock/virtio_transport_common.c
+++ b/net/vmw_vsock/virtio_transport_common.c
@@ -947,9 +947,11 @@ virtio_transport_recv_connected(struct sock *sk,
                if (le32_to_cpu(pkt->hdr.flags) & VIRTIO_VSOCK_SHUTDOWN_SEND)
                        vsk->peer_shutdown |= SEND_SHUTDOWN;
                if (vsk->peer_shutdown == SHUTDOWN_MASK &&
-                    vsock_stream_has_data(vsk) <= 0) {
+                    vsock_stream_has_data(vsk) <= 0 &&
-                        sock_set_flag(sk, SOCK_DONE);
+                    !sock_flag(sk, SOCK_DONE)) {
-                        sk->sk_state = TCP_CLOSING;
+                        (void)virtio_transport_reset(vsk, NULL);
+                        virtio_transport_do_close(vsk, true);
                }
                if (le32_to_cpu(pkt->hdr.flags))
                        sk->sk_state_change(sk);
diff --git a/samples/bpf/Makefile b/samples/bpf/Makefile
index 1d9be26b4edd..42b571cde177 100644
--- a/samples/bpf/Makefile
+++ b/samples/bpf/Makefile
@@ -176,6 +176,7 @@ KBUILD_HOSTCFLAGS += -I$(srctree)/tools/lib/bpf/
 KBUILD_HOSTCFLAGS += -I$(srctree)/tools/testing/selftests/bpf/
 KBUILD_HOSTCFLAGS += -I$(srctree)/tools/lib/ -I$(srctree)/tools/include
 KBUILD_HOSTCFLAGS += -I$(srctree)/tools/perf
+KBUILD_HOSTCFLAGS += -DHAVE_ATTR_TEST=0
 HOSTCFLAGS_bpf_load.o += -I$(objtree)/usr/include -Wno-unused-variable
diff --git a/tools/perf/perf-sys.h b/tools/perf/perf-sys.h
index 63e4349a772a..15e458e150bd 100644
--- a/tools/perf/perf-sys.h
+++ b/tools/perf/perf-sys.h
@@ -15,7 +15,9 @@ void test_attr__init(void);
 void test_attr__open(struct perf_event_attr *attr, pid_t pid, int cpu,
                     int fd, int group_fd, unsigned long flags);
-#define HAVE_ATTR_TEST
+#ifndef HAVE_ATTR_TEST
+#define HAVE_ATTR_TEST 1
+#endif
 static inline int
 sys_perf_event_open(struct perf_event_attr *attr,
@@ -27,7 +29,7 @@ sys_perf_event_open(struct perf_event_attr *attr,
        fd = syscall(__NR_perf_event_open, attr, pid, cpu,
                     group_fd, flags);
-#ifdef HAVE_ATTR_TEST
+#if HAVE_ATTR_TEST
        if (unlikely(test_attr__enabled))
                test_attr__open(attr, pid, cpu, fd, group_fd, flags);
 #endif
diff --git a/tools/testing/selftests/bpf/test_sysctl.c b/tools/testing/selftests/bpf/test_sysctl.c
index a320e3844b17..7c6e5b173f33 100644
--- a/tools/testing/selftests/bpf/test_sysctl.c
+++ b/tools/testing/selftests/bpf/test_sysctl.c
@@ -161,9 +161,14 @@ static struct sysctl_test tests[] = {
                .descr = "ctx:file_pos sysctl:read read ok narrow",
                .insns = {
                        /* If (file_pos == X) */
+#if __BYTE_ORDER == __LITTLE_ENDIAN
                        BPF_LDX_MEM(BPF_B, BPF_REG_7, BPF_REG_1,
                                    offsetof(struct bpf_sysctl, file_pos)),
-                        BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0, 2),
+#else
+                        BPF_LDX_MEM(BPF_B, BPF_REG_7, BPF_REG_1,
+                                    offsetof(struct bpf_sysctl, file_pos) + 3),
+#endif
+                        BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 4, 2),
                        /* return ALLOW; */
                        BPF_MOV64_IMM(BPF_REG_0, 1),
@@ -176,6 +181,7 @@ static struct sysctl_test tests[] = {
                .attach_type = BPF_CGROUP_SYSCTL,
                .sysctl = "kernel/ostype",
                .open_flags = O_RDONLY,
+                .seek = 4,
                .result = SUCCESS,
        },
        {
diff --git a/tools/testing/selftests/net/tls.c b/tools/testing/selftests/net/tls.c
index 4c285b6e1db8..1c8f194d6556 100644
--- a/tools/testing/selftests/net/tls.c
+++ b/tools/testing/selftests/net/tls.c
@@ -898,6 +898,114 @@ TEST_F(tls, nonblocking)
        }
 }
+static void
+test_mutliproc(struct __test_metadata *_metadata, struct _test_data_tls *self,
+               bool sendpg, unsigned int n_readers, unsigned int n_writers)
+{
+        const unsigned int n_children = n_readers + n_writers;
+        const size_t data = 6 * 1000 * 1000;
+        const size_t file_sz = data / 100;
+        size_t read_bias, write_bias;
+        int i, fd, child_id;
+        char buf[file_sz];
+        pid_t pid;
+        /* Only allow multiples for simplicity */
+        ASSERT_EQ(!(n_readers % n_writers) || !(n_writers % n_readers), true);
+        read_bias = n_writers / n_readers ?: 1;
+        write_bias = n_readers / n_writers ?: 1;
+        /* prep a file to send */
+        fd = open("/tmp/", O_TMPFILE | O_RDWR, 0600);
+        ASSERT_GE(fd, 0);
+        memset(buf, 0xac, file_sz);
+        ASSERT_EQ(write(fd, buf, file_sz), file_sz);
+        /* spawn children */
+        for (child_id = 0; child_id < n_children; child_id++) {
+                pid = fork();
+                ASSERT_NE(pid, -1);
+                if (!pid)
+                        break;
+        }
+        /* parent waits for all children */
+        if (pid) {
+                for (i = 0; i < n_children; i++) {
+                        int status;
+                        wait(&status);
+                        EXPECT_EQ(status, 0);
+                }
+                return;
+        }
+        /* Split threads for reading and writing */
+        if (child_id < n_readers) {
+                size_t left = data * read_bias;
+                char rb[8001];
+                while (left) {
+                        int res;
+                        res = recv(self->cfd, rb,
+                                   left > sizeof(rb) ? sizeof(rb) : left, 0);
+                        EXPECT_GE(res, 0);
+                        left -= res;
+                }
+        } else {
+                size_t left = data * write_bias;
+                while (left) {
+                        int res;
+                        ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0);
+                        if (sendpg)
+                                res = sendfile(self->fd, fd, NULL,
+                                               left > file_sz ? file_sz : left);
+                        else
+                                res = send(self->fd, buf,
+                                           left > file_sz ? file_sz : left, 0);
+                        EXPECT_GE(res, 0);
+                        left -= res;
+                }
+        }
+}
+TEST_F(tls, mutliproc_even)
+{
+        test_mutliproc(_metadata, self, false, 6, 6);
+}
+TEST_F(tls, mutliproc_readers)
+{
+        test_mutliproc(_metadata, self, false, 4, 12);
+}
+TEST_F(tls, mutliproc_writers)
+{
+        test_mutliproc(_metadata, self, false, 10, 2);
+}
+TEST_F(tls, mutliproc_sendpage_even)
+{
+        test_mutliproc(_metadata, self, true, 6, 6);
+}
+TEST_F(tls, mutliproc_sendpage_readers)
+{
+        test_mutliproc(_metadata, self, true, 4, 12);
+}
+TEST_F(tls, mutliproc_sendpage_writers)
+{
+        test_mutliproc(_metadata, self, true, 10, 2);
+}
 TEST_F(tls, control_msg)
 {
        if (self->notls)
author	Linus Torvalds <torvalds@linux-foundation.org>	2019-11-08 21:21:05 -0500
committer	Linus Torvalds <torvalds@linux-foundation.org>	2019-11-08 21:21:05 -0500
commit	0058b0a506e40d9a2c62015fe92eb64a44d78cd9 (patch)
tree	b92b6bb31d6308a3f049b49e3780e525ff67a2e5
parent	5cb8418cb533222709f362d264653a634eb8c7ac (diff)
parent	a2582cdc32f071422e0197a6c59bd1235b426ce2 (diff)