static int nft_chain_parse_hook(struct net *net,
                                const struct nlattr * const nla[],
                                struct nft_chain_hook *hook, u8 family,
-                               bool create)
+                               bool autoload)
 {
        struct nlattr *ha[NFTA_HOOK_MAX + 1];
        const struct nft_chain_type *type;
        type = chain_type[family][NFT_CHAIN_T_DEFAULT];
        if (nla[NFTA_CHAIN_TYPE]) {
                type = nf_tables_chain_type_lookup(net, nla[NFTA_CHAIN_TYPE],
-                                                  family, create);
+                                                  family, autoload);
                if (IS_ERR(type))
                        return PTR_ERR(type);
        }
 }
 
 static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask,
-                             u8 policy, bool create)
+                             u8 policy)
 {
        const struct nlattr * const *nla = ctx->nla;
        struct nft_table *table = ctx->table;
                struct nft_chain_hook hook;
                struct nf_hook_ops *ops;
 
-               err = nft_chain_parse_hook(net, nla, &hook, family, create);
+               err = nft_chain_parse_hook(net, nla, &hook, family, true);
                if (err < 0)
                        return err;
 
        return err;
 }
 
-static int nf_tables_updchain(struct nft_ctx *ctx, u8 genmask, u8 policy,
-                             bool create)
+static int nf_tables_updchain(struct nft_ctx *ctx, u8 genmask, u8 policy)
 {
        const struct nlattr * const *nla = ctx->nla;
        struct nft_table *table = ctx->table;
                        return -EBUSY;
 
                err = nft_chain_parse_hook(ctx->net, nla, &hook, ctx->family,
-                                          create);
+                                          false);
                if (err < 0)
                        return err;
 
        u8 policy = NF_ACCEPT;
        struct nft_ctx ctx;
        u64 handle = 0;
-       bool create;
-
-       create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
 
        lockdep_assert_held(&net->nft.commit_mutex);
 
                if (nlh->nlmsg_flags & NLM_F_REPLACE)
                        return -EOPNOTSUPP;
 
-               return nf_tables_updchain(&ctx, genmask, policy, create);
+               return nf_tables_updchain(&ctx, genmask, policy);
        }
 
-       return nf_tables_addchain(&ctx, family, genmask, policy, create);
+       return nf_tables_addchain(&ctx, family, genmask, policy);
 }
 
 static int nf_tables_delchain(struct net *net, struct sock *nlsk,
        struct nlattr *tmp;
        unsigned int size, i, n, ulen = 0, usize = 0;
        int err, rem;
-       bool create;
        u64 handle, pos_handle;
 
        lockdep_assert_held(&net->nft.commit_mutex);
 
-       create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
-
        table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask);
        if (IS_ERR(table)) {
                NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_TABLE]);
                else
                        return -EOPNOTSUPP;
        } else {
-               if (!create || nlh->nlmsg_flags & NLM_F_REPLACE)
+               if (!(nlh->nlmsg_flags & NLM_F_CREATE) ||
+                   nlh->nlmsg_flags & NLM_F_REPLACE)
                        return -EINVAL;
                handle = nf_tables_alloc_handle(table);
 
        struct nft_ctx ctx;
        char *name;
        unsigned int size;
-       bool create;
        u64 timeout;
        u32 ktype, dtype, flags, policy, gc_int, objtype;
        struct nft_set_desc desc;
                        return err;
        }
 
-       create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
-
        table = nft_table_lookup(net, nla[NFTA_SET_TABLE], family, genmask);
        if (IS_ERR(table)) {
                NL_SET_BAD_ATTR(extack, nla[NFTA_SET_TABLE]);