Merge git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf-next

Pablo Neira Ayuso says:

====================
Netfilter updates for net-next

The following patchset contains Netfilter updates for your net-next tree.
They are:

* nf_tables set timeout infrastructure from Patrick Mchardy.

1) Add support for set timeout support.

2) Add support for set element timeouts using the new set extension
   infrastructure.

4) Add garbage collection helper functions to get rid of stale elements.
   Elements are accumulated in a batch that are asynchronously released
   via RCU when the batch is full.

5) Add garbage collection synchronization helpers. This introduces a new
   element busy bit to address concurrent access from the netlink API and the
   garbage collector.

5) Add timeout support for the nft_hash set implementation. The garbage
   collector peridically checks for stale elements from the workqueue.

* iptables/nftables cgroup fixes:

6) Ignore non full-socket objects from the input path, otherwise cgroup
   match may crash, from Daniel Borkmann.

7) Fix cgroup in nf_tables.

8) Save some cycles from xt_socket by skipping packet header parsing when
   skb->sk is already set because of early demux. Also from Daniel.

* br_netfilter updates from Florian Westphal.

9) Save frag_max_size and restore it from the forward path too.

10) Use a per-cpu area to restore the original source MAC address when traffic
    is DNAT'ed.

11) Add helper functions to access physical devices.

12) Use these new physdev helper function from xt_physdev.

13) Add another nf_bridge_info_get() helper function to fetch the br_netfilter
    state information.

14) Annotate original layer 2 protocol number in nf_bridge info, instead of
    using kludgy flags.

15) Also annotate the pkttype mangling when the packet travels back and forth
    from the IP to the bridge layer, instead of using a flag.

* More nf_tables set enhancement from Patrick:

16) Fix possible usage of set variant that doesn't support timeouts.

17) Avoid spurious "set is full" errors from Netlink API when there are pending
    stale elements scheduled to be released.

18) Restrict loop checks to set maps.

19) Add support for dynamic set updates from the packet path.

20) Add support to store optional user data (eg. comments) per set element.

BTW, I have also pulled net-next into nf-next to anticipate the conflict
resolution between your okfn() signature changes and Florian's br_netfilter
updates.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

2 files changed, 157 insertions, 1 deletions

diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index 804981980393..d6a2f0ed5130 100644
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -195,6 +195,7 @@ struct nft_set_estimate {
 };
 
 struct nft_set_ext;
+struct nft_expr;
 
 /**
  *      struct nft_set_ops - nf_tables set operations
@@ -217,6 +218,15 @@ struct nft_set_ops {
         bool                            (*lookup)(const struct nft_set *set,
                                                   const struct nft_data *key,
                                                   const struct nft_set_ext **ext);
+        bool                            (*update)(struct nft_set *set,
+                                                  const struct nft_data *key,
+                                                  void *(*new)(struct nft_set *,
+                                                               const struct nft_expr *,
+                                                               struct nft_data []),
+                                                  const struct nft_expr *expr,
+                                                  struct nft_data data[],
+                                                  const struct nft_set_ext **ext);
+
         int                             (*insert)(const struct nft_set *set,
                                                   const struct nft_set_elem *elem);
         void                            (*activate)(const struct nft_set *set,
@@ -257,6 +267,9 @@ void nft_unregister_set(struct nft_set_ops *ops);
  *      @dtype: data type (verdict or numeric type defined by userspace)
  *      @size: maximum set size
  *      @nelems: number of elements
+ *      @ndeact: number of deactivated elements queued for removal
+ *      @timeout: default timeout value in msecs
+ *      @gc_int: garbage collection interval in msecs
  *      @policy: set parameterization (see enum nft_set_policies)
  *      @ops: set ops
  *      @pnet: network namespace
@@ -272,7 +285,10 @@ struct nft_set {
         u32                             ktype;
         u32                             dtype;
         u32                             size;
-        u32                             nelems;
+        atomic_t                        nelems;
+        u32                             ndeact;
+        u64                             timeout;
+        u32                             gc_int;
         u16                             policy;
         /* runtime data below here */
         const struct nft_set_ops        *ops ____cacheline_aligned;
@@ -289,16 +305,27 @@ static inline void *nft_set_priv(const struct nft_set *set)
         return (void *)set->data;
 }
 
+static inline struct nft_set *nft_set_container_of(const void *priv)
+{
+        return (void *)priv - offsetof(struct nft_set, data);
+}
+
 struct nft_set *nf_tables_set_lookup(const struct nft_table *table,
                                      const struct nlattr *nla);
 struct nft_set *nf_tables_set_lookup_byid(const struct net *net,
                                           const struct nlattr *nla);
 
+static inline unsigned long nft_set_gc_interval(const struct nft_set *set)
+{
+        return set->gc_int ? msecs_to_jiffies(set->gc_int) : HZ;
+}
+
 /**
  *      struct nft_set_binding - nf_tables set binding
  *
  *      @list: set bindings list node
  *      @chain: chain containing the rule bound to the set
+ *      @flags: set action flags
  *
  *      A set binding contains all information necessary for validation
  *      of new elements added to a bound set.
@@ -306,6 +333,7 @@ struct nft_set *nf_tables_set_lookup_byid(const struct net *net,
 struct nft_set_binding {
         struct list_head                list;
         const struct nft_chain          *chain;
+        u32                             flags;
 };
 
 int nf_tables_bind_set(const struct nft_ctx *ctx, struct nft_set *set,
@@ -319,12 +347,18 @@ void nf_tables_unbind_set(const struct nft_ctx *ctx, struct nft_set *set,
  *      @NFT_SET_EXT_KEY: element key
  *      @NFT_SET_EXT_DATA: mapping data
  *      @NFT_SET_EXT_FLAGS: element flags
+ *      @NFT_SET_EXT_TIMEOUT: element timeout
+ *      @NFT_SET_EXT_EXPIRATION: element expiration time
+ *      @NFT_SET_EXT_USERDATA: user data associated with the element
  *      @NFT_SET_EXT_NUM: number of extension types
  */
 enum nft_set_extensions {
         NFT_SET_EXT_KEY,
         NFT_SET_EXT_DATA,
         NFT_SET_EXT_FLAGS,
+        NFT_SET_EXT_TIMEOUT,
+        NFT_SET_EXT_EXPIRATION,
+        NFT_SET_EXT_USERDATA,
         NFT_SET_EXT_NUM
 };
 
@@ -421,15 +455,97 @@ static inline u8 *nft_set_ext_flags(const struct nft_set_ext *ext)
         return nft_set_ext(ext, NFT_SET_EXT_FLAGS);
 }
 
+static inline u64 *nft_set_ext_timeout(const struct nft_set_ext *ext)
+{
+        return nft_set_ext(ext, NFT_SET_EXT_TIMEOUT);
+}
+
+static inline unsigned long *nft_set_ext_expiration(const struct nft_set_ext *ext)
+{
+        return nft_set_ext(ext, NFT_SET_EXT_EXPIRATION);
+}
+
+static inline struct nft_userdata *nft_set_ext_userdata(const struct nft_set_ext *ext)
+{
+        return nft_set_ext(ext, NFT_SET_EXT_USERDATA);
+}
+
+static inline bool nft_set_elem_expired(const struct nft_set_ext *ext)
+{
+        return nft_set_ext_exists(ext, NFT_SET_EXT_EXPIRATION) &&
+               time_is_before_eq_jiffies(*nft_set_ext_expiration(ext));
+}
+
 static inline struct nft_set_ext *nft_set_elem_ext(const struct nft_set *set,
                                                    void *elem)
 {
         return elem + set->ops->elemsize;
 }
 
+void *nft_set_elem_init(const struct nft_set *set,
+                        const struct nft_set_ext_tmpl *tmpl,
+                        const struct nft_data *key,
+                        const struct nft_data *data,
+                        u64 timeout, gfp_t gfp);
 void nft_set_elem_destroy(const struct nft_set *set, void *elem);
 
 /**
+ *      struct nft_set_gc_batch_head - nf_tables set garbage collection batch
+ *
+ *      @rcu: rcu head
+ *      @set: set the elements belong to
+ *      @cnt: count of elements
+ */
+struct nft_set_gc_batch_head {
+        struct rcu_head                 rcu;
+        const struct nft_set            *set;
+        unsigned int                    cnt;
+};
+
+#define NFT_SET_GC_BATCH_SIZE   ((PAGE_SIZE -                             \
+                                  sizeof(struct nft_set_gc_batch_head)) / \
+                                 sizeof(void *))
+
+/**
+ *      struct nft_set_gc_batch - nf_tables set garbage collection batch
+ *
+ *      @head: GC batch head
+ *      @elems: garbage collection elements
+ */
+struct nft_set_gc_batch {
+        struct nft_set_gc_batch_head    head;
+        void                            *elems[NFT_SET_GC_BATCH_SIZE];
+};
+
+struct nft_set_gc_batch *nft_set_gc_batch_alloc(const struct nft_set *set,
+                                                gfp_t gfp);
+void nft_set_gc_batch_release(struct rcu_head *rcu);
+
+static inline void nft_set_gc_batch_complete(struct nft_set_gc_batch *gcb)
+{
+        if (gcb != NULL)
+                call_rcu(&gcb->head.rcu, nft_set_gc_batch_release);
+}
+
+static inline struct nft_set_gc_batch *
+nft_set_gc_batch_check(const struct nft_set *set, struct nft_set_gc_batch *gcb,
+                       gfp_t gfp)
+{
+        if (gcb != NULL) {
+                if (gcb->head.cnt + 1 < ARRAY_SIZE(gcb->elems))
+                        return gcb;
+                nft_set_gc_batch_complete(gcb);
+        }
+        return nft_set_gc_batch_alloc(set, gfp);
+}
+
+static inline void nft_set_gc_batch_add(struct nft_set_gc_batch *gcb,
+                                        void *elem)
+{
+        gcb->elems[gcb->head.cnt++] = elem;
+}
+
+/**
  *      struct nft_expr_type - nf_tables expression type
  *
  *      @select_ops: function to select nft_expr_ops
@@ -750,6 +866,8 @@ static inline u8 nft_genmask_cur(const struct net *net)
         return 1 << ACCESS_ONCE(net->nft.gencursor);
 }
 
+#define NFT_GENMASK_ANY         ((1 << 0) | (1 << 1))
+
 /*
  * Set element transaction helpers
  */
@@ -766,6 +884,41 @@ static inline void nft_set_elem_change_active(const struct nft_set *set,
         ext->genmask ^= nft_genmask_next(read_pnet(&set->pnet));
 }
 
+/*
+ * We use a free bit in the genmask field to indicate the element
+ * is busy, meaning it is currently being processed either by
+ * the netlink API or GC.
+ *
+ * Even though the genmask is only a single byte wide, this works
+ * because the extension structure if fully constant once initialized,
+ * so there are no non-atomic write accesses unless it is already
+ * marked busy.
+ */
+#define NFT_SET_ELEM_BUSY_MASK  (1 << 2)
+
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+#define NFT_SET_ELEM_BUSY_BIT   2
+#elif defined(__BIG_ENDIAN_BITFIELD)
+#define NFT_SET_ELEM_BUSY_BIT   (BITS_PER_LONG - BITS_PER_BYTE + 2)
+#else
+#error
+#endif
+
+static inline int nft_set_elem_mark_busy(struct nft_set_ext *ext)
+{
+        unsigned long *word = (unsigned long *)ext;
+
+        BUILD_BUG_ON(offsetof(struct nft_set_ext, genmask) != 0);
+        return test_and_set_bit(NFT_SET_ELEM_BUSY_BIT, word);
+}
+
+static inline void nft_set_elem_clear_busy(struct nft_set_ext *ext)
+{
+        unsigned long *word = (unsigned long *)ext;
+
+        clear_bit(NFT_SET_ELEM_BUSY_BIT, word);
+}
+
 /**
  *      struct nft_trans - nf_tables object update in transaction
  *
diff --git a/include/net/netfilter/nf_tables_core.h b/include/net/netfilter/nf_tables_core.h
index a75fc8e27cd6..c6f400cfaac8 100644
--- a/include/net/netfilter/nf_tables_core.h
+++ b/include/net/netfilter/nf_tables_core.h
@@ -31,6 +31,9 @@ void nft_cmp_module_exit(void);
 int nft_lookup_module_init(void);
 void nft_lookup_module_exit(void);
 
+int nft_dynset_module_init(void);
+void nft_dynset_module_exit(void);
+
 int nft_bitwise_module_init(void);
 void nft_bitwise_module_exit(void);