netfilter: nf_tables: pass context structure to nft_parse_register_load

Mechanical transformation, no logical changes intended.

Signed-off-by: Florian Westphal <fw@strlen.de>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index 2be4738eae1cc1639449f0cfeab56591fff9119e..573995e7a27ea1dc5667d33a84980ff75b839ba6 100644 (file)
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -254,7 +254,8 @@ static inline enum nft_registers nft_type_to_reg(enum nft_data_types type)
 int nft_parse_u32_check(const struct nlattr *attr, int max, u32 *dest);
 int nft_dump_register(struct sk_buff *skb, unsigned int attr, unsigned int reg);
 
-int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len);
+int nft_parse_register_load(const struct nft_ctx *ctx,
+                           const struct nlattr *attr, u8 *sreg, u32 len);
 int nft_parse_register_store(const struct nft_ctx *ctx,
                             const struct nlattr *attr, u8 *dreg,
                             const struct nft_data *data,

diff --git a/net/bridge/netfilter/nft_meta_bridge.c b/net/bridge/netfilter/nft_meta_bridge.c
index bd4d1b4d745f645eba71b881e903551080238816..4d8e15927217ba3db4510e90bef691fde5ef18c4 100644 (file)
--- a/net/bridge/netfilter/nft_meta_bridge.c
+++ b/net/bridge/netfilter/nft_meta_bridge.c
@@ -142,7 +142,7 @@ static int nft_meta_bridge_set_init(const struct nft_ctx *ctx,
        }
 
        priv->len = len;
-       err = nft_parse_register_load(tb[NFTA_META_SREG], &priv->sreg, len);
+       err = nft_parse_register_load(ctx, tb[NFTA_META_SREG], &priv->sreg, len);
        if (err < 0)
                return err;
 

diff --git a/net/ipv4/netfilter/nft_dup_ipv4.c b/net/ipv4/netfilter/nft_dup_ipv4.c
index a522c3a3be5234837cd0f6dd7ad51364bfc63faa..ef5dd88107ddbbc751584bda0ea376c166eb9d85 100644 (file)
--- a/net/ipv4/netfilter/nft_dup_ipv4.c
+++ b/net/ipv4/netfilter/nft_dup_ipv4.c
@@ -40,13 +40,13 @@ static int nft_dup_ipv4_init(const struct nft_ctx *ctx,
        if (tb[NFTA_DUP_SREG_ADDR] == NULL)
                return -EINVAL;
 
-       err = nft_parse_register_load(tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr,
+       err = nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr,
                                      sizeof(struct in_addr));
        if (err < 0)
                return err;
 
        if (tb[NFTA_DUP_SREG_DEV])
-               err = nft_parse_register_load(tb[NFTA_DUP_SREG_DEV],
+               err = nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_DEV],
                                              &priv->sreg_dev, sizeof(int));
 
        return err;

diff --git a/net/ipv6/netfilter/nft_dup_ipv6.c b/net/ipv6/netfilter/nft_dup_ipv6.c
index c82f3fdd4a65deed0970ee4949fc60b3b164efe5..492a811828a71bf918e53eb91ec4d34ba31c783c 100644 (file)
--- a/net/ipv6/netfilter/nft_dup_ipv6.c
+++ b/net/ipv6/netfilter/nft_dup_ipv6.c
@@ -38,13 +38,13 @@ static int nft_dup_ipv6_init(const struct nft_ctx *ctx,
        if (tb[NFTA_DUP_SREG_ADDR] == NULL)
                return -EINVAL;
 
-       err = nft_parse_register_load(tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr,
+       err = nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr,
                                      sizeof(struct in6_addr));
        if (err < 0)
                return err;
 
        if (tb[NFTA_DUP_SREG_DEV])
-               err = nft_parse_register_load(tb[NFTA_DUP_SREG_DEV],
+               err = nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_DEV],
                                              &priv->sreg_dev, sizeof(int));
 
        return err;

diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index c85d037a363b2b5b4197c281af945dd13ded8a2b..d05fc17bb9b711f6f40a2dbc3fd36d52cb59a545 100644 (file)
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -11038,7 +11038,8 @@ static int nft_validate_register_load(enum nft_registers reg, unsigned int len)
        return 0;
 }
 
-int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len)
+int nft_parse_register_load(const struct nft_ctx *ctx,
+                           const struct nlattr *attr, u8 *sreg, u32 len)
 {
        u32 reg;
        int err;

diff --git a/net/netfilter/nft_bitwise.c b/net/netfilter/nft_bitwise.c
index ca857afbf06167cd12e80b8d834fc1640e25a876..7de95674fd8c44eb3ed91746468da231093b5fd0 100644 (file)
--- a/net/netfilter/nft_bitwise.c
+++ b/net/netfilter/nft_bitwise.c
@@ -171,7 +171,7 @@ static int nft_bitwise_init(const struct nft_ctx *ctx,
 
        priv->len = len;
 
-       err = nft_parse_register_load(tb[NFTA_BITWISE_SREG], &priv->sreg,
+       err = nft_parse_register_load(ctx, tb[NFTA_BITWISE_SREG], &priv->sreg,
                                      priv->len);
        if (err < 0)
                return err;
@@ -365,7 +365,7 @@ static int nft_bitwise_fast_init(const struct nft_ctx *ctx,
        struct nft_bitwise_fast_expr *priv = nft_expr_priv(expr);
        int err;
 
-       err = nft_parse_register_load(tb[NFTA_BITWISE_SREG], &priv->sreg,
+       err = nft_parse_register_load(ctx, tb[NFTA_BITWISE_SREG], &priv->sreg,
                                      sizeof(u32));
        if (err < 0)
                return err;

diff --git a/net/netfilter/nft_byteorder.c b/net/netfilter/nft_byteorder.c
index f6e791a6810151823fa021849f4809af715e5a67..2f82a444d21bf3e1b5598577635497066c5e838d 100644 (file)
--- a/net/netfilter/nft_byteorder.c
+++ b/net/netfilter/nft_byteorder.c
@@ -139,7 +139,7 @@ static int nft_byteorder_init(const struct nft_ctx *ctx,
 
        priv->len = len;
 
-       err = nft_parse_register_load(tb[NFTA_BYTEORDER_SREG], &priv->sreg,
+       err = nft_parse_register_load(ctx, tb[NFTA_BYTEORDER_SREG], &priv->sreg,
                                      priv->len);
        if (err < 0)
                return err;

diff --git a/net/netfilter/nft_cmp.c b/net/netfilter/nft_cmp.c
index cd4652259095cf0b350a0b5c3af2e34f398a6e92..2605f43737bc96012c6f90e2fd52fc662a895b8e 100644 (file)
--- a/net/netfilter/nft_cmp.c
+++ b/net/netfilter/nft_cmp.c
@@ -83,7 +83,7 @@ static int nft_cmp_init(const struct nft_ctx *ctx, const struct nft_expr *expr,
        if (err < 0)
                return err;
 
-       err = nft_parse_register_load(tb[NFTA_CMP_SREG], &priv->sreg, desc.len);
+       err = nft_parse_register_load(ctx, tb[NFTA_CMP_SREG], &priv->sreg, desc.len);
        if (err < 0)
                return err;
 
@@ -222,7 +222,7 @@ static int nft_cmp_fast_init(const struct nft_ctx *ctx,
        if (err < 0)
                return err;
 
-       err = nft_parse_register_load(tb[NFTA_CMP_SREG], &priv->sreg, desc.len);
+       err = nft_parse_register_load(ctx, tb[NFTA_CMP_SREG], &priv->sreg, desc.len);
        if (err < 0)
                return err;
 
@@ -323,7 +323,7 @@ static int nft_cmp16_fast_init(const struct nft_ctx *ctx,
        if (err < 0)
                return err;
 
-       err = nft_parse_register_load(tb[NFTA_CMP_SREG], &priv->sreg, desc.len);
+       err = nft_parse_register_load(ctx, tb[NFTA_CMP_SREG], &priv->sreg, desc.len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_ct.c b/net/netfilter/nft_ct.c
index 452ed94c3a4d85455bd888f48d85c1459da99c31..67a41cd2baaff0c35898f06cf3c072a6c5bd8356 100644 (file)
--- a/net/netfilter/nft_ct.c
+++ b/net/netfilter/nft_ct.c
@@ -606,7 +606,7 @@ static int nft_ct_set_init(const struct nft_ctx *ctx,
        }
 
        priv->len = len;
-       err = nft_parse_register_load(tb[NFTA_CT_SREG], &priv->sreg, len);
+       err = nft_parse_register_load(ctx, tb[NFTA_CT_SREG], &priv->sreg, len);
        if (err < 0)
                goto err1;
 

diff --git a/net/netfilter/nft_dup_netdev.c b/net/netfilter/nft_dup_netdev.c
index e5739a59ebf10c846446c34ec27740d60b042d15..0573f96ce07913b7581673e7ef59b7809cb598b5 100644 (file)
--- a/net/netfilter/nft_dup_netdev.c
+++ b/net/netfilter/nft_dup_netdev.c
@@ -40,7 +40,7 @@ static int nft_dup_netdev_init(const struct nft_ctx *ctx,
        if (tb[NFTA_DUP_SREG_DEV] == NULL)
                return -EINVAL;
 
-       return nft_parse_register_load(tb[NFTA_DUP_SREG_DEV], &priv->sreg_dev,
+       return nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_DEV], &priv->sreg_dev,
                                       sizeof(int));
 }
 

diff --git a/net/netfilter/nft_dynset.c b/net/netfilter/nft_dynset.c
index b4ada3ab21679bc4e69f5810cd5590b7a2bbac96..6920df754265642c9c2998411b19ee5f7084b05f 100644 (file)
--- a/net/netfilter/nft_dynset.c
+++ b/net/netfilter/nft_dynset.c
@@ -215,7 +215,7 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
                        return err;
        }
 
-       err = nft_parse_register_load(tb[NFTA_DYNSET_SREG_KEY], &priv->sreg_key,
+       err = nft_parse_register_load(ctx, tb[NFTA_DYNSET_SREG_KEY], &priv->sreg_key,
                                      set->klen);
        if (err < 0)
                return err;
@@ -226,7 +226,7 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
                if (set->dtype == NFT_DATA_VERDICT)
                        return -EOPNOTSUPP;
 
-               err = nft_parse_register_load(tb[NFTA_DYNSET_SREG_DATA],
+               err = nft_parse_register_load(ctx, tb[NFTA_DYNSET_SREG_DATA],
                                              &priv->sreg_data, set->dlen);
                if (err < 0)
                        return err;

diff --git a/net/netfilter/nft_exthdr.c b/net/netfilter/nft_exthdr.c
index 6eb571d0c3fdfcb4ac6cef4b313f039ecfe2517b..6bfd335162414a817f7ec4f974f7e4ed7e4be3d2 100644 (file)
--- a/net/netfilter/nft_exthdr.c
+++ b/net/netfilter/nft_exthdr.c
@@ -588,7 +588,7 @@ static int nft_exthdr_tcp_set_init(const struct nft_ctx *ctx,
        priv->flags  = flags;
        priv->op     = op;
 
-       return nft_parse_register_load(tb[NFTA_EXTHDR_SREG], &priv->sreg,
+       return nft_parse_register_load(ctx, tb[NFTA_EXTHDR_SREG], &priv->sreg,
                                       priv->len);
 }
 

diff --git a/net/netfilter/nft_fwd_netdev.c b/net/netfilter/nft_fwd_netdev.c
index 358e742afad703a99aa49acc3b31752f0017d9c5..c83a794025f92c3a491fcfd3c7133c1094c9488d 100644 (file)
--- a/net/netfilter/nft_fwd_netdev.c
+++ b/net/netfilter/nft_fwd_netdev.c
@@ -52,7 +52,7 @@ static int nft_fwd_netdev_init(const struct nft_ctx *ctx,
        if (tb[NFTA_FWD_SREG_DEV] == NULL)
                return -EINVAL;
 
-       return nft_parse_register_load(tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev,
+       return nft_parse_register_load(ctx, tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev,
                                       sizeof(int));
 }
 
@@ -178,12 +178,12 @@ static int nft_fwd_neigh_init(const struct nft_ctx *ctx,
                return -EOPNOTSUPP;
        }
 
-       err = nft_parse_register_load(tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev,
+       err = nft_parse_register_load(ctx, tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev,
                                      sizeof(int));
        if (err < 0)
                return err;
 
-       return nft_parse_register_load(tb[NFTA_FWD_SREG_ADDR], &priv->sreg_addr,
+       return nft_parse_register_load(ctx, tb[NFTA_FWD_SREG_ADDR], &priv->sreg_addr,
                                       addr_len);
 }
 

diff --git a/net/netfilter/nft_hash.c b/net/netfilter/nft_hash.c
index 868d68302d224d6e1f556ccd6824d99217f281be..5d034bbb6913cd4b218e7ccd94e1b405366c3608 100644 (file)
--- a/net/netfilter/nft_hash.c
+++ b/net/netfilter/nft_hash.c
@@ -92,7 +92,7 @@ static int nft_jhash_init(const struct nft_ctx *ctx,
 
        priv->len = len;
 
-       err = nft_parse_register_load(tb[NFTA_HASH_SREG], &priv->sreg, len);
+       err = nft_parse_register_load(ctx, tb[NFTA_HASH_SREG], &priv->sreg, len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_lookup.c b/net/netfilter/nft_lookup.c
index f3080fa1b22631b9e6adbcb26bdb36b1eb8b6cf4..580e4b1deb9ba00c2c85fd451eefadbed54f51b4 100644 (file)
--- a/net/netfilter/nft_lookup.c
+++ b/net/netfilter/nft_lookup.c
@@ -113,7 +113,7 @@ static int nft_lookup_init(const struct nft_ctx *ctx,
        if (IS_ERR(set))
                return PTR_ERR(set);
 
-       err = nft_parse_register_load(tb[NFTA_LOOKUP_SREG], &priv->sreg,
+       err = nft_parse_register_load(ctx, tb[NFTA_LOOKUP_SREG], &priv->sreg,
                                      set->klen);
        if (err < 0)
                return err;

diff --git a/net/netfilter/nft_masq.c b/net/netfilter/nft_masq.c
index 8a14aaca93bbdff806935021ed8cb54cde5b590e..cb43c72a8c2ad8b2ec8257e1ab29db2a3ff7be66 100644 (file)
--- a/net/netfilter/nft_masq.c
+++ b/net/netfilter/nft_masq.c
@@ -52,13 +52,13 @@ static int nft_masq_init(const struct nft_ctx *ctx,
                priv->flags = ntohl(nla_get_be32(tb[NFTA_MASQ_FLAGS]));
 
        if (tb[NFTA_MASQ_REG_PROTO_MIN]) {
-               err = nft_parse_register_load(tb[NFTA_MASQ_REG_PROTO_MIN],
+               err = nft_parse_register_load(ctx, tb[NFTA_MASQ_REG_PROTO_MIN],
                                              &priv->sreg_proto_min, plen);
                if (err < 0)
                        return err;
 
                if (tb[NFTA_MASQ_REG_PROTO_MAX]) {
-                       err = nft_parse_register_load(tb[NFTA_MASQ_REG_PROTO_MAX],
+                       err = nft_parse_register_load(ctx, tb[NFTA_MASQ_REG_PROTO_MAX],
                                                      &priv->sreg_proto_max,
                                                      plen);
                        if (err < 0)

diff --git a/net/netfilter/nft_meta.c b/net/netfilter/nft_meta.c
index 9139ce38ea7b9a7ed2cb626762ef5620e0124b52..0214ad1ced2fe2ab3bf626ecd65ab6aa02444795 100644 (file)
--- a/net/netfilter/nft_meta.c
+++ b/net/netfilter/nft_meta.c
@@ -657,7 +657,7 @@ int nft_meta_set_init(const struct nft_ctx *ctx,
        }
 
        priv->len = len;
-       err = nft_parse_register_load(tb[NFTA_META_SREG], &priv->sreg, len);
+       err = nft_parse_register_load(ctx, tb[NFTA_META_SREG], &priv->sreg, len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_nat.c b/net/netfilter/nft_nat.c
index 808f5802c2704a583c747e71d227965fa5c1a8bf..983dd937fe02993f65bc91607deae1c695fc31a2 100644 (file)
--- a/net/netfilter/nft_nat.c
+++ b/net/netfilter/nft_nat.c
@@ -214,13 +214,13 @@ static int nft_nat_init(const struct nft_ctx *ctx, const struct nft_expr *expr,
        priv->family = family;
 
        if (tb[NFTA_NAT_REG_ADDR_MIN]) {
-               err = nft_parse_register_load(tb[NFTA_NAT_REG_ADDR_MIN],
+               err = nft_parse_register_load(ctx, tb[NFTA_NAT_REG_ADDR_MIN],
                                              &priv->sreg_addr_min, alen);
                if (err < 0)
                        return err;
 
                if (tb[NFTA_NAT_REG_ADDR_MAX]) {
-                       err = nft_parse_register_load(tb[NFTA_NAT_REG_ADDR_MAX],
+                       err = nft_parse_register_load(ctx, tb[NFTA_NAT_REG_ADDR_MAX],
                                                      &priv->sreg_addr_max,
                                                      alen);
                        if (err < 0)
@@ -234,13 +234,13 @@ static int nft_nat_init(const struct nft_ctx *ctx, const struct nft_expr *expr,
 
        plen = sizeof_field(struct nf_nat_range, min_proto.all);
        if (tb[NFTA_NAT_REG_PROTO_MIN]) {
-               err = nft_parse_register_load(tb[NFTA_NAT_REG_PROTO_MIN],
+               err = nft_parse_register_load(ctx, tb[NFTA_NAT_REG_PROTO_MIN],
                                              &priv->sreg_proto_min, plen);
                if (err < 0)
                        return err;
 
                if (tb[NFTA_NAT_REG_PROTO_MAX]) {
-                       err = nft_parse_register_load(tb[NFTA_NAT_REG_PROTO_MAX],
+                       err = nft_parse_register_load(ctx, tb[NFTA_NAT_REG_PROTO_MAX],
                                                      &priv->sreg_proto_max,
                                                      plen);
                        if (err < 0)

diff --git a/net/netfilter/nft_objref.c b/net/netfilter/nft_objref.c
index 509011b1ef597ca96abbbc3acf7fdb87536acdf0..09da7a3f9f96775982ff817b5c30695c77eab7dd 100644 (file)
--- a/net/netfilter/nft_objref.c
+++ b/net/netfilter/nft_objref.c
@@ -143,7 +143,7 @@ static int nft_objref_map_init(const struct nft_ctx *ctx,
        if (!(set->flags & NFT_SET_OBJECT))
                return -EINVAL;
 
-       err = nft_parse_register_load(tb[NFTA_OBJREF_SET_SREG], &priv->sreg,
+       err = nft_parse_register_load(ctx, tb[NFTA_OBJREF_SET_SREG], &priv->sreg,
                                      set->klen);
        if (err < 0)
                return err;

diff --git a/net/netfilter/nft_payload.c b/net/netfilter/nft_payload.c
index 50429cbd42da42928f585daddec4ffa5016588ad..330609a76fb202f7f8c54d2c695f16df3016f118 100644 (file)
--- a/net/netfilter/nft_payload.c
+++ b/net/netfilter/nft_payload.c
@@ -981,7 +981,7 @@ static int nft_payload_set_init(const struct nft_ctx *ctx,
        }
        priv->csum_type = csum_type;
 
-       return nft_parse_register_load(tb[NFTA_PAYLOAD_SREG], &priv->sreg,
+       return nft_parse_register_load(ctx, tb[NFTA_PAYLOAD_SREG], &priv->sreg,
                                       priv->len);
 }
 

diff --git a/net/netfilter/nft_queue.c b/net/netfilter/nft_queue.c
index b2b8127c8d438161d40f861aeee8a82a2e3660f6..44e6817e6e29bab9039488e85ea3880a89c7f617 100644 (file)
--- a/net/netfilter/nft_queue.c
+++ b/net/netfilter/nft_queue.c
@@ -136,7 +136,7 @@ static int nft_queue_sreg_init(const struct nft_ctx *ctx,
        struct nft_queue *priv = nft_expr_priv(expr);
        int err;
 
-       err = nft_parse_register_load(tb[NFTA_QUEUE_SREG_QNUM],
+       err = nft_parse_register_load(ctx, tb[NFTA_QUEUE_SREG_QNUM],
                                      &priv->sreg_qnum, sizeof(u32));
        if (err < 0)
                return err;

diff --git a/net/netfilter/nft_range.c b/net/netfilter/nft_range.c
index 51ae64cd268f43f626b35ba958c7bb8b9600ed20..ea382f7bbd78dbcedf4cd85ad4459cf1d06bf50e 100644 (file)
--- a/net/netfilter/nft_range.c
+++ b/net/netfilter/nft_range.c
@@ -83,7 +83,7 @@ static int nft_range_init(const struct nft_ctx *ctx, const struct nft_expr *expr
                goto err2;
        }
 
-       err = nft_parse_register_load(tb[NFTA_RANGE_SREG], &priv->sreg,
+       err = nft_parse_register_load(ctx, tb[NFTA_RANGE_SREG], &priv->sreg,
                                      desc_from.len);
        if (err < 0)
                goto err2;

diff --git a/net/netfilter/nft_redir.c b/net/netfilter/nft_redir.c
index a58bd8d291ff2dfe8b68da505e7bc7d8b59d212a..6568cc264078d0b35c6e0d7cb185264af6707dfb 100644 (file)
--- a/net/netfilter/nft_redir.c
+++ b/net/netfilter/nft_redir.c
@@ -51,13 +51,13 @@ static int nft_redir_init(const struct nft_ctx *ctx,
 
        plen = sizeof_field(struct nf_nat_range, min_proto.all);
        if (tb[NFTA_REDIR_REG_PROTO_MIN]) {
-               err = nft_parse_register_load(tb[NFTA_REDIR_REG_PROTO_MIN],
+               err = nft_parse_register_load(ctx, tb[NFTA_REDIR_REG_PROTO_MIN],
                                              &priv->sreg_proto_min, plen);
                if (err < 0)
                        return err;
 
                if (tb[NFTA_REDIR_REG_PROTO_MAX]) {
-                       err = nft_parse_register_load(tb[NFTA_REDIR_REG_PROTO_MAX],
+                       err = nft_parse_register_load(ctx, tb[NFTA_REDIR_REG_PROTO_MAX],
                                                      &priv->sreg_proto_max,
                                                      plen);
                        if (err < 0)

diff --git a/net/netfilter/nft_tproxy.c b/net/netfilter/nft_tproxy.c
index 71412adb73d414c43d2082362e854c3ad561d815..1b691393d8b1d2c1a8cd8771c9e4ea64e949c4b4 100644 (file)
--- a/net/netfilter/nft_tproxy.c
+++ b/net/netfilter/nft_tproxy.c
@@ -254,14 +254,14 @@ static int nft_tproxy_init(const struct nft_ctx *ctx,
        }
 
        if (tb[NFTA_TPROXY_REG_ADDR]) {
-               err = nft_parse_register_load(tb[NFTA_TPROXY_REG_ADDR],
+               err = nft_parse_register_load(ctx, tb[NFTA_TPROXY_REG_ADDR],
                                              &priv->sreg_addr, alen);
                if (err < 0)
                        return err;
        }
 
        if (tb[NFTA_TPROXY_REG_PORT]) {
-               err = nft_parse_register_load(tb[NFTA_TPROXY_REG_PORT],
+               err = nft_parse_register_load(ctx, tb[NFTA_TPROXY_REG_PORT],
                                              &priv->sreg_port, sizeof(u16));
                if (err < 0)
                        return err;