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 net-next,
they are:

1) Don't use userspace datatypes in bridge netfilter code, from
   Tobin Harding.

2) Iterate only once over the expectation table when removing the
   helper module, instead of once per-netns, from Florian Westphal.

3) Extra sanitization in xt_hook_ops_alloc() to return error in case
   we ever pass zero hooks, xt_hook_ops_alloc():

4) Handle NFPROTO_INET from the logging core infrastructure, from
   Liping Zhang.

5) Autoload loggers when TRACE target is used from rules, this doesn't
   change the behaviour in case the user already selected nfnetlink_log
   as preferred way to print tracing logs, also from Liping Zhang.

6) Conntrack slabs with SLAB_HWCACHE_ALIGN to allow rearranging fields
   by cache lines, increases the size of entries in 11% per entry.
   From Florian Westphal.

7) Skip zone comparison if CONFIG_NF_CONNTRACK_ZONES=n, from Florian.

8) Remove useless defensive check in nf_logger_find_get() from Shivani
   Bhardwaj.

9) Remove zone extension as place it in the conntrack object, this is
   always include in the hashing and we expect more intensive use of
   zones since containers are in place. Also from Florian Westphal.

10) Owner match now works from any namespace, from Eric Bierdeman.

11) Make sure we only reply with TCP reset to TCP traffic from
    nf_reject_ipv4, patch from Liping Zhang.

12) Introduce --nflog-size to indicate amount of network packet bytes
    that are copied to userspace via log message, from Vishwanath Pai.
    This obsoletes --nflog-range that has never worked, it was designed
    to achieve this but it has never worked.

13) Introduce generic macros for nf_tables object generation masks.

14) Use generation mask in table, chain and set objects in nf_tables.
    This allows fixes interferences with ongoing preparation phase of
    the commit protocol and object listings going on at the same time.
    This update is introduced in three patches, one per object.

15) Check if the object is active in the next generation for element
    deactivation in the rbtree implementation, given that deactivation
    happens from the commit phase path we have to observe the future
    status of the object.

16) Support for deletion of just added elements in the hash set type.

17) Allow to resize hashtable from /proc entry, not only from the
    obscure /sys entry that maps to the module parameter, from Florian
    Westphal.

18) Get rid of NFT_BASECHAIN_DISABLED, this code is not exercised
    anymore since we tear down the ruleset whenever the netdevice
    goes away.

19) Support for matching inverted set lookups, from Arturo Borrero.

20) Simplify the iptables_mangle_hook() by removing a superfluous
    extra branch.

21) Introduce ether_addr_equal_masked() and use it from the netfilter
    codebase, from Joe Perches.

22) Remove references to "Use netfilter MARK value as routing key"
    from the Netfilter Kconfig description given that this toggle
    doesn't exists already for 10 years, from Moritz Sichert.

23) Introduce generic NF_INVF() and use it from the xtables codebase,
    from Joe Perches.

24) Setting logger to NONE via /proc was not working unless explicit
    nul-termination was included in the string. This fixes seems to
    leave the former behaviour there, so we don't break backward.
====================

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

17 files changed, 428 insertions, 321 deletions

diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig
index 95e757c377f9..9266ceebd112 100644
--- a/net/netfilter/Kconfig
+++ b/net/netfilter/Kconfig
@@ -609,9 +609,8 @@ config NETFILTER_XT_MARK
         The target allows you to create rules in the "mangle" table which alter
         the netfilter mark (nfmark) field associated with the packet.
 
-        Prior to routing, the nfmark can influence the routing method (see
-        "Use netfilter MARK value as routing key") and can also be used by
-        other subsystems to change their behavior.
+        Prior to routing, the nfmark can influence the routing method and can
+        also be used by other subsystems to change their behavior.
 
 config NETFILTER_XT_CONNMARK
         tristate 'ctmark target and match support'
@@ -753,9 +752,8 @@ config NETFILTER_XT_TARGET_HMARK
 
         The target allows you to create rules in the "raw" and "mangle" tables
         which set the skbuff mark by means of hash calculation within a given
-        range. The nfmark can influence the routing method (see "Use netfilter
-        MARK value as routing key") and can also be used by other subsystems to
-        change their behaviour.
+        range. The nfmark can influence the routing method and can also be used
+        by other subsystems to change their behaviour.
 
         To compile it as a module, choose M here. If unsure, say N.
 
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index f204274a9b6b..153e33ffeeaa 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -327,16 +327,10 @@ struct nf_conn *nf_ct_tmpl_alloc(struct net *net,
 
         tmpl->status = IPS_TEMPLATE;
         write_pnet(&tmpl->ct_net, net);
-
-        if (nf_ct_zone_add(tmpl, flags, zone) < 0)
-                goto out_free;
-
+        nf_ct_zone_add(tmpl, zone);
         atomic_set(&tmpl->ct_general.use, 0);
 
         return tmpl;
-out_free:
-        kfree(tmpl);
-        return NULL;
 }
 EXPORT_SYMBOL_GPL(nf_ct_tmpl_alloc);
 
@@ -929,16 +923,13 @@ __nf_conntrack_alloc(struct net *net,
                offsetof(struct nf_conn, proto) -
                offsetof(struct nf_conn, __nfct_init_offset[0]));
 
-        if (zone && nf_ct_zone_add(ct, GFP_ATOMIC, zone) < 0)
-                goto out_free;
+        nf_ct_zone_add(ct, zone);
 
         /* Because we use RCU lookups, we set ct_general.use to zero before
          * this is inserted in any list.
          */
         atomic_set(&ct->ct_general.use, 0);
         return ct;
-out_free:
-        kmem_cache_free(nf_conntrack_cachep, ct);
 out:
         atomic_dec(&net->ct.count);
         return ERR_PTR(-ENOMEM);
@@ -1342,14 +1333,6 @@ bool __nf_ct_kill_acct(struct nf_conn *ct,
 }
 EXPORT_SYMBOL_GPL(__nf_ct_kill_acct);
 
-#ifdef CONFIG_NF_CONNTRACK_ZONES
-static struct nf_ct_ext_type nf_ct_zone_extend __read_mostly = {
-        .len    = sizeof(struct nf_conntrack_zone),
-        .align  = __alignof__(struct nf_conntrack_zone),
-        .id     = NF_CT_EXT_ZONE,
-};
-#endif
-
 #if IS_ENABLED(CONFIG_NF_CT_NETLINK)
 
 #include <linux/netfilter/nfnetlink.h>
@@ -1532,9 +1515,6 @@ void nf_conntrack_cleanup_end(void)
 
         nf_ct_free_hashtable(nf_conntrack_hash, nf_conntrack_htable_size);
 
-#ifdef CONFIG_NF_CONNTRACK_ZONES
-        nf_ct_extend_unregister(&nf_ct_zone_extend);
-#endif
         nf_conntrack_proto_fini();
         nf_conntrack_seqadj_fini();
         nf_conntrack_labels_fini();
@@ -1617,24 +1597,14 @@ void *nf_ct_alloc_hashtable(unsigned int *sizep, int nulls)
 }
 EXPORT_SYMBOL_GPL(nf_ct_alloc_hashtable);
 
-int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp)
+int nf_conntrack_hash_resize(unsigned int hashsize)
 {
-        int i, bucket, rc;
-        unsigned int hashsize, old_size;
+        int i, bucket;
+        unsigned int old_size;
         struct hlist_nulls_head *hash, *old_hash;
         struct nf_conntrack_tuple_hash *h;
         struct nf_conn *ct;
 
-        if (current->nsproxy->net_ns != &init_net)
-                return -EOPNOTSUPP;
-
-        /* On boot, we can set this without any fancy locking. */
-        if (!nf_conntrack_htable_size)
-                return param_set_uint(val, kp);
-
-        rc = kstrtouint(val, 0, &hashsize);
-        if (rc)
-                return rc;
         if (!hashsize)
                 return -EINVAL;
 
@@ -1642,6 +1612,12 @@ int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp)
         if (!hash)
                 return -ENOMEM;
 
+        old_size = nf_conntrack_htable_size;
+        if (old_size == hashsize) {
+                nf_ct_free_hashtable(hash, hashsize);
+                return 0;
+        }
+
         local_bh_disable();
         nf_conntrack_all_lock();
         write_seqcount_begin(&nf_conntrack_generation);
@@ -1677,6 +1653,25 @@ int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp)
         nf_ct_free_hashtable(old_hash, old_size);
         return 0;
 }
+
+int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp)
+{
+        unsigned int hashsize;
+        int rc;
+
+        if (current->nsproxy->net_ns != &init_net)
+                return -EOPNOTSUPP;
+
+        /* On boot, we can set this without any fancy locking. */
+        if (!nf_conntrack_htable_size)
+                return param_set_uint(val, kp);
+
+        rc = kstrtouint(val, 0, &hashsize);
+        if (rc)
+                return rc;
+
+        return nf_conntrack_hash_resize(hashsize);
+}
 EXPORT_SYMBOL_GPL(nf_conntrack_set_hashsize);
 
 module_param_call(hashsize, nf_conntrack_set_hashsize, param_get_uint,
@@ -1733,7 +1728,7 @@ int nf_conntrack_init_start(void)
 
         nf_conntrack_cachep = kmem_cache_create("nf_conntrack",
                                                 sizeof(struct nf_conn), 0,
-                                                SLAB_DESTROY_BY_RCU, NULL);
+                                                SLAB_DESTROY_BY_RCU | SLAB_HWCACHE_ALIGN, NULL);
         if (!nf_conntrack_cachep)
                 goto err_cachep;
 
@@ -1773,11 +1768,6 @@ int nf_conntrack_init_start(void)
         if (ret < 0)
                 goto err_seqadj;
 
-#ifdef CONFIG_NF_CONNTRACK_ZONES
-        ret = nf_ct_extend_register(&nf_ct_zone_extend);
-        if (ret < 0)
-                goto err_extend;
-#endif
         ret = nf_conntrack_proto_init();
         if (ret < 0)
                 goto err_proto;
@@ -1793,10 +1783,6 @@ int nf_conntrack_init_start(void)
         return 0;
 
 err_proto:
-#ifdef CONFIG_NF_CONNTRACK_ZONES
-        nf_ct_extend_unregister(&nf_ct_zone_extend);
-err_extend:
-#endif
         nf_conntrack_seqadj_fini();
 err_seqadj:
         nf_conntrack_labels_fini();
diff --git a/net/netfilter/nf_conntrack_helper.c b/net/netfilter/nf_conntrack_helper.c
index 196cb39649e1..3a1a88b9bafa 100644
--- a/net/netfilter/nf_conntrack_helper.c
+++ b/net/netfilter/nf_conntrack_helper.c
@@ -389,11 +389,38 @@ static void __nf_conntrack_helper_unregister(struct nf_conntrack_helper *me,
                                              struct net *net)
 {
         struct nf_conntrack_tuple_hash *h;
+        const struct hlist_nulls_node *nn;
+        int cpu;
+
+        /* Get rid of expecteds, set helpers to NULL. */
+        for_each_possible_cpu(cpu) {
+                struct ct_pcpu *pcpu = per_cpu_ptr(net->ct.pcpu_lists, cpu);
+
+                spin_lock_bh(&pcpu->lock);
+                hlist_nulls_for_each_entry(h, nn, &pcpu->unconfirmed, hnnode)
+                        unhelp(h, me);
+                spin_unlock_bh(&pcpu->lock);
+        }
+}
+
+void nf_conntrack_helper_unregister(struct nf_conntrack_helper *me)
+{
+        struct nf_conntrack_tuple_hash *h;
         struct nf_conntrack_expect *exp;
         const struct hlist_node *next;
         const struct hlist_nulls_node *nn;
+        struct net *net;
         unsigned int i;
-        int cpu;
+
+        mutex_lock(&nf_ct_helper_mutex);
+        hlist_del_rcu(&me->hnode);
+        nf_ct_helper_count--;
+        mutex_unlock(&nf_ct_helper_mutex);
+
+        /* Make sure every nothing is still using the helper unless its a
+         * connection in the hash.
+         */
+        synchronize_rcu();
 
         /* Get rid of expectations */
         spin_lock_bh(&nf_conntrack_expect_lock);
@@ -413,15 +440,11 @@ static void __nf_conntrack_helper_unregister(struct nf_conntrack_helper *me,
         }
         spin_unlock_bh(&nf_conntrack_expect_lock);
 
-        /* Get rid of expecteds, set helpers to NULL. */
-        for_each_possible_cpu(cpu) {
-                struct ct_pcpu *pcpu = per_cpu_ptr(net->ct.pcpu_lists, cpu);
+        rtnl_lock();
+        for_each_net(net)
+                __nf_conntrack_helper_unregister(me, net);
+        rtnl_unlock();
 
-                spin_lock_bh(&pcpu->lock);
-                hlist_nulls_for_each_entry(h, nn, &pcpu->unconfirmed, hnnode)
-                        unhelp(h, me);
-                spin_unlock_bh(&pcpu->lock);
-        }
         local_bh_disable();
         for (i = 0; i < nf_conntrack_htable_size; i++) {
                 nf_conntrack_lock(&nf_conntrack_locks[i % CONNTRACK_LOCKS]);
@@ -433,26 +456,6 @@ static void __nf_conntrack_helper_unregister(struct nf_conntrack_helper *me,
         }
         local_bh_enable();
 }
-
-void nf_conntrack_helper_unregister(struct nf_conntrack_helper *me)
-{
-        struct net *net;
-
-        mutex_lock(&nf_ct_helper_mutex);
-        hlist_del_rcu(&me->hnode);
-        nf_ct_helper_count--;
-        mutex_unlock(&nf_ct_helper_mutex);
-
-        /* Make sure every nothing is still using the helper unless its a
-         * connection in the hash.
-         */
-        synchronize_rcu();
-
-        rtnl_lock();
-        for_each_net(net)
-                __nf_conntrack_helper_unregister(me, net);
-        rtnl_unlock();
-}
 EXPORT_SYMBOL_GPL(nf_conntrack_helper_unregister);
 
 static struct nf_ct_ext_type helper_extend __read_mostly = {
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index c026c472ea80..2aaa188ee961 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -434,8 +434,29 @@ static void nf_conntrack_standalone_fini_proc(struct net *net)
 
 #ifdef CONFIG_SYSCTL
 /* Log invalid packets of a given protocol */
-static int log_invalid_proto_min = 0;
-static int log_invalid_proto_max = 255;
+static int log_invalid_proto_min __read_mostly;
+static int log_invalid_proto_max __read_mostly = 255;
+
+/* size the user *wants to set */
+static unsigned int nf_conntrack_htable_size_user __read_mostly;
+
+static int
+nf_conntrack_hash_sysctl(struct ctl_table *table, int write,
+                         void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+        int ret;
+
+        ret = proc_dointvec(table, write, buffer, lenp, ppos);
+        if (ret < 0 || !write)
+                return ret;
+
+        /* update ret, we might not be able to satisfy request */
+        ret = nf_conntrack_hash_resize(nf_conntrack_htable_size_user);
+
+        /* update it to the actual value used by conntrack */
+        nf_conntrack_htable_size_user = nf_conntrack_htable_size;
+        return ret;
+}
 
 static struct ctl_table_header *nf_ct_netfilter_header;
 
@@ -456,10 +477,10 @@ static struct ctl_table nf_ct_sysctl_table[] = {
         },
         {
                 .procname       = "nf_conntrack_buckets",
-                .data           = &nf_conntrack_htable_size,
+                .data           = &nf_conntrack_htable_size_user,
                 .maxlen         = sizeof(unsigned int),
-                .mode           = 0444,
-                .proc_handler   = proc_dointvec,
+                .mode           = 0644,
+                .proc_handler   = nf_conntrack_hash_sysctl,
         },
         {
                 .procname       = "nf_conntrack_checksum",
@@ -515,6 +536,9 @@ static int nf_conntrack_standalone_init_sysctl(struct net *net)
         if (net->user_ns != &init_user_ns)
                 table[0].procname = NULL;
 
+        if (!net_eq(&init_net, net))
+                table[2].mode = 0444;
+
         net->ct.sysctl_header = register_net_sysctl(net, "net/netfilter", table);
         if (!net->ct.sysctl_header)
                 goto out_unregister_netfilter;
@@ -604,6 +628,8 @@ static int __init nf_conntrack_standalone_init(void)
                 ret = -ENOMEM;
                 goto out_sysctl;
         }
+
+        nf_conntrack_htable_size_user = nf_conntrack_htable_size;
 #endif
 
         ret = register_pernet_subsys(&nf_conntrack_net_ops);
diff --git a/net/netfilter/nf_log.c b/net/netfilter/nf_log.c
index a5d41dfa9f05..aa5847a16713 100644
--- a/net/netfilter/nf_log.c
+++ b/net/netfilter/nf_log.c
@@ -159,6 +159,20 @@ int nf_logger_find_get(int pf, enum nf_log_type type)
         struct nf_logger *logger;
         int ret = -ENOENT;
 
+        if (pf == NFPROTO_INET) {
+                ret = nf_logger_find_get(NFPROTO_IPV4, type);
+                if (ret < 0)
+                        return ret;
+
+                ret = nf_logger_find_get(NFPROTO_IPV6, type);
+                if (ret < 0) {
+                        nf_logger_put(NFPROTO_IPV4, type);
+                        return ret;
+                }
+
+                return 0;
+        }
+
         if (rcu_access_pointer(loggers[pf][type]) == NULL)
                 request_module("nf-logger-%u-%u", pf, type);
 
@@ -167,7 +181,7 @@ int nf_logger_find_get(int pf, enum nf_log_type type)
         if (logger == NULL)
                 goto out;
 
-        if (logger && try_module_get(logger->me))
+        if (try_module_get(logger->me))
                 ret = 0;
 out:
         rcu_read_unlock();
@@ -179,6 +193,12 @@ void nf_logger_put(int pf, enum nf_log_type type)
 {
         struct nf_logger *logger;
 
+        if (pf == NFPROTO_INET) {
+                nf_logger_put(NFPROTO_IPV4, type);
+                nf_logger_put(NFPROTO_IPV6, type);
+                return;
+        }
+
         BUG_ON(loggers[pf][type] == NULL);
 
         rcu_read_lock();
@@ -398,16 +418,17 @@ static int nf_log_proc_dostring(struct ctl_table *table, int write,
 {
         const struct nf_logger *logger;
         char buf[NFLOGGER_NAME_LEN];
-        size_t size = *lenp;
         int r = 0;
         int tindex = (unsigned long)table->extra1;
         struct net *net = current->nsproxy->net_ns;
 
         if (write) {
-                if (size > sizeof(buf))
-                        size = sizeof(buf);
-                if (copy_from_user(buf, buffer, size))
-                        return -EFAULT;
+                struct ctl_table tmp = *table;
+
+                tmp.data = buf;
+                r = proc_dostring(&tmp, write, buffer, lenp, ppos);
+                if (r)
+                        return r;
 
                 if (!strcmp(buf, "NONE")) {
                         nf_log_unbind_pf(net, tindex);
diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index 2c881871db38..18b7f8578ee0 100644
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -131,29 +131,8 @@ static void nft_trans_destroy(struct nft_trans *trans)
         kfree(trans);
 }
 
-static int nft_register_basechain(struct nft_base_chain *basechain,
-                                  unsigned int hook_nops)
-{
-        struct net *net = read_pnet(&basechain->pnet);
-
-        if (basechain->flags & NFT_BASECHAIN_DISABLED)
-                return 0;
-
-        return nf_register_net_hooks(net, basechain->ops, hook_nops);
-}
-
-static void nft_unregister_basechain(struct nft_base_chain *basechain,
-                                     unsigned int hook_nops)
-{
-        struct net *net = read_pnet(&basechain->pnet);
-
-        if (basechain->flags & NFT_BASECHAIN_DISABLED)
-                return;
-
-        nf_unregister_net_hooks(net, basechain->ops, hook_nops);
-}
-
-static int nf_tables_register_hooks(const struct nft_table *table,
+static int nf_tables_register_hooks(struct net *net,
+                                    const struct nft_table *table,
                                     struct nft_chain *chain,
                                     unsigned int hook_nops)
 {
@@ -161,10 +140,12 @@ static int nf_tables_register_hooks(const struct nft_table *table,
             !(chain->flags & NFT_BASE_CHAIN))
                 return 0;
 
-        return nft_register_basechain(nft_base_chain(chain), hook_nops);
+        return nf_register_net_hooks(net, nft_base_chain(chain)->ops,
+                                     hook_nops);
 }
 
-static void nf_tables_unregister_hooks(const struct nft_table *table,
+static void nf_tables_unregister_hooks(struct net *net,
+                                       const struct nft_table *table,
                                        struct nft_chain *chain,
                                        unsigned int hook_nops)
 {
@@ -172,12 +153,9 @@ static void nf_tables_unregister_hooks(const struct nft_table *table,
             !(chain->flags & NFT_BASE_CHAIN))
                 return;
 
-        nft_unregister_basechain(nft_base_chain(chain), hook_nops);
+        nf_unregister_net_hooks(net, nft_base_chain(chain)->ops, hook_nops);
 }
 
-/* Internal table flags */
-#define NFT_TABLE_INACTIVE      (1 << 15)
-
 static int nft_trans_table_add(struct nft_ctx *ctx, int msg_type)
 {
         struct nft_trans *trans;
@@ -187,7 +165,7 @@ static int nft_trans_table_add(struct nft_ctx *ctx, int msg_type)
                 return -ENOMEM;
 
         if (msg_type == NFT_MSG_NEWTABLE)
-                ctx->table->flags |= NFT_TABLE_INACTIVE;
+                nft_activate_next(ctx->net, ctx->table);
 
         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
         return 0;
@@ -201,7 +179,7 @@ static int nft_deltable(struct nft_ctx *ctx)
         if (err < 0)
                 return err;
 
-        list_del_rcu(&ctx->table->list);
+        nft_deactivate_next(ctx->net, ctx->table);
         return err;
 }
 
@@ -214,7 +192,7 @@ static int nft_trans_chain_add(struct nft_ctx *ctx, int msg_type)
                 return -ENOMEM;
 
         if (msg_type == NFT_MSG_NEWCHAIN)
-                ctx->chain->flags |= NFT_CHAIN_INACTIVE;
+                nft_activate_next(ctx->net, ctx->chain);
 
         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
         return 0;
@@ -229,47 +207,17 @@ static int nft_delchain(struct nft_ctx *ctx)
                 return err;
 
         ctx->table->use--;
-        list_del_rcu(&ctx->chain->list);
+        nft_deactivate_next(ctx->net, ctx->chain);
 
         return err;
 }
 
-static inline bool
-nft_rule_is_active(struct net *net, const struct nft_rule *rule)
-{
-        return (rule->genmask & nft_genmask_cur(net)) == 0;
-}
-
-static inline int
-nft_rule_is_active_next(struct net *net, const struct nft_rule *rule)
-{
-        return (rule->genmask & nft_genmask_next(net)) == 0;
-}
-
-static inline void
-nft_rule_activate_next(struct net *net, struct nft_rule *rule)
-{
-        /* Now inactive, will be active in the future */
-        rule->genmask = nft_genmask_cur(net);
-}
-
-static inline void
-nft_rule_deactivate_next(struct net *net, struct nft_rule *rule)
-{
-        rule->genmask = nft_genmask_next(net);
-}
-
-static inline void nft_rule_clear(struct net *net, struct nft_rule *rule)
-{
-        rule->genmask &= ~nft_genmask_next(net);
-}
-
 static int
 nf_tables_delrule_deactivate(struct nft_ctx *ctx, struct nft_rule *rule)
 {
         /* You cannot delete the same rule twice */
-        if (nft_rule_is_active_next(ctx->net, rule)) {
-                nft_rule_deactivate_next(ctx->net, rule);
+        if (nft_is_active_next(ctx->net, rule)) {
+                nft_deactivate_next(ctx->net, rule);
                 ctx->chain->use--;
                 return 0;
         }
@@ -322,9 +270,6 @@ static int nft_delrule_by_chain(struct nft_ctx *ctx)
         return 0;
 }
 
-/* Internal set flag */
-#define NFT_SET_INACTIVE        (1 << 15)
-
 static int nft_trans_set_add(struct nft_ctx *ctx, int msg_type,
                              struct nft_set *set)
 {
@@ -337,7 +282,7 @@ static int nft_trans_set_add(struct nft_ctx *ctx, int msg_type,
         if (msg_type == NFT_MSG_NEWSET && ctx->nla[NFTA_SET_ID] != NULL) {
                 nft_trans_set_id(trans) =
                         ntohl(nla_get_be32(ctx->nla[NFTA_SET_ID]));
-                set->flags |= NFT_SET_INACTIVE;
+                nft_activate_next(ctx->net, set);
         }
         nft_trans_set(trans) = set;
         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
@@ -353,7 +298,7 @@ static int nft_delset(struct nft_ctx *ctx, struct nft_set *set)
         if (err < 0)
                 return err;
 
-        list_del_rcu(&set->list);
+        nft_deactivate_next(ctx->net, set);
         ctx->table->use--;
 
         return err;
@@ -364,26 +309,29 @@ static int nft_delset(struct nft_ctx *ctx, struct nft_set *set)
  */
 
 static struct nft_table *nft_table_lookup(const struct nft_af_info *afi,
-                                          const struct nlattr *nla)
+                                          const struct nlattr *nla,
+                                          u8 genmask)
 {
         struct nft_table *table;
 
         list_for_each_entry(table, &afi->tables, list) {
-                if (!nla_strcmp(nla, table->name))
+                if (!nla_strcmp(nla, table->name) &&
+                    nft_active_genmask(table, genmask))
                         return table;
         }
         return NULL;
 }
 
 static struct nft_table *nf_tables_table_lookup(const struct nft_af_info *afi,
-                                                const struct nlattr *nla)
+                                                const struct nlattr *nla,
+                                                u8 genmask)
 {
         struct nft_table *table;
 
         if (nla == NULL)
                 return ERR_PTR(-EINVAL);
 
-        table = nft_table_lookup(afi, nla);
+        table = nft_table_lookup(afi, nla, genmask);
         if (table != NULL)
                 return table;
 
@@ -524,6 +472,8 @@ static int nf_tables_dump_tables(struct sk_buff *skb,
                         if (idx > s_idx)
                                 memset(&cb->args[1], 0,
                                        sizeof(cb->args) - sizeof(cb->args[0]));
+                        if (!nft_is_active(net, table))
+                                continue;
                         if (nf_tables_fill_table_info(skb, net,
                                                       NETLINK_CB(cb->skb).portid,
                                                       cb->nlh->nlmsg_seq,
@@ -548,6 +498,7 @@ static int nf_tables_gettable(struct net *net, struct sock *nlsk,
                               const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_cur(net);
         const struct nft_af_info *afi;
         const struct nft_table *table;
         struct sk_buff *skb2;
@@ -565,11 +516,9 @@ static int nf_tables_gettable(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_TABLE_NAME]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_TABLE_NAME], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
-        if (table->flags & NFT_TABLE_INACTIVE)
-                return -ENOENT;
 
         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
         if (!skb2)
@@ -588,17 +537,21 @@ err:
         return err;
 }
 
-static int nf_tables_table_enable(const struct nft_af_info *afi,
+static int nf_tables_table_enable(struct net *net,
+                                  const struct nft_af_info *afi,
                                   struct nft_table *table)
 {
         struct nft_chain *chain;
         int err, i = 0;
 
         list_for_each_entry(chain, &table->chains, list) {
+                if (!nft_is_active_next(net, chain))
+                        continue;
                 if (!(chain->flags & NFT_BASE_CHAIN))
                         continue;
 
-                err = nft_register_basechain(nft_base_chain(chain), afi->nops);
+                err = nf_register_net_hooks(net, nft_base_chain(chain)->ops,
+                                            afi->nops);
                 if (err < 0)
                         goto err;
 
@@ -607,26 +560,34 @@ static int nf_tables_table_enable(const struct nft_af_info *afi,
         return 0;
 err:
         list_for_each_entry(chain, &table->chains, list) {
+                if (!nft_is_active_next(net, chain))
+                        continue;
                 if (!(chain->flags & NFT_BASE_CHAIN))
                         continue;
 
                 if (i-- <= 0)
                         break;
 
-                nft_unregister_basechain(nft_base_chain(chain), afi->nops);
+                nf_unregister_net_hooks(net, nft_base_chain(chain)->ops,
+                                        afi->nops);
         }
         return err;
 }
 
-static void nf_tables_table_disable(const struct nft_af_info *afi,
+static void nf_tables_table_disable(struct net *net,
+                                    const struct nft_af_info *afi,
                                     struct nft_table *table)
 {
         struct nft_chain *chain;
 
         list_for_each_entry(chain, &table->chains, list) {
-                if (chain->flags & NFT_BASE_CHAIN)
-                        nft_unregister_basechain(nft_base_chain(chain),
-                                                 afi->nops);
+                if (!nft_is_active_next(net, chain))
+                        continue;
+                if (!(chain->flags & NFT_BASE_CHAIN))
+                        continue;
+
+                nf_unregister_net_hooks(net, nft_base_chain(chain)->ops,
+                                        afi->nops);
         }
 }
 
@@ -656,7 +617,7 @@ static int nf_tables_updtable(struct nft_ctx *ctx)
                 nft_trans_table_enable(trans) = false;
         } else if (!(flags & NFT_TABLE_F_DORMANT) &&
                    ctx->table->flags & NFT_TABLE_F_DORMANT) {
-                ret = nf_tables_table_enable(ctx->afi, ctx->table);
+                ret = nf_tables_table_enable(ctx->net, ctx->afi, ctx->table);
                 if (ret >= 0) {
                         ctx->table->flags &= ~NFT_TABLE_F_DORMANT;
                         nft_trans_table_enable(trans) = true;
@@ -678,6 +639,7 @@ static int nf_tables_newtable(struct net *net, struct sock *nlsk,
                               const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_next(net);
         const struct nlattr *name;
         struct nft_af_info *afi;
         struct nft_table *table;
@@ -691,7 +653,7 @@ static int nf_tables_newtable(struct net *net, struct sock *nlsk,
                 return PTR_ERR(afi);
 
         name = nla[NFTA_TABLE_NAME];
-        table = nf_tables_table_lookup(afi, name);
+        table = nf_tables_table_lookup(afi, name, genmask);
         if (IS_ERR(table)) {
                 if (PTR_ERR(table) != -ENOENT)
                         return PTR_ERR(table);
@@ -699,8 +661,6 @@ static int nf_tables_newtable(struct net *net, struct sock *nlsk,
         }
 
         if (table != NULL) {
-                if (table->flags & NFT_TABLE_INACTIVE)
-                        return -ENOENT;
                 if (nlh->nlmsg_flags & NLM_F_EXCL)
                         return -EEXIST;
                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
@@ -752,6 +712,9 @@ static int nft_flush_table(struct nft_ctx *ctx)
         struct nft_set *set, *ns;
 
         list_for_each_entry(chain, &ctx->table->chains, list) {
+                if (!nft_is_active_next(ctx->net, chain))
+                        continue;
+
                 ctx->chain = chain;
 
                 err = nft_delrule_by_chain(ctx);
@@ -760,6 +723,9 @@ static int nft_flush_table(struct nft_ctx *ctx)
         }
 
         list_for_each_entry_safe(set, ns, &ctx->table->sets, list) {
+                if (!nft_is_active_next(ctx->net, set))
+                        continue;
+
                 if (set->flags & NFT_SET_ANONYMOUS &&
                     !list_empty(&set->bindings))
                         continue;
@@ -770,6 +736,9 @@ static int nft_flush_table(struct nft_ctx *ctx)
         }
 
         list_for_each_entry_safe(chain, nc, &ctx->table->chains, list) {
+                if (!nft_is_active_next(ctx->net, chain))
+                        continue;
+
                 ctx->chain = chain;
 
                 err = nft_delchain(ctx);
@@ -795,6 +764,9 @@ static int nft_flush(struct nft_ctx *ctx, int family)
 
                 ctx->afi = afi;
                 list_for_each_entry_safe(table, nt, &afi->tables, list) {
+                        if (!nft_is_active_next(ctx->net, table))
+                                continue;
+
                         if (nla[NFTA_TABLE_NAME] &&
                             nla_strcmp(nla[NFTA_TABLE_NAME], table->name) != 0)
                                 continue;
@@ -815,6 +787,7 @@ static int nf_tables_deltable(struct net *net, struct sock *nlsk,
                               const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_next(net);
         struct nft_af_info *afi;
         struct nft_table *table;
         int family = nfmsg->nfgen_family;
@@ -828,7 +801,7 @@ static int nf_tables_deltable(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_TABLE_NAME]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_TABLE_NAME], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
 
@@ -875,12 +848,14 @@ EXPORT_SYMBOL_GPL(nft_unregister_chain_type);
  */
 
 static struct nft_chain *
-nf_tables_chain_lookup_byhandle(const struct nft_table *table, u64 handle)
+nf_tables_chain_lookup_byhandle(const struct nft_table *table, u64 handle,
+                                u8 genmask)
 {
         struct nft_chain *chain;
 
         list_for_each_entry(chain, &table->chains, list) {
-                if (chain->handle == handle)
+                if (chain->handle == handle &&
+                    nft_active_genmask(chain, genmask))
                         return chain;
         }
 
@@ -888,7 +863,8 @@ nf_tables_chain_lookup_byhandle(const struct nft_table *table, u64 handle)
 }
 
 static struct nft_chain *nf_tables_chain_lookup(const struct nft_table *table,
-                                                const struct nlattr *nla)
+                                                const struct nlattr *nla,
+                                                u8 genmask)
 {
         struct nft_chain *chain;
 
@@ -896,7 +872,8 @@ static struct nft_chain *nf_tables_chain_lookup(const struct nft_table *table,
                 return ERR_PTR(-EINVAL);
 
         list_for_each_entry(chain, &table->chains, list) {
-                if (!nla_strcmp(nla, chain->name))
+                if (!nla_strcmp(nla, chain->name) &&
+                    nft_active_genmask(chain, genmask))
                         return chain;
         }
 
@@ -1079,6 +1056,8 @@ static int nf_tables_dump_chains(struct sk_buff *skb,
                                 if (idx > s_idx)
                                         memset(&cb->args[1], 0,
                                                sizeof(cb->args) - sizeof(cb->args[0]));
+                                if (!nft_is_active(net, chain))
+                                        continue;
                                 if (nf_tables_fill_chain_info(skb, net,
                                                               NETLINK_CB(cb->skb).portid,
                                                               cb->nlh->nlmsg_seq,
@@ -1104,6 +1083,7 @@ static int nf_tables_getchain(struct net *net, struct sock *nlsk,
                               const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_cur(net);
         const struct nft_af_info *afi;
         const struct nft_table *table;
         const struct nft_chain *chain;
@@ -1122,17 +1102,13 @@ static int nf_tables_getchain(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
-        if (table->flags & NFT_TABLE_INACTIVE)
-                return -ENOENT;
 
-        chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME]);
+        chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask);
         if (IS_ERR(chain))
                 return PTR_ERR(chain);
-        if (chain->flags & NFT_CHAIN_INACTIVE)
-                return -ENOENT;
 
         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
         if (!skb2)
@@ -1231,6 +1207,7 @@ static int nf_tables_newchain(struct net *net, struct sock *nlsk,
         struct nft_chain *chain;
         struct nft_base_chain *basechain = NULL;
         struct nlattr *ha[NFTA_HOOK_MAX + 1];
+        u8 genmask = nft_genmask_next(net);
         int family = nfmsg->nfgen_family;
         struct net_device *dev = NULL;
         u8 policy = NF_ACCEPT;
@@ -1247,7 +1224,7 @@ static int nf_tables_newchain(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
 
@@ -1256,11 +1233,11 @@ static int nf_tables_newchain(struct net *net, struct sock *nlsk,
 
         if (nla[NFTA_CHAIN_HANDLE]) {
                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_CHAIN_HANDLE]));
-                chain = nf_tables_chain_lookup_byhandle(table, handle);
+                chain = nf_tables_chain_lookup_byhandle(table, handle, genmask);
                 if (IS_ERR(chain))
                         return PTR_ERR(chain);
         } else {
-                chain = nf_tables_chain_lookup(table, name);
+                chain = nf_tables_chain_lookup(table, name, genmask);
                 if (IS_ERR(chain)) {
                         if (PTR_ERR(chain) != -ENOENT)
                                 return PTR_ERR(chain);
@@ -1291,16 +1268,20 @@ static int nf_tables_newchain(struct net *net, struct sock *nlsk,
                 struct nft_stats *stats = NULL;
                 struct nft_trans *trans;
 
-                if (chain->flags & NFT_CHAIN_INACTIVE)
-                        return -ENOENT;
                 if (nlh->nlmsg_flags & NLM_F_EXCL)
                         return -EEXIST;
                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
                         return -EOPNOTSUPP;
 
-                if (nla[NFTA_CHAIN_HANDLE] && name &&
-                    !IS_ERR(nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME])))
-                        return -EEXIST;
+                if (nla[NFTA_CHAIN_HANDLE] && name) {
+                        struct nft_chain *chain2;
+
+                        chain2 = nf_tables_chain_lookup(table,
+                                                        nla[NFTA_CHAIN_NAME],
+                                                        genmask);
+                        if (IS_ERR(chain2))
+                                return PTR_ERR(chain2);
+                }
 
                 if (nla[NFTA_CHAIN_COUNTERS]) {
                         if (!(chain->flags & NFT_BASE_CHAIN))
@@ -1455,7 +1436,7 @@ static int nf_tables_newchain(struct net *net, struct sock *nlsk,
         chain->table = table;
         nla_strlcpy(chain->name, name, NFT_CHAIN_MAXNAMELEN);
 
-        err = nf_tables_register_hooks(table, chain, afi->nops);
+        err = nf_tables_register_hooks(net, table, chain, afi->nops);
         if (err < 0)
                 goto err1;
 
@@ -1468,7 +1449,7 @@ static int nf_tables_newchain(struct net *net, struct sock *nlsk,
         list_add_tail_rcu(&chain->list, &table->chains);
         return 0;
 err2:
-        nf_tables_unregister_hooks(table, chain, afi->nops);
+        nf_tables_unregister_hooks(net, table, chain, afi->nops);
 err1:
         nf_tables_chain_destroy(chain);
         return err;
@@ -1479,6 +1460,7 @@ static int nf_tables_delchain(struct net *net, struct sock *nlsk,
                               const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_next(net);
         struct nft_af_info *afi;
         struct nft_table *table;
         struct nft_chain *chain;
@@ -1489,11 +1471,11 @@ static int nf_tables_delchain(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
 
-        chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME]);
+        chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask);
         if (IS_ERR(chain))
                 return PTR_ERR(chain);
         if (chain->use > 0)
@@ -1898,7 +1880,7 @@ static int nf_tables_dump_rules(struct sk_buff *skb,
                 list_for_each_entry_rcu(table, &afi->tables, list) {
                         list_for_each_entry_rcu(chain, &table->chains, list) {
                                 list_for_each_entry_rcu(rule, &chain->rules, list) {
-                                        if (!nft_rule_is_active(net, rule))
+                                        if (!nft_is_active(net, rule))
                                                 goto cont;
                                         if (idx < s_idx)
                                                 goto cont;
@@ -1931,6 +1913,7 @@ static int nf_tables_getrule(struct net *net, struct sock *nlsk,
                              const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_cur(net);
         const struct nft_af_info *afi;
         const struct nft_table *table;
         const struct nft_chain *chain;
@@ -1950,17 +1933,13 @@ static int nf_tables_getrule(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
-        if (table->flags & NFT_TABLE_INACTIVE)
-                return -ENOENT;
 
-        chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN]);
+        chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask);
         if (IS_ERR(chain))
                 return PTR_ERR(chain);
-        if (chain->flags & NFT_CHAIN_INACTIVE)
-                return -ENOENT;
 
         rule = nf_tables_rule_lookup(chain, nla[NFTA_RULE_HANDLE]);
         if (IS_ERR(rule))
@@ -2009,6 +1988,7 @@ static int nf_tables_newrule(struct net *net, struct sock *nlsk,
                              const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_next(net);
         struct nft_af_info *afi;
         struct nft_table *table;
         struct nft_chain *chain;
@@ -2029,11 +2009,11 @@ static int nf_tables_newrule(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
 
-        chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN]);
+        chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask);
         if (IS_ERR(chain))
                 return PTR_ERR(chain);
 
@@ -2102,7 +2082,7 @@ static int nf_tables_newrule(struct net *net, struct sock *nlsk,
         if (rule == NULL)
                 goto err1;
 
-        nft_rule_activate_next(net, rule);
+        nft_activate_next(net, rule);
 
         rule->handle = handle;
         rule->dlen   = size;
@@ -2124,14 +2104,14 @@ static int nf_tables_newrule(struct net *net, struct sock *nlsk,
         }
 
         if (nlh->nlmsg_flags & NLM_F_REPLACE) {
-                if (nft_rule_is_active_next(net, old_rule)) {
+                if (nft_is_active_next(net, old_rule)) {
                         trans = nft_trans_rule_add(&ctx, NFT_MSG_DELRULE,
                                                    old_rule);
                         if (trans == NULL) {
                                 err = -ENOMEM;
                                 goto err2;
                         }
-                        nft_rule_deactivate_next(net, old_rule);
+                        nft_deactivate_next(net, old_rule);
                         chain->use--;
                         list_add_tail_rcu(&rule->list, &old_rule->list);
                 } else {
@@ -2174,6 +2154,7 @@ static int nf_tables_delrule(struct net *net, struct sock *nlsk,
                              const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_next(net);
         struct nft_af_info *afi;
         struct nft_table *table;
         struct nft_chain *chain = NULL;
@@ -2185,12 +2166,13 @@ static int nf_tables_delrule(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
 
         if (nla[NFTA_RULE_CHAIN]) {
-                chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN]);
+                chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN],
+                                               genmask);
                 if (IS_ERR(chain))
                         return PTR_ERR(chain);
         }
@@ -2210,6 +2192,9 @@ static int nf_tables_delrule(struct net *net, struct sock *nlsk,
                 }
         } else {
                 list_for_each_entry(chain, &table->chains, list) {
+                        if (!nft_is_active_next(net, chain))
+                                continue;
+
                         ctx.chain = chain;
                         err = nft_delrule_by_chain(&ctx);
                         if (err < 0)
@@ -2339,7 +2324,8 @@ static const struct nla_policy nft_set_desc_policy[NFTA_SET_DESC_MAX + 1] = {
 static int nft_ctx_init_from_setattr(struct nft_ctx *ctx, struct net *net,
                                      const struct sk_buff *skb,
                                      const struct nlmsghdr *nlh,
-                                     const struct nlattr * const nla[])
+                                     const struct nlattr * const nla[],
+                                     u8 genmask)
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
         struct nft_af_info *afi = NULL;
@@ -2355,7 +2341,8 @@ static int nft_ctx_init_from_setattr(struct nft_ctx *ctx, struct net *net,
                 if (afi == NULL)
                         return -EAFNOSUPPORT;
 
-                table = nf_tables_table_lookup(afi, nla[NFTA_SET_TABLE]);
+                table = nf_tables_table_lookup(afi, nla[NFTA_SET_TABLE],
+                                               genmask);
                 if (IS_ERR(table))
                         return PTR_ERR(table);
         }
@@ -2365,7 +2352,7 @@ static int nft_ctx_init_from_setattr(struct nft_ctx *ctx, struct net *net,
 }
 
 struct nft_set *nf_tables_set_lookup(const struct nft_table *table,
-                                     const struct nlattr *nla)
+                                     const struct nlattr *nla, u8 genmask)
 {
         struct nft_set *set;
 
@@ -2373,22 +2360,27 @@ struct nft_set *nf_tables_set_lookup(const struct nft_table *table,
                 return ERR_PTR(-EINVAL);
 
         list_for_each_entry(set, &table->sets, list) {
-                if (!nla_strcmp(nla, set->name))
+                if (!nla_strcmp(nla, set->name) &&
+                    nft_active_genmask(set, genmask))
                         return set;
         }
         return ERR_PTR(-ENOENT);
 }
 
 struct nft_set *nf_tables_set_lookup_byid(const struct net *net,
-                                          const struct nlattr *nla)
+                                          const struct nlattr *nla,
+                                          u8 genmask)
 {
         struct nft_trans *trans;
         u32 id = ntohl(nla_get_be32(nla));
 
         list_for_each_entry(trans, &net->nft.commit_list, list) {
+                struct nft_set *set = nft_trans_set(trans);
+
                 if (trans->msg_type == NFT_MSG_NEWSET &&
-                    id == nft_trans_set_id(trans))
-                        return nft_trans_set(trans);
+                    id == nft_trans_set_id(trans) &&
+                    nft_active_genmask(set, genmask))
+                        return set;
         }
         return ERR_PTR(-ENOENT);
 }
@@ -2413,6 +2405,8 @@ cont:
                 list_for_each_entry(i, &ctx->table->sets, list) {
                         int tmp;
 
+                        if (!nft_is_active_next(ctx->net, set))
+                                continue;
                         if (!sscanf(i->name, name, &tmp))
                                 continue;
                         if (tmp < min || tmp >= min + BITS_PER_BYTE * PAGE_SIZE)
@@ -2432,6 +2426,8 @@ cont:
 
         snprintf(set->name, sizeof(set->name), name, min + n);
         list_for_each_entry(i, &ctx->table->sets, list) {
+                if (!nft_is_active_next(ctx->net, i))
+                        continue;
                 if (!strcmp(set->name, i->name))
                         return -ENFILE;
         }
@@ -2580,6 +2576,8 @@ static int nf_tables_dump_sets(struct sk_buff *skb, struct netlink_callback *cb)
                         list_for_each_entry_rcu(set, &table->sets, list) {
                                 if (idx < s_idx)
                                         goto cont;
+                                if (!nft_is_active(net, set))
+                                        goto cont;
 
                                 ctx_set = *ctx;
                                 ctx_set.table = table;
@@ -2616,6 +2614,7 @@ static int nf_tables_getset(struct net *net, struct sock *nlsk,
                             struct sk_buff *skb, const struct nlmsghdr *nlh,
                             const struct nlattr * const nla[])
 {
+        u8 genmask = nft_genmask_cur(net);
         const struct nft_set *set;
         struct nft_ctx ctx;
         struct sk_buff *skb2;
@@ -2623,7 +2622,7 @@ static int nf_tables_getset(struct net *net, struct sock *nlsk,
         int err;
 
         /* Verify existence before starting dump */
-        err = nft_ctx_init_from_setattr(&ctx, net, skb, nlh, nla);
+        err = nft_ctx_init_from_setattr(&ctx, net, skb, nlh, nla, genmask);
         if (err < 0)
                 return err;
 
@@ -2650,11 +2649,9 @@ static int nf_tables_getset(struct net *net, struct sock *nlsk,
         if (!nla[NFTA_SET_TABLE])
                 return -EINVAL;
 
-        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME]);
+        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask);
         if (IS_ERR(set))
                 return PTR_ERR(set);
-        if (set->flags & NFT_SET_INACTIVE)
-                return -ENOENT;
 
         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
         if (skb2 == NULL)
@@ -2693,6 +2690,7 @@ static int nf_tables_newset(struct net *net, struct sock *nlsk,
                             const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_next(net);
         const struct nft_set_ops *ops;
         struct nft_af_info *afi;
         struct nft_table *table;
@@ -2790,13 +2788,13 @@ static int nf_tables_newset(struct net *net, struct sock *nlsk,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_SET_TABLE]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_SET_TABLE], genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
 
         nft_ctx_init(&ctx, net, skb, nlh, afi, table, NULL, nla);
 
-        set = nf_tables_set_lookup(table, nla[NFTA_SET_NAME]);
+        set = nf_tables_set_lookup(table, nla[NFTA_SET_NAME], genmask);
         if (IS_ERR(set)) {
                 if (PTR_ERR(set) != -ENOENT)
                         return PTR_ERR(set);
@@ -2895,6 +2893,7 @@ static int nf_tables_delset(struct net *net, struct sock *nlsk,
                             const struct nlattr * const nla[])
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
+        u8 genmask = nft_genmask_next(net);
         struct nft_set *set;
         struct nft_ctx ctx;
         int err;
@@ -2904,11 +2903,11 @@ static int nf_tables_delset(struct net *net, struct sock *nlsk,
         if (nla[NFTA_SET_TABLE] == NULL)
                 return -EINVAL;
 
-        err = nft_ctx_init_from_setattr(&ctx, net, skb, nlh, nla);
+        err = nft_ctx_init_from_setattr(&ctx, net, skb, nlh, nla, genmask);
         if (err < 0)
                 return err;
 
-        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME]);
+        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask);
         if (IS_ERR(set))
                 return PTR_ERR(set);
         if (!list_empty(&set->bindings))
@@ -2973,7 +2972,7 @@ void nf_tables_unbind_set(const struct nft_ctx *ctx, struct nft_set *set,
         list_del_rcu(&binding->list);
 
         if (list_empty(&set->bindings) && set->flags & NFT_SET_ANONYMOUS &&
-            !(set->flags & NFT_SET_INACTIVE))
+            nft_is_active(ctx->net, set))
                 nf_tables_set_destroy(ctx, set);
 }
 
@@ -3029,7 +3028,8 @@ static const struct nla_policy nft_set_elem_list_policy[NFTA_SET_ELEM_LIST_MAX +
 static int nft_ctx_init_from_elemattr(struct nft_ctx *ctx, struct net *net,
                                       const struct sk_buff *skb,
                                       const struct nlmsghdr *nlh,
-                                      const struct nlattr * const nla[])
+                                      const struct nlattr * const nla[],
+                                      u8 genmask)
 {
         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
         struct nft_af_info *afi;
@@ -3039,7 +3039,8 @@ static int nft_ctx_init_from_elemattr(struct nft_ctx *ctx, struct net *net,
         if (IS_ERR(afi))
                 return PTR_ERR(afi);
 
-        table = nf_tables_table_lookup(afi, nla[NFTA_SET_ELEM_LIST_TABLE]);
+        table = nf_tables_table_lookup(afi, nla[NFTA_SET_ELEM_LIST_TABLE],
+                                       genmask);
         if (IS_ERR(table))
                 return PTR_ERR(table);
 
@@ -3136,6 +3137,7 @@ static int nf_tables_dump_setelem(const struct nft_ctx *ctx,
 static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb)
 {
         struct net *net = sock_net(skb->sk);
+        u8 genmask = nft_genmask_cur(net);
         const struct nft_set *set;
         struct nft_set_dump_args args;
         struct nft_ctx ctx;
@@ -3152,17 +3154,14 @@ static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb)
                 return err;
 
         err = nft_ctx_init_from_elemattr(&ctx, net, cb->skb, cb->nlh,
-                                         (void *)nla);
+                                         (void *)nla, genmask);
         if (err < 0)
                 return err;
-        if (ctx.table->flags & NFT_TABLE_INACTIVE)
-                return -ENOENT;
 
-        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET]);
+        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET],
+                                   genmask);
         if (IS_ERR(set))
                 return PTR_ERR(set);
-        if (set->flags & NFT_SET_INACTIVE)
-                return -ENOENT;
 
         event  = NFT_MSG_NEWSETELEM;
         event |= NFNL_SUBSYS_NFTABLES << 8;
@@ -3216,21 +3215,19 @@ static int nf_tables_getsetelem(struct net *net, struct sock *nlsk,
                                 struct sk_buff *skb, const struct nlmsghdr *nlh,
                                 const struct nlattr * const nla[])
 {
+        u8 genmask = nft_genmask_cur(net);
         const struct nft_set *set;
         struct nft_ctx ctx;
         int err;
 
-        err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla);
+        err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla, genmask);
         if (err < 0)
                 return err;
-        if (ctx.table->flags & NFT_TABLE_INACTIVE)
-                return -ENOENT;
 
-        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET]);
+        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET],
+                                   genmask);
         if (IS_ERR(set))
                 return PTR_ERR(set);
-        if (set->flags & NFT_SET_INACTIVE)
-                return -ENOENT;
 
         if (nlh->nlmsg_flags & NLM_F_DUMP) {
                 struct netlink_dump_control c = {
@@ -3548,6 +3545,7 @@ static int nf_tables_newsetelem(struct net *net, struct sock *nlsk,
                                 struct sk_buff *skb, const struct nlmsghdr *nlh,
                                 const struct nlattr * const nla[])
 {
+        u8 genmask = nft_genmask_next(net);
         const struct nlattr *attr;
         struct nft_set *set;
         struct nft_ctx ctx;
@@ -3556,15 +3554,17 @@ static int nf_tables_newsetelem(struct net *net, struct sock *nlsk,
         if (nla[NFTA_SET_ELEM_LIST_ELEMENTS] == NULL)
                 return -EINVAL;
 
-        err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla);
+        err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla, genmask);
         if (err < 0)
                 return err;
 
-        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET]);
+        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET],
+                                   genmask);
         if (IS_ERR(set)) {
                 if (nla[NFTA_SET_ELEM_LIST_SET_ID]) {
                         set = nf_tables_set_lookup_byid(net,
-                                        nla[NFTA_SET_ELEM_LIST_SET_ID]);
+                                        nla[NFTA_SET_ELEM_LIST_SET_ID],
+                                        genmask);
                 }
                 if (IS_ERR(set))
                         return PTR_ERR(set);
@@ -3670,6 +3670,7 @@ static int nf_tables_delsetelem(struct net *net, struct sock *nlsk,
                                 struct sk_buff *skb, const struct nlmsghdr *nlh,
                                 const struct nlattr * const nla[])
 {
+        u8 genmask = nft_genmask_next(net);
         const struct nlattr *attr;
         struct nft_set *set;
         struct nft_ctx ctx;
@@ -3678,11 +3679,12 @@ static int nf_tables_delsetelem(struct net *net, struct sock *nlsk,
         if (nla[NFTA_SET_ELEM_LIST_ELEMENTS] == NULL)
                 return -EINVAL;
 
-        err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla);
+        err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla, genmask);
         if (err < 0)
                 return err;
 
-        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET]);
+        set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET],
+                                   genmask);
         if (IS_ERR(set))
                 return PTR_ERR(set);
         if (!list_empty(&set->bindings) && set->flags & NFT_SET_CONSTANT)
@@ -3950,36 +3952,40 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb)
                 case NFT_MSG_NEWTABLE:
                         if (nft_trans_table_update(trans)) {
                                 if (!nft_trans_table_enable(trans)) {
-                                        nf_tables_table_disable(trans->ctx.afi,
+                                        nf_tables_table_disable(net,
+                                                                trans->ctx.afi,
                                                                 trans->ctx.table);
                                         trans->ctx.table->flags |= NFT_TABLE_F_DORMANT;
                                 }
                         } else {
-                                trans->ctx.table->flags &= ~NFT_TABLE_INACTIVE;
+                                nft_clear(net, trans->ctx.table);
                         }
                         nf_tables_table_notify(&trans->ctx, NFT_MSG_NEWTABLE);
                         nft_trans_destroy(trans);
                         break;
                 case NFT_MSG_DELTABLE:
+                        list_del_rcu(&trans->ctx.table->list);
                         nf_tables_table_notify(&trans->ctx, NFT_MSG_DELTABLE);
                         break;
                 case NFT_MSG_NEWCHAIN:
                         if (nft_trans_chain_update(trans))
                                 nft_chain_commit_update(trans);
                         else
-                                trans->ctx.chain->flags &= ~NFT_CHAIN_INACTIVE;
+                                nft_clear(net, trans->ctx.chain);
 
                         nf_tables_chain_notify(&trans->ctx, NFT_MSG_NEWCHAIN);
                         nft_trans_destroy(trans);
                         break;
                 case NFT_MSG_DELCHAIN:
+                        list_del_rcu(&trans->ctx.chain->list);
                         nf_tables_chain_notify(&trans->ctx, NFT_MSG_DELCHAIN);
-                        nf_tables_unregister_hooks(trans->ctx.table,
+                        nf_tables_unregister_hooks(trans->ctx.net,
+                                                   trans->ctx.table,
                                                    trans->ctx.chain,
                                                    trans->ctx.afi->nops);
                         break;
                 case NFT_MSG_NEWRULE:
-                        nft_rule_clear(trans->ctx.net, nft_trans_rule(trans));
+                        nft_clear(trans->ctx.net, nft_trans_rule(trans));
                         nf_tables_rule_notify(&trans->ctx,
                                               nft_trans_rule(trans),
                                               NFT_MSG_NEWRULE);
@@ -3992,7 +3998,7 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb)
                                               NFT_MSG_DELRULE);
                         break;
                 case NFT_MSG_NEWSET:
-                        nft_trans_set(trans)->flags &= ~NFT_SET_INACTIVE;
+                        nft_clear(net, nft_trans_set(trans));
                         /* This avoids hitting -EBUSY when deleting the table
                          * from the transaction.
                          */
@@ -4005,6 +4011,7 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb)
                         nft_trans_destroy(trans);
                         break;
                 case NFT_MSG_DELSET:
+                        list_del_rcu(&nft_trans_set(trans)->list);
                         nf_tables_set_notify(&trans->ctx, nft_trans_set(trans),
                                              NFT_MSG_DELSET, GFP_KERNEL);
                         break;
@@ -4076,7 +4083,8 @@ static int nf_tables_abort(struct net *net, struct sk_buff *skb)
                 case NFT_MSG_NEWTABLE:
                         if (nft_trans_table_update(trans)) {
                                 if (nft_trans_table_enable(trans)) {
-                                        nf_tables_table_disable(trans->ctx.afi,
+                                        nf_tables_table_disable(net,
+                                                                trans->ctx.afi,
                                                                 trans->ctx.table);
                                         trans->ctx.table->flags |= NFT_TABLE_F_DORMANT;
                                 }
@@ -4086,8 +4094,7 @@ static int nf_tables_abort(struct net *net, struct sk_buff *skb)
                         }
                         break;
                 case NFT_MSG_DELTABLE:
-                        list_add_tail_rcu(&trans->ctx.table->list,
-                                          &trans->ctx.afi->tables);
+                        nft_clear(trans->ctx.net, trans->ctx.table);
                         nft_trans_destroy(trans);
                         break;
                 case NFT_MSG_NEWCHAIN:
@@ -4098,15 +4105,15 @@ static int nf_tables_abort(struct net *net, struct sk_buff *skb)
                         } else {
                                 trans->ctx.table->use--;
                                 list_del_rcu(&trans->ctx.chain->list);
-                                nf_tables_unregister_hooks(trans->ctx.table,
+                                nf_tables_unregister_hooks(trans->ctx.net,
+                                                           trans->ctx.table,
                                                            trans->ctx.chain,
                                                            trans->ctx.afi->nops);
                         }
                         break;
                 case NFT_MSG_DELCHAIN:
                         trans->ctx.table->use++;
-                        list_add_tail_rcu(&trans->ctx.chain->list,
-                                          &trans->ctx.table->chains);
+                        nft_clear(trans->ctx.net, trans->ctx.chain);
                         nft_trans_destroy(trans);
                         break;
                 case NFT_MSG_NEWRULE:
@@ -4115,7 +4122,7 @@ static int nf_tables_abort(struct net *net, struct sk_buff *skb)
                         break;
                 case NFT_MSG_DELRULE:
                         trans->ctx.chain->use++;
-                        nft_rule_clear(trans->ctx.net, nft_trans_rule(trans));
+                        nft_clear(trans->ctx.net, nft_trans_rule(trans));
                         nft_trans_destroy(trans);
                         break;
                 case NFT_MSG_NEWSET:
@@ -4124,8 +4131,7 @@ static int nf_tables_abort(struct net *net, struct sk_buff *skb)
                         break;
                 case NFT_MSG_DELSET:
                         trans->ctx.table->use++;
-                        list_add_tail_rcu(&nft_trans_set(trans)->list,
-                                          &trans->ctx.table->sets);
+                        nft_clear(trans->ctx.net, nft_trans_set(trans));
                         nft_trans_destroy(trans);
                         break;
                 case NFT_MSG_NEWSETELEM:
@@ -4272,6 +4278,8 @@ static int nf_tables_check_loops(const struct nft_ctx *ctx,
         }
 
         list_for_each_entry(set, &ctx->table->sets, list) {
+                if (!nft_is_active_next(ctx->net, set))
+                        continue;
                 if (!(set->flags & NFT_SET_MAP) ||
                     set->dtype != NFT_DATA_VERDICT)
                         continue;
@@ -4430,6 +4438,7 @@ static const struct nla_policy nft_verdict_policy[NFTA_VERDICT_MAX + 1] = {
 static int nft_verdict_init(const struct nft_ctx *ctx, struct nft_data *data,
                             struct nft_data_desc *desc, const struct nlattr *nla)
 {
+        u8 genmask = nft_genmask_next(ctx->net);
         struct nlattr *tb[NFTA_VERDICT_MAX + 1];
         struct nft_chain *chain;
         int err;
@@ -4462,7 +4471,7 @@ static int nft_verdict_init(const struct nft_ctx *ctx, struct nft_data *data,
                 if (!tb[NFTA_VERDICT_CHAIN])
                         return -EINVAL;
                 chain = nf_tables_chain_lookup(ctx->table,
-                                               tb[NFTA_VERDICT_CHAIN]);
+                                               tb[NFTA_VERDICT_CHAIN], genmask);
                 if (IS_ERR(chain))
                         return PTR_ERR(chain);
                 if (chain->flags & NFT_BASE_CHAIN)
@@ -4640,7 +4649,7 @@ int __nft_release_basechain(struct nft_ctx *ctx)
 
         BUG_ON(!(ctx->chain->flags & NFT_BASE_CHAIN));
 
-        nf_tables_unregister_hooks(ctx->chain->table, ctx->chain,
+        nf_tables_unregister_hooks(ctx->net, ctx->chain->table, ctx->chain,
                                    ctx->afi->nops);
         list_for_each_entry_safe(rule, nr, &ctx->chain->rules, list) {
                 list_del(&rule->list);
@@ -4669,7 +4678,8 @@ static void __nft_release_afinfo(struct net *net, struct nft_af_info *afi)
 
         list_for_each_entry_safe(table, nt, &afi->tables, list) {
                 list_for_each_entry(chain, &table->chains, list)
-                        nf_tables_unregister_hooks(table, chain, afi->nops);
+                        nf_tables_unregister_hooks(net, table, chain,
+                                                   afi->nops);
                 /* No packets are walking on these chains anymore. */
                 ctx.table = table;
                 list_for_each_entry(chain, &table->chains, list) {
diff --git a/net/netfilter/nfnetlink_log.c b/net/netfilter/nfnetlink_log.c
index 11f81c8385fc..cbcfdfb586a6 100644
--- a/net/netfilter/nfnetlink_log.c
+++ b/net/netfilter/nfnetlink_log.c
@@ -700,10 +700,13 @@ nfulnl_log_packet(struct net *net,
                 break;
 
         case NFULNL_COPY_PACKET:
-                if (inst->copy_range > skb->len)
+                data_len = inst->copy_range;
+                if ((li->u.ulog.flags & NF_LOG_F_COPY_LEN) &&
+                    (li->u.ulog.copy_len < data_len))
+                        data_len = li->u.ulog.copy_len;
+
+                if (data_len > skb->len)
                         data_len = skb->len;
-                else
-                        data_len = inst->copy_range;
 
                 size += nla_total_size(data_len);
                 break;
diff --git a/net/netfilter/nft_dynset.c b/net/netfilter/nft_dynset.c
index 78d4914fb39c..0af26699bf04 100644
--- a/net/netfilter/nft_dynset.c
+++ b/net/netfilter/nft_dynset.c
@@ -103,6 +103,7 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
                            const struct nlattr * const tb[])
 {
         struct nft_dynset *priv = nft_expr_priv(expr);
+        u8 genmask = nft_genmask_next(ctx->net);
         struct nft_set *set;
         u64 timeout;
         int err;
@@ -112,11 +113,13 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
             tb[NFTA_DYNSET_SREG_KEY] == NULL)
                 return -EINVAL;
 
-        set = nf_tables_set_lookup(ctx->table, tb[NFTA_DYNSET_SET_NAME]);
+        set = nf_tables_set_lookup(ctx->table, tb[NFTA_DYNSET_SET_NAME],
+                                   genmask);
         if (IS_ERR(set)) {
                 if (tb[NFTA_DYNSET_SET_ID])
                         set = nf_tables_set_lookup_byid(ctx->net,
-                                                        tb[NFTA_DYNSET_SET_ID]);
+                                                        tb[NFTA_DYNSET_SET_ID],
+                                                        genmask);
                 if (IS_ERR(set))
                         return PTR_ERR(set);
         }
diff --git a/net/netfilter/nft_hash.c b/net/netfilter/nft_hash.c
index f39c53a159eb..ea924816b7b8 100644
--- a/net/netfilter/nft_hash.c
+++ b/net/netfilter/nft_hash.c
@@ -153,9 +153,10 @@ static void *nft_hash_deactivate(const struct nft_set *set,
                                  const struct nft_set_elem *elem)
 {
         struct nft_hash *priv = nft_set_priv(set);
+        struct net *net = read_pnet(&set->pnet);
         struct nft_hash_elem *he;
         struct nft_hash_cmp_arg arg = {
-                .genmask = nft_genmask_next(read_pnet(&set->pnet)),
+                .genmask = nft_genmask_next(net),
                 .set     = set,
                 .key     = elem->key.val.data,
         };
@@ -163,7 +164,8 @@ static void *nft_hash_deactivate(const struct nft_set *set,
         rcu_read_lock();
         he = rhashtable_lookup_fast(&priv->ht, &arg, nft_hash_params);
         if (he != NULL) {
-                if (!nft_set_elem_mark_busy(&he->ext))
+                if (!nft_set_elem_mark_busy(&he->ext) ||
+                    !nft_is_active(net, &he->ext))
                         nft_set_elem_change_active(set, &he->ext);
                 else
                         he = NULL;
diff --git a/net/netfilter/nft_log.c b/net/netfilter/nft_log.c
index 319c22b4bca2..713d66837705 100644
--- a/net/netfilter/nft_log.c
+++ b/net/netfilter/nft_log.c
@@ -52,7 +52,6 @@ static int nft_log_init(const struct nft_ctx *ctx,
         struct nft_log *priv = nft_expr_priv(expr);
         struct nf_loginfo *li = &priv->loginfo;
         const struct nlattr *nla;
-        int ret;
 
         nla = tb[NFTA_LOG_PREFIX];
         if (nla != NULL) {
@@ -97,19 +96,6 @@ static int nft_log_init(const struct nft_ctx *ctx,
                 break;
         }
 
-        if (ctx->afi->family == NFPROTO_INET) {
-                ret = nf_logger_find_get(NFPROTO_IPV4, li->type);
-                if (ret < 0)
-                        return ret;
-
-                ret = nf_logger_find_get(NFPROTO_IPV6, li->type);
-                if (ret < 0) {
-                        nf_logger_put(NFPROTO_IPV4, li->type);
-                        return ret;
-                }
-                return 0;
-        }
-
         return nf_logger_find_get(ctx->afi->family, li->type);
 }
 
@@ -122,12 +108,7 @@ static void nft_log_destroy(const struct nft_ctx *ctx,
         if (priv->prefix != nft_log_null_prefix)
                 kfree(priv->prefix);
 
-        if (ctx->afi->family == NFPROTO_INET) {
-                nf_logger_put(NFPROTO_IPV4, li->type);
-                nf_logger_put(NFPROTO_IPV6, li->type);
-        } else {
-                nf_logger_put(ctx->afi->family, li->type);
-        }
+        nf_logger_put(ctx->afi->family, li->type);
 }
 
 static int nft_log_dump(struct sk_buff *skb, const struct nft_expr *expr)
diff --git a/net/netfilter/nft_lookup.c b/net/netfilter/nft_lookup.c
index b3c31ef8015d..b8d18f598569 100644
--- a/net/netfilter/nft_lookup.c
+++ b/net/netfilter/nft_lookup.c
@@ -22,6 +22,7 @@ struct nft_lookup {
         struct nft_set                  *set;
         enum nft_registers              sreg:8;
         enum nft_registers              dreg:8;
+        bool                            invert;
         struct nft_set_binding          binding;
 };
 
@@ -32,14 +33,20 @@ static void nft_lookup_eval(const struct nft_expr *expr,
         const struct nft_lookup *priv = nft_expr_priv(expr);
         const struct nft_set *set = priv->set;
         const struct nft_set_ext *ext;
+        bool found;
 
-        if (set->ops->lookup(set, &regs->data[priv->sreg], &ext)) {
-                if (set->flags & NFT_SET_MAP)
-                        nft_data_copy(&regs->data[priv->dreg],
-                                      nft_set_ext_data(ext), set->dlen);
+        found = set->ops->lookup(set, &regs->data[priv->sreg], &ext) ^
+                priv->invert;
+
+        if (!found) {
+                regs->verdict.code = NFT_BREAK;
                 return;
         }
-        regs->verdict.code = NFT_BREAK;
+
+        if (found && set->flags & NFT_SET_MAP)
+                nft_data_copy(&regs->data[priv->dreg],
+                              nft_set_ext_data(ext), set->dlen);
+
 }
 
 static const struct nla_policy nft_lookup_policy[NFTA_LOOKUP_MAX + 1] = {
@@ -47,6 +54,7 @@ static const struct nla_policy nft_lookup_policy[NFTA_LOOKUP_MAX + 1] = {
         [NFTA_LOOKUP_SET_ID]    = { .type = NLA_U32 },
         [NFTA_LOOKUP_SREG]      = { .type = NLA_U32 },
         [NFTA_LOOKUP_DREG]      = { .type = NLA_U32 },
+        [NFTA_LOOKUP_FLAGS]     = { .type = NLA_U32 },
 };
 
 static int nft_lookup_init(const struct nft_ctx *ctx,
@@ -54,18 +62,21 @@ static int nft_lookup_init(const struct nft_ctx *ctx,
                            const struct nlattr * const tb[])
 {
         struct nft_lookup *priv = nft_expr_priv(expr);
+        u8 genmask = nft_genmask_next(ctx->net);
         struct nft_set *set;
+        u32 flags;
         int err;
 
         if (tb[NFTA_LOOKUP_SET] == NULL ||
             tb[NFTA_LOOKUP_SREG] == NULL)
                 return -EINVAL;
 
-        set = nf_tables_set_lookup(ctx->table, tb[NFTA_LOOKUP_SET]);
+        set = nf_tables_set_lookup(ctx->table, tb[NFTA_LOOKUP_SET], genmask);
         if (IS_ERR(set)) {
                 if (tb[NFTA_LOOKUP_SET_ID]) {
                         set = nf_tables_set_lookup_byid(ctx->net,
-                                                        tb[NFTA_LOOKUP_SET_ID]);
+                                                        tb[NFTA_LOOKUP_SET_ID],
+                                                        genmask);
                 }
                 if (IS_ERR(set))
                         return PTR_ERR(set);
@@ -79,7 +90,22 @@ static int nft_lookup_init(const struct nft_ctx *ctx,
         if (err < 0)
                 return err;
 
+        if (tb[NFTA_LOOKUP_FLAGS]) {
+                flags = ntohl(nla_get_be32(tb[NFTA_LOOKUP_FLAGS]));
+
+                if (flags & ~NFT_LOOKUP_F_INV)
+                        return -EINVAL;
+
+                if (flags & NFT_LOOKUP_F_INV) {
+                        if (set->flags & NFT_SET_MAP)
+                                return -EINVAL;
+                        priv->invert = true;
+                }
+        }
+
         if (tb[NFTA_LOOKUP_DREG] != NULL) {
+                if (priv->invert)
+                        return -EINVAL;
                 if (!(set->flags & NFT_SET_MAP))
                         return -EINVAL;
 
@@ -112,6 +138,7 @@ static void nft_lookup_destroy(const struct nft_ctx *ctx,
 static int nft_lookup_dump(struct sk_buff *skb, const struct nft_expr *expr)
 {
         const struct nft_lookup *priv = nft_expr_priv(expr);
+        u32 flags = priv->invert ? NFT_LOOKUP_F_INV : 0;
 
         if (nla_put_string(skb, NFTA_LOOKUP_SET, priv->set->name))
                 goto nla_put_failure;
@@ -120,6 +147,8 @@ static int nft_lookup_dump(struct sk_buff *skb, const struct nft_expr *expr)
         if (priv->set->flags & NFT_SET_MAP)
                 if (nft_dump_register(skb, NFTA_LOOKUP_DREG, priv->dreg))
                         goto nla_put_failure;
+        if (nla_put_be32(skb, NFTA_LOOKUP_FLAGS, htonl(flags)))
+                goto nla_put_failure;
         return 0;
 
 nla_put_failure:
diff --git a/net/netfilter/nft_rbtree.c b/net/netfilter/nft_rbtree.c
index 7201d57b5a93..c0f638745adc 100644
--- a/net/netfilter/nft_rbtree.c
+++ b/net/netfilter/nft_rbtree.c
@@ -170,7 +170,7 @@ static void *nft_rbtree_deactivate(const struct nft_set *set,
         const struct nft_rbtree *priv = nft_set_priv(set);
         const struct rb_node *parent = priv->root.rb_node;
         struct nft_rbtree_elem *rbe, *this = elem->priv;
-        u8 genmask = nft_genmask_cur(read_pnet(&set->pnet));
+        u8 genmask = nft_genmask_next(read_pnet(&set->pnet));
         int d;
 
         while (parent != NULL) {
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index 2675d580c490..fe0e2db632c7 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -1460,6 +1460,9 @@ xt_hook_ops_alloc(const struct xt_table *table, nf_hookfn *fn)
         uint8_t hooknum;
         struct nf_hook_ops *ops;
 
+        if (!num_hooks)
+                return ERR_PTR(-EINVAL);
+
         ops = kmalloc(sizeof(*ops) * num_hooks, GFP_KERNEL);
         if (ops == NULL)
                 return ERR_PTR(-ENOMEM);
diff --git a/net/netfilter/xt_NFLOG.c b/net/netfilter/xt_NFLOG.c
index a1fa2c800cb9..018eed7e1ff1 100644
--- a/net/netfilter/xt_NFLOG.c
+++ b/net/netfilter/xt_NFLOG.c
@@ -33,6 +33,9 @@ nflog_tg(struct sk_buff *skb, const struct xt_action_param *par)
         li.u.ulog.group      = info->group;
         li.u.ulog.qthreshold = info->threshold;
 
+        if (info->flags & XT_NFLOG_F_COPY_LEN)
+                li.u.ulog.flags |= NF_LOG_F_COPY_LEN;
+
         nfulnl_log_packet(net, par->family, par->hooknum, skb, par->in,
                           par->out, &li, info->prefix);
         return XT_CONTINUE;
diff --git a/net/netfilter/xt_TRACE.c b/net/netfilter/xt_TRACE.c
index df48967af382..858d189a1303 100644
--- a/net/netfilter/xt_TRACE.c
+++ b/net/netfilter/xt_TRACE.c
@@ -4,12 +4,23 @@
 #include <linux/skbuff.h>
 
 #include <linux/netfilter/x_tables.h>
+#include <net/netfilter/nf_log.h>
 
 MODULE_DESCRIPTION("Xtables: packet flow tracing");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("ipt_TRACE");
 MODULE_ALIAS("ip6t_TRACE");
 
+static int trace_tg_check(const struct xt_tgchk_param *par)
+{
+        return nf_logger_find_get(par->family, NF_LOG_TYPE_LOG);
+}
+
+static void trace_tg_destroy(const struct xt_tgdtor_param *par)
+{
+        nf_logger_put(par->family, NF_LOG_TYPE_LOG);
+}
+
 static unsigned int
 trace_tg(struct sk_buff *skb, const struct xt_action_param *par)
 {
@@ -18,12 +29,14 @@ trace_tg(struct sk_buff *skb, const struct xt_action_param *par)
 }
 
 static struct xt_target trace_tg_reg __read_mostly = {
-        .name       = "TRACE",
-        .revision   = 0,
-        .family     = NFPROTO_UNSPEC,
-        .table      = "raw",
-        .target     = trace_tg,
-        .me         = THIS_MODULE,
+        .name           = "TRACE",
+        .revision       = 0,
+        .family         = NFPROTO_UNSPEC,
+        .table          = "raw",
+        .target         = trace_tg,
+        .checkentry     = trace_tg_check,
+        .destroy        = trace_tg_destroy,
+        .me             = THIS_MODULE,
 };
 
 static int __init trace_tg_init(void)
diff --git a/net/netfilter/xt_owner.c b/net/netfilter/xt_owner.c
index 1302b475abcb..a20e731b5b6c 100644
--- a/net/netfilter/xt_owner.c
+++ b/net/netfilter/xt_owner.c
@@ -21,11 +21,39 @@
 static int owner_check(const struct xt_mtchk_param *par)
 {
         struct xt_owner_match_info *info = par->matchinfo;
+        struct net *net = par->net;
 
-        /* For now only allow adding matches from the initial user namespace */
+        /* Only allow the common case where the userns of the writer
+         * matches the userns of the network namespace.
+         */
         if ((info->match & (XT_OWNER_UID|XT_OWNER_GID)) &&
-            (current_user_ns() != &init_user_ns))
+            (current_user_ns() != net->user_ns))
                 return -EINVAL;
+
+        /* Ensure the uids are valid */
+        if (info->match & XT_OWNER_UID) {
+                kuid_t uid_min = make_kuid(net->user_ns, info->uid_min);
+                kuid_t uid_max = make_kuid(net->user_ns, info->uid_max);
+
+                if (!uid_valid(uid_min) || !uid_valid(uid_max) ||
+                    (info->uid_max < info->uid_min) ||
+                    uid_lt(uid_max, uid_min)) {
+                        return -EINVAL;
+                }
+        }
+
+        /* Ensure the gids are valid */
+        if (info->match & XT_OWNER_GID) {
+                kgid_t gid_min = make_kgid(net->user_ns, info->gid_min);
+                kgid_t gid_max = make_kgid(net->user_ns, info->gid_max);
+
+                if (!gid_valid(gid_min) || !gid_valid(gid_max) ||
+                    (info->gid_max < info->gid_min) ||
+                    gid_lt(gid_max, gid_min)) {
+                        return -EINVAL;
+                }
+        }
+
         return 0;
 }
 
@@ -35,6 +63,7 @@ owner_mt(const struct sk_buff *skb, struct xt_action_param *par)
         const struct xt_owner_match_info *info = par->matchinfo;
         const struct file *filp;
         struct sock *sk = skb_to_full_sk(skb);
+        struct net *net = par->net;
 
         if (sk == NULL || sk->sk_socket == NULL)
                 return (info->match ^ info->invert) == 0;
@@ -51,8 +80,8 @@ owner_mt(const struct sk_buff *skb, struct xt_action_param *par)
                        (XT_OWNER_UID | XT_OWNER_GID)) == 0;
 
         if (info->match & XT_OWNER_UID) {
-                kuid_t uid_min = make_kuid(&init_user_ns, info->uid_min);
-                kuid_t uid_max = make_kuid(&init_user_ns, info->uid_max);
+                kuid_t uid_min = make_kuid(net->user_ns, info->uid_min);
+                kuid_t uid_max = make_kuid(net->user_ns, info->uid_max);
                 if ((uid_gte(filp->f_cred->fsuid, uid_min) &&
                      uid_lte(filp->f_cred->fsuid, uid_max)) ^
                     !(info->invert & XT_OWNER_UID))
@@ -60,8 +89,8 @@ owner_mt(const struct sk_buff *skb, struct xt_action_param *par)
         }
 
         if (info->match & XT_OWNER_GID) {
-                kgid_t gid_min = make_kgid(&init_user_ns, info->gid_min);
-                kgid_t gid_max = make_kgid(&init_user_ns, info->gid_max);
+                kgid_t gid_min = make_kgid(net->user_ns, info->gid_min);
+                kgid_t gid_max = make_kgid(net->user_ns, info->gid_max);
                 if ((gid_gte(filp->f_cred->fsgid, gid_min) &&
                      gid_lte(filp->f_cred->fsgid, gid_max)) ^
                     !(info->invert & XT_OWNER_GID))
diff --git a/net/netfilter/xt_tcpudp.c b/net/netfilter/xt_tcpudp.c
index c14d4645daa3..ade024c90f4f 100644
--- a/net/netfilter/xt_tcpudp.c
+++ b/net/netfilter/xt_tcpudp.c
@@ -83,8 +83,6 @@ static bool tcp_mt(const struct sk_buff *skb, struct xt_action_param *par)
                 return false;
         }
 
-#define FWINVTCP(bool, invflg) ((bool) ^ !!(tcpinfo->invflags & (invflg)))
-
         th = skb_header_pointer(skb, par->thoff, sizeof(_tcph), &_tcph);
         if (th == NULL) {
                 /* We've been asked to examine this packet, and we
@@ -102,9 +100,8 @@ static bool tcp_mt(const struct sk_buff *skb, struct xt_action_param *par)
                         ntohs(th->dest),
                         !!(tcpinfo->invflags & XT_TCP_INV_DSTPT)))
                 return false;
-        if (!FWINVTCP((((unsigned char *)th)[13] & tcpinfo->flg_mask)
-                      == tcpinfo->flg_cmp,
-                      XT_TCP_INV_FLAGS))
+        if (!NF_INVF(tcpinfo, XT_TCP_INV_FLAGS,
+                     (((unsigned char *)th)[13] & tcpinfo->flg_mask) == tcpinfo->flg_cmp))
                 return false;
         if (tcpinfo->option) {
                 if (th->doff * 4 < sizeof(_tcph)) {