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

Pull networking fixes from David Miller:

 1) Fix double-free in batman-adv, from Sven Eckelmann.

 2) Fix packet stats for fast-RX path, from Joannes Berg.

 3) Netfilter's ip_route_me_harder() doesn't handle request sockets
    properly, fix from Florian Westphal.

 4) Fix sendmsg deadlock in rxrpc, from David Howells.

 5) Add missing RCU locking to transport hashtable scan, from Xin Long.

 6) Fix potential packet loss in mlxsw driver, from Ido Schimmel.

 7) Fix race in NAPI handling between poll handlers and busy polling,
    from Eric Dumazet.

 8) TX path in vxlan and geneve need proper RCU locking, from Jakub
    Kicinski.

 9) SYN processing in DCCP and TCP need to disable BH, from Eric
    Dumazet.

10) Properly handle net_enable_timestamp() being invoked from IRQ
    context, also from Eric Dumazet.

11) Fix crash on device-tree systems in xgene driver, from Alban Bedel.

12) Do not call sk_free() on a locked socket, from Arnaldo Carvalho de
    Melo.

13) Fix use-after-free in netvsc driver, from Dexuan Cui.

14) Fix max MTU setting in bonding driver, from WANG Cong.

15) xen-netback hash table can be allocated from softirq context, so use
    GFP_ATOMIC. From Anoob Soman.

16) Fix MAC address change bug in bgmac driver, from Hari Vyas.

17) strparser needs to destroy strp_wq on module exit, from WANG Cong.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (69 commits)
  strparser: destroy workqueue on module exit
  sfc: fix IPID endianness in TSOv2
  sfc: avoid max() in array size
  rds: remove unnecessary returned value check
  rxrpc: Fix potential NULL-pointer exception
  nfp: correct DMA direction in XDP DMA sync
  nfp: don't tell FW about the reserved buffer space
  net: ethernet: bgmac: mac address change bug
  net: ethernet: bgmac: init sequence bug
  xen-netback: don't vfree() queues under spinlock
  xen-netback: keep a local pointer for vif in backend_disconnect()
  netfilter: nf_tables: don't call nfnetlink_set_err() if nfnetlink_send() fails
  netfilter: nft_set_rbtree: incorrect assumption on lower interval lookups
  netfilter: nf_conntrack_sip: fix wrong memory initialisation
  can: flexcan: fix typo in comment
  can: usb_8dev: Fix memory leak of priv->cmd_msg_buffer
  can: gs_usb: fix coding style
  can: gs_usb: Don't use stack memory for USB transfers
  ixgbe: Limit use of 2K buffers on architectures with 256B or larger cache lines
  ixgbe: update the rss key on h/w, when ethtool ask for it
  ...

3 files changed, 51 insertions, 41 deletions

diff --git a/include/linux/average.h b/include/linux/average.h
index d04aa58280de..7ddaf340d2ac 100644
--- a/include/linux/average.h
+++ b/include/linux/average.h
@@ -1,45 +1,66 @@
 #ifndef _LINUX_AVERAGE_H
 #define _LINUX_AVERAGE_H
 
-/* Exponentially weighted moving average (EWMA) */
+/*
+ * Exponentially weighted moving average (EWMA)
+ *
+ * This implements a fixed-precision EWMA algorithm, with both the
+ * precision and fall-off coefficient determined at compile-time
+ * and built into the generated helper funtions.
+ *
+ * The first argument to the macro is the name that will be used
+ * for the struct and helper functions.
+ *
+ * The second argument, the precision, expresses how many bits are
+ * used for the fractional part of the fixed-precision values.
+ *
+ * The third argument, the weight reciprocal, determines how the
+ * new values will be weighed vs. the old state, new values will
+ * get weight 1/weight_rcp and old values 1-1/weight_rcp. Note
+ * that this parameter must be a power of two for efficiency.
+ */
 
-#define DECLARE_EWMA(name, _factor, _weight)                            \
+#define DECLARE_EWMA(name, _precision, _weight_rcp)                     \
         struct ewma_##name {                                            \
                 unsigned long internal;                                 \
         };                                                              \
         static inline void ewma_##name##_init(struct ewma_##name *e)    \
         {                                                               \
-                BUILD_BUG_ON(!__builtin_constant_p(_factor));           \
-                BUILD_BUG_ON(!__builtin_constant_p(_weight));           \
-                BUILD_BUG_ON_NOT_POWER_OF_2(_factor);                   \
-                BUILD_BUG_ON_NOT_POWER_OF_2(_weight);                   \
+                BUILD_BUG_ON(!__builtin_constant_p(_precision));        \
+                BUILD_BUG_ON(!__builtin_constant_p(_weight_rcp));       \
+                /*                                                      \
+                 * Even if you want to feed it just 0/1 you should have \
+                 * some bits for the non-fractional part...             \
+                 */                                                     \
+                BUILD_BUG_ON((_precision) > 30);                        \
+                BUILD_BUG_ON_NOT_POWER_OF_2(_weight_rcp);               \
                 e->internal = 0;                                        \
         }                                                               \
         static inline unsigned long                                     \
         ewma_##name##_read(struct ewma_##name *e)                       \
         {                                                               \
-                BUILD_BUG_ON(!__builtin_constant_p(_factor));           \
-                BUILD_BUG_ON(!__builtin_constant_p(_weight));           \
-                BUILD_BUG_ON_NOT_POWER_OF_2(_factor);                   \
-                BUILD_BUG_ON_NOT_POWER_OF_2(_weight);                   \
-                return e->internal >> ilog2(_factor);                   \
+                BUILD_BUG_ON(!__builtin_constant_p(_precision));        \
+                BUILD_BUG_ON(!__builtin_constant_p(_weight_rcp));       \
+                BUILD_BUG_ON((_precision) > 30);                        \
+                BUILD_BUG_ON_NOT_POWER_OF_2(_weight_rcp);               \
+                return e->internal >> (_precision);                     \
         }                                                               \
         static inline void ewma_##name##_add(struct ewma_##name *e,     \
                                              unsigned long val)         \
         {                                                               \
                 unsigned long internal = ACCESS_ONCE(e->internal);      \
-                unsigned long weight = ilog2(_weight);                  \
-                unsigned long factor = ilog2(_factor);                  \
+                unsigned long weight_rcp = ilog2(_weight_rcp);          \
+                unsigned long precision = _precision;                   \
                                                                         \
-                BUILD_BUG_ON(!__builtin_constant_p(_factor));           \
-                BUILD_BUG_ON(!__builtin_constant_p(_weight));           \
-                BUILD_BUG_ON_NOT_POWER_OF_2(_factor);                   \
-                BUILD_BUG_ON_NOT_POWER_OF_2(_weight);                   \
+                BUILD_BUG_ON(!__builtin_constant_p(_precision));        \
+                BUILD_BUG_ON(!__builtin_constant_p(_weight_rcp));       \
+                BUILD_BUG_ON((_precision) > 30);                        \
+                BUILD_BUG_ON_NOT_POWER_OF_2(_weight_rcp);               \
                                                                         \
                 ACCESS_ONCE(e->internal) = internal ?                   \
-                        (((internal << weight) - internal) +            \
-                                (val << factor)) >> weight :            \
-                        (val << factor);                                \
+                        (((internal << weight_rcp) - internal) +        \
+                                (val << precision)) >> weight_rcp :     \
+                        (val << precision);                             \
         }
 
 #endif /* _LINUX_AVERAGE_H */
diff --git a/include/linux/mlx4/driver.h b/include/linux/mlx4/driver.h
index e965e5090d96..a858bcb6220b 100644
--- a/include/linux/mlx4/driver.h
+++ b/include/linux/mlx4/driver.h
@@ -109,7 +109,7 @@ static inline void mlx4_u64_to_mac(u8 *addr, u64 mac)
         int i;
 
         for (i = ETH_ALEN; i > 0; i--) {
-                addr[i - 1] = mac && 0xFF;
+                addr[i - 1] = mac & 0xFF;
                 mac >>= 8;
         }
 }
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index f40f0ab3847a..97456b2539e4 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -330,6 +330,7 @@ struct napi_struct {
 
 enum {
         NAPI_STATE_SCHED,       /* Poll is scheduled */
+        NAPI_STATE_MISSED,      /* reschedule a napi */
         NAPI_STATE_DISABLE,     /* Disable pending */
         NAPI_STATE_NPSVC,       /* Netpoll - don't dequeue from poll_list */
         NAPI_STATE_HASHED,      /* In NAPI hash (busy polling possible) */
@@ -338,12 +339,13 @@ enum {
 };
 
 enum {
-        NAPIF_STATE_SCHED        = (1UL << NAPI_STATE_SCHED),
-        NAPIF_STATE_DISABLE      = (1UL << NAPI_STATE_DISABLE),
-        NAPIF_STATE_NPSVC        = (1UL << NAPI_STATE_NPSVC),
-        NAPIF_STATE_HASHED       = (1UL << NAPI_STATE_HASHED),
-        NAPIF_STATE_NO_BUSY_POLL = (1UL << NAPI_STATE_NO_BUSY_POLL),
-        NAPIF_STATE_IN_BUSY_POLL = (1UL << NAPI_STATE_IN_BUSY_POLL),
+        NAPIF_STATE_SCHED        = BIT(NAPI_STATE_SCHED),
+        NAPIF_STATE_MISSED       = BIT(NAPI_STATE_MISSED),
+        NAPIF_STATE_DISABLE      = BIT(NAPI_STATE_DISABLE),
+        NAPIF_STATE_NPSVC        = BIT(NAPI_STATE_NPSVC),
+        NAPIF_STATE_HASHED       = BIT(NAPI_STATE_HASHED),
+        NAPIF_STATE_NO_BUSY_POLL = BIT(NAPI_STATE_NO_BUSY_POLL),
+        NAPIF_STATE_IN_BUSY_POLL = BIT(NAPI_STATE_IN_BUSY_POLL),
 };
 
 enum gro_result {
@@ -414,20 +416,7 @@ static inline bool napi_disable_pending(struct napi_struct *n)
         return test_bit(NAPI_STATE_DISABLE, &n->state);
 }
 
-/**
- *      napi_schedule_prep - check if NAPI can be scheduled
- *      @n: NAPI context
- *
- * Test if NAPI routine is already running, and if not mark
- * it as running.  This is used as a condition variable to
- * insure only one NAPI poll instance runs.  We also make
- * sure there is no pending NAPI disable.
- */
-static inline bool napi_schedule_prep(struct napi_struct *n)
-{
-        return !napi_disable_pending(n) &&
-                !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
-}
+bool napi_schedule_prep(struct napi_struct *n);
 
 /**
  *      napi_schedule - schedule NAPI poll