netfilter: nf_tables: use DEBUG_NET_WARN_ON_ONCE in packet and control paths

Replace raw warning macros with DEBUG_NET_WARN_ON_ONCE across the
nf_tables API, core engine, and expression evaluations. This prevents
unnecessary system panics when panic_on_warn=1 is enabled in production
systems.

Signed-off-by: Fernando Fernandez Mancera <fmancera@suse.de>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index 87387adbca655f3501c77167a69bd2451e0260aa..4884f7f7aaeee032de4edea314e35e95f987d7f2 100644 (file)
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -3378,8 +3378,10 @@ static int nf_tables_delchain(struct sk_buff *skb, const struct nfnl_info *info,
  */
 int nft_register_expr(struct nft_expr_type *type)
 {
-       if (WARN_ON_ONCE(type->maxattr > NFT_EXPR_MAXATTR))
+       if (unlikely(type->maxattr > NFT_EXPR_MAXATTR)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return -ENOMEM;
+       }
 
        nfnl_lock(NFNL_SUBSYS_NFTABLES);
        if (type->family == NFPROTO_UNSPEC)
@@ -3691,8 +3693,10 @@ int nft_expr_clone(struct nft_expr *dst, struct nft_expr *src, gfp_t gfp)
 {
        int err;
 
-       if (WARN_ON_ONCE(!src->ops->clone))
+       if (unlikely(!src->ops->clone)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return -EINVAL;
+       }
 
        dst->ops = src->ops;
        err = src->ops->clone(dst, src, gfp);
@@ -8327,8 +8331,10 @@ static int nf_tables_newobj(struct sk_buff *skb, const struct nfnl_info *info,
                        return 0;
 
                type = nft_obj_type_get(net, objtype, family);
-               if (WARN_ON_ONCE(IS_ERR(type)))
+               if (IS_ERR(type)) {
+                       DEBUG_NET_WARN_ON_ONCE(1);
                        return PTR_ERR(type);
+               }
 
                nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
 
@@ -10306,19 +10312,25 @@ static int nf_tables_commit_chain_prepare(struct net *net, struct nft_chain *cha
 
                prule = (struct nft_rule_dp *)data;
                data += offsetof(struct nft_rule_dp, data);
-               if (WARN_ON_ONCE(data > data_boundary))
+               if (unlikely(data > data_boundary)) {
+                       DEBUG_NET_WARN_ON_ONCE(1);
                        return -ENOMEM;
+               }
 
                size = 0;
                nft_rule_for_each_expr(expr, last, rule) {
-                       if (WARN_ON_ONCE(data + size + expr->ops->size > data_boundary))
+                       if (unlikely(data + size + expr->ops->size > data_boundary)) {
+                               DEBUG_NET_WARN_ON_ONCE(1);
                                return -ENOMEM;
+                       }
 
                        memcpy(data + size, expr, expr->ops->size);
                        size += expr->ops->size;
                }
-               if (WARN_ON_ONCE(size >= 1 << 12))
+               if (unlikely(size >= 1 << 12)) {
+                       DEBUG_NET_WARN_ON_ONCE(1);
                        return -ENOMEM;
+               }
 
                prule->handle = rule->handle;
                prule->dlen = size;
@@ -10329,8 +10341,10 @@ static int nf_tables_commit_chain_prepare(struct net *net, struct nft_chain *cha
                chain->blob_next->size += (unsigned long)(data - (void *)prule);
        }
 
-       if (WARN_ON_ONCE(data > data_boundary))
+       if (unlikely(data > data_boundary)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return -ENOMEM;
+       }
 
        prule = (struct nft_rule_dp *)data;
        nft_last_rule(chain, prule);
@@ -11636,8 +11650,10 @@ int nft_parse_register_load(const struct nft_ctx *ctx,
        next_register = DIV_ROUND_UP(len, NFT_REG32_SIZE) + reg;
 
        /* Can't happen: nft_validate_register_load() should have failed */
-       if (WARN_ON_ONCE(next_register > NFT_REG32_NUM))
+       if (unlikely(next_register > NFT_REG32_NUM)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return -EINVAL;
+       }
 
        /* find first register that did not see an earlier store. */
        invalid_reg = find_next_zero_bit(ctx->reg_inited, NFT_REG32_NUM, reg);
@@ -11884,8 +11900,10 @@ int nft_data_init(const struct nft_ctx *ctx, struct nft_data *data,
        struct nlattr *tb[NFTA_DATA_MAX + 1];
        int err;
 
-       if (WARN_ON_ONCE(!desc->size))
+       if (unlikely(!desc->size)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return -EINVAL;
+       }
 
        err = nla_parse_nested_deprecated(tb, NFTA_DATA_MAX, nla,
                                          nft_data_policy, NULL);
@@ -11950,7 +11968,7 @@ int nft_data_dump(struct sk_buff *skb, int attr, const struct nft_data *data,
                break;
        default:
                err = -EINVAL;
-               WARN_ON(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
        }
 
        nla_nest_end(skb, nest);

diff --git a/net/netfilter/nf_tables_core.c b/net/netfilter/nf_tables_core.c
index 8ab186f86dd43ac50835d41117c2e1c575361791..01a72f334dc6e1aeda5820fc44569862336a9747 100644 (file)
--- a/net/netfilter/nf_tables_core.c
+++ b/net/netfilter/nf_tables_core.c
@@ -314,8 +314,10 @@ next_rule:
 
        switch (regs.verdict.code) {
        case NFT_JUMP:
-               if (WARN_ON_ONCE(stackptr >= NFT_JUMP_STACK_SIZE))
-                       return NF_DROP;
+               if (unlikely(stackptr >= NFT_JUMP_STACK_SIZE)) {
+                       DEBUG_NET_WARN_ON_ONCE(1);
+                       return NF_DROP_REASON(pkt->skb, SKB_DROP_REASON_NETFILTER_DROP, ELOOP);
+               }
                jumpstack[stackptr].rule = nft_rule_next(rule);
                stackptr++;
                fallthrough;
@@ -326,7 +328,7 @@ next_rule:
        case NFT_RETURN:
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
        }
 
        if (stackptr > 0) {

diff --git a/net/netfilter/nf_tables_offload.c b/net/netfilter/nf_tables_offload.c
index 9101b1703b5250981d5434c7ee4982173c6a3686..8998a24651ff072f9370cc940e8c5220db22001b 100644 (file)
--- a/net/netfilter/nf_tables_offload.c
+++ b/net/netfilter/nf_tables_offload.c
@@ -361,7 +361,7 @@ static int nft_block_setup(struct nft_base_chain *basechain,
                err = nft_flow_offload_unbind(bo, basechain);
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                err = -EOPNOTSUPP;
        }
 

diff --git a/net/netfilter/nf_tables_trace.c b/net/netfilter/nf_tables_trace.c
index a88abae5a9de2f80f253ac4e288e774f9dd6307e..d85b6a2fb43caf18b0a70ab03e0bcbda5c8ccfab 100644 (file)
--- a/net/netfilter/nf_tables_trace.c
+++ b/net/netfilter/nf_tables_trace.c
@@ -227,8 +227,10 @@ static const struct nft_chain *nft_trace_get_chain(const struct nft_rule_dp *rul
 
        last = (const struct nft_rule_dp_last *)rule;
 
-       if (WARN_ON_ONCE(!last->chain))
+       if (unlikely(!last->chain)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return &info->basechain->chain;
+       }
 
        return last->chain;
 }
@@ -354,7 +356,7 @@ void nft_trace_notify(const struct nft_pktinfo *pkt,
        return;
 
  nla_put_failure:
-       WARN_ON_ONCE(1);
+       DEBUG_NET_WARN_ON_ONCE(1);
        kfree_skb(skb);
 }
 

diff --git a/net/netfilter/nft_ct.c b/net/netfilter/nft_ct.c
index 9fe179d688daa84f6d773d94134698c9897c90df..25934c6f01fbca999a3e14cb20046b78a45dfb54 100644 (file)
--- a/net/netfilter/nft_ct.c
+++ b/net/netfilter/nft_ct.c
@@ -1132,7 +1132,7 @@ static void nft_ct_helper_obj_eval(struct nft_object *obj,
                to_assign = priv->helper6;
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                return;
        }
 

diff --git a/net/netfilter/nft_ct_fast.c b/net/netfilter/nft_ct_fast.c
index ecf7b3a404be261846b244377921e6c2f3735f7c..a44524c4fe630e916d3feae3df24f72e40920eac 100644 (file)
--- a/net/netfilter/nft_ct_fast.c
+++ b/net/netfilter/nft_ct_fast.c
@@ -53,7 +53,7 @@ void nft_ct_get_fast_eval(const struct nft_expr *expr,
                return;
 #endif
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                regs->verdict.code = NFT_BREAK;
                break;
        }

diff --git a/net/netfilter/nft_exthdr.c b/net/netfilter/nft_exthdr.c
index e6a07c0df2079fe46c25ca04a170258da0a1ec4a..8861b4d191d114a771eafd209221389286865c13 100644 (file)
--- a/net/netfilter/nft_exthdr.c
+++ b/net/netfilter/nft_exthdr.c
@@ -298,7 +298,7 @@ static void nft_exthdr_tcp_set_eval(const struct nft_expr *expr,
                                                 old.v32, new.v32, false);
                        break;
                default:
-                       WARN_ON_ONCE(1);
+                       DEBUG_NET_WARN_ON_ONCE(1);
                        break;
                }
 

diff --git a/net/netfilter/nft_fib.c b/net/netfilter/nft_fib.c
index 327a5f33659cd79da08a430ed5676c25df72e58b..1d0d815c8745e93ef5f6b85aa0f6c7d7d47f35b0 100644 (file)
--- a/net/netfilter/nft_fib.c
+++ b/net/netfilter/nft_fib.c
@@ -155,7 +155,7 @@ void nft_fib_store_result(void *reg, const struct nft_fib *priv,
                        strscpy_pad(reg, dev ? dev->name : "", IFNAMSIZ);
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                *dreg = 0;
                break;
        }

diff --git a/net/netfilter/nft_inner.c b/net/netfilter/nft_inner.c
index d14ca157910b5dcf1b587a20783672eebc9b02a0..97fb4eea2d669b269bb611823650649449423f27 100644 (file)
--- a/net/netfilter/nft_inner.c
+++ b/net/netfilter/nft_inner.c
@@ -308,7 +308,7 @@ static void nft_inner_eval(const struct nft_expr *expr, struct nft_regs *regs,
                nft_meta_inner_eval((struct nft_expr *)&priv->expr, regs, pkt, &tun_ctx);
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                goto err;
        }
        nft_inner_save_tun_ctx(pkt, &tun_ctx);

diff --git a/net/netfilter/nft_lookup.c b/net/netfilter/nft_lookup.c
index 9fafe5afc490e0f4b2df7aa7eae90cb1b30538dd..ba512e94b4023fba26116ef1ce6b09e1b40d51de 100644 (file)
--- a/net/netfilter/nft_lookup.c
+++ b/net/netfilter/nft_lookup.c
@@ -50,7 +50,7 @@ __nft_set_do_lookup(const struct net *net, const struct nft_set *set,
        if (set->ops == &nft_set_rbtree_type.ops)
                return nft_rbtree_lookup(net, set, key);
 
-       WARN_ON_ONCE(1);
+       DEBUG_NET_WARN_ON_ONCE(1);
 #endif
        return set->ops->lookup(net, set, key);
 }

diff --git a/net/netfilter/nft_masq.c b/net/netfilter/nft_masq.c
index 2b01128737a3a8ab31166a0e672b43d280e7d23f..841efd981e200c766e4143f745470cdcff352f69 100644 (file)
--- a/net/netfilter/nft_masq.c
+++ b/net/netfilter/nft_masq.c
@@ -123,7 +123,7 @@ static void nft_masq_eval(const struct nft_expr *expr,
                break;
 #endif
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                break;
        }
 }

diff --git a/net/netfilter/nft_meta.c b/net/netfilter/nft_meta.c
index 5b25851381e5241d63bd724ccd3aafbea4207428..9b5821c644426dcc7a0e1723c49083a745fbbd2c 100644 (file)
--- a/net/netfilter/nft_meta.c
+++ b/net/netfilter/nft_meta.c
@@ -116,12 +116,12 @@ nft_meta_get_eval_pkttype_lo(const struct nft_pktinfo *pkt,
                        nft_reg_store8(dest, PACKET_MULTICAST);
                        break;
                default:
-                       WARN_ON_ONCE(1);
+                       DEBUG_NET_WARN_ON_ONCE(1);
                        return false;
                }
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                return false;
        }
 
@@ -460,7 +460,7 @@ void nft_meta_get_eval(const struct nft_expr *expr,
                nft_meta_get_eval_sdifname(dest, pkt);
                break;
        default:
-               WARN_ON(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                goto err;
        }
        return;
@@ -506,7 +506,7 @@ void nft_meta_set_eval(const struct nft_expr *expr,
                break;
 #endif
        default:
-               WARN_ON(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
        }
 }
 EXPORT_SYMBOL_GPL(nft_meta_set_eval);
@@ -886,7 +886,7 @@ void nft_meta_inner_eval(const struct nft_expr *expr,
                nft_reg_store8(dest, tun_ctx->l4proto);
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                goto err;
        }
        return;

diff --git a/net/netfilter/nft_payload.c b/net/netfilter/nft_payload.c
index 484a5490832e4a88735e3c86bf9c5cecd57aacf3..ef2a80dfc68f951d8faa9908f23a8a8d38249cac 100644 (file)
--- a/net/netfilter/nft_payload.c
+++ b/net/netfilter/nft_payload.c
@@ -196,7 +196,7 @@ void nft_payload_eval(const struct nft_expr *expr,
                        goto err;
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                goto err;
        }
        offset += priv->offset;
@@ -603,7 +603,7 @@ void nft_payload_inner_eval(const struct nft_expr *expr, struct nft_regs *regs,
                offset = tun_ctx->inner_thoff;
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                goto err;
        }
        offset += priv->offset;
@@ -866,7 +866,7 @@ static void nft_payload_set_eval(const struct nft_expr *expr,
                        goto err;
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                goto err;
        }
 

diff --git a/net/netfilter/nft_redir.c b/net/netfilter/nft_redir.c
index 58ae802db8f52d5c5d644900446057fe9fd5920c..a98aa28180fbeaeb4b176f9ae36253bfb1ebb09c 100644 (file)
--- a/net/netfilter/nft_redir.c
+++ b/net/netfilter/nft_redir.c
@@ -126,7 +126,7 @@ static void nft_redir_eval(const struct nft_expr *expr,
                break;
 #endif
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                break;
        }
 }

diff --git a/net/netfilter/nft_reject.c b/net/netfilter/nft_reject.c
index 196a92c7ea09b7c3af00f0906b1537fc59bb0823..e3972e904cf0fa17c0a692a5006cf53543093cb9 100644 (file)
--- a/net/netfilter/nft_reject.c
+++ b/net/netfilter/nft_reject.c
@@ -102,8 +102,10 @@ static u8 icmp_code_v4[NFT_REJECT_ICMPX_MAX + 1] = {
 
 int nft_reject_icmp_code(u8 code)
 {
-       if (WARN_ON_ONCE(code > NFT_REJECT_ICMPX_MAX))
+       if (unlikely(code > NFT_REJECT_ICMPX_MAX)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return ICMP_NET_UNREACH;
+       }
 
        return icmp_code_v4[code];
 }
@@ -120,8 +122,10 @@ static u8 icmp_code_v6[NFT_REJECT_ICMPX_MAX + 1] = {
 
 int nft_reject_icmpv6_code(u8 code)
 {
-       if (WARN_ON_ONCE(code > NFT_REJECT_ICMPX_MAX))
+       if (unlikely(code > NFT_REJECT_ICMPX_MAX)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return ICMPV6_NOROUTE;
+       }
 
        return icmp_code_v6[code];
 }

diff --git a/net/netfilter/nft_rt.c b/net/netfilter/nft_rt.c
index e23cd47598514e31e3638d47ce4bf6a61ed78455..aeb0094eafd8031652cb91951cbe1111ba6d90a2 100644 (file)
--- a/net/netfilter/nft_rt.c
+++ b/net/netfilter/nft_rt.c
@@ -93,7 +93,7 @@ void nft_rt_get_eval(const struct nft_expr *expr,
                break;
 #endif
        default:
-               WARN_ON(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                goto err;
        }
        return;

diff --git a/net/netfilter/nft_set_hash.c b/net/netfilter/nft_set_hash.c
index b0e571c8e3f38a977d651d06cca362f69bb53169..eb4e382119d4fd4bf9b57e37b6570e2ef8d316de 100644 (file)
--- a/net/netfilter/nft_set_hash.c
+++ b/net/netfilter/nft_set_hash.c
@@ -385,7 +385,7 @@ static void nft_rhash_walk(const struct nft_ctx *ctx, struct nft_set *set,
                break;
        default:
                iter->err = -EINVAL;
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                break;
        }
 }

diff --git a/net/netfilter/nft_set_pipapo.c b/net/netfilter/nft_set_pipapo.c
index 50d4a4f04309a9df7cb1434c3dc89d1ceac5bfbc..706c78853f245b0c5327c262775732fe3d59d0b8 100644 (file)
--- a/net/netfilter/nft_set_pipapo.c
+++ b/net/netfilter/nft_set_pipapo.c
@@ -2199,7 +2199,7 @@ static void nft_pipapo_walk(const struct nft_ctx *ctx, struct nft_set *set,
                break;
        default:
                iter->err = -EINVAL;
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                break;
        }
 }

diff --git a/net/netfilter/nft_set_rbtree.c b/net/netfilter/nft_set_rbtree.c
index b4f0b5fdf1f26587844a37476189e16e6cbd6340..018bbb6df4ce43aa43b146caabc7d4dbdb123228 100644 (file)
--- a/net/netfilter/nft_set_rbtree.c
+++ b/net/netfilter/nft_set_rbtree.c
@@ -654,8 +654,10 @@ maybe_grow:
        }
 
 realloc_array:
-       if (WARN_ON_ONCE(nelems > new_max_intervals))
+       if (unlikely(nelems > new_max_intervals)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return -ENOMEM;
+       }
 
        if (priv->array_next) {
                if (max_intervals == new_max_intervals)
@@ -878,7 +880,7 @@ static void nft_rbtree_walk(const struct nft_ctx *ctx,
                break;
        default:
                iter->err = -EINVAL;
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                break;
        }
 }

diff --git a/net/netfilter/nft_socket.c b/net/netfilter/nft_socket.c
index a146a45d7531eb3ac1ae9bfaec62e71d0964f107..52d892e0426144240784fefcc6757af43f43c7b4 100644 (file)
--- a/net/netfilter/nft_socket.c
+++ b/net/netfilter/nft_socket.c
@@ -71,8 +71,10 @@ static noinline int nft_socket_cgroup_subtree_level(void)
        if (level > 255)
                return -ERANGE;
 
-       if (WARN_ON_ONCE(level < 0))
+       if (unlikely(level < 0)) {
+               DEBUG_NET_WARN_ON_ONCE(1);
                return -EINVAL;
+       }
 
        return level;
 }
@@ -97,7 +99,7 @@ static struct sock *nft_socket_do_lookup(const struct nft_pktinfo *pkt)
                break;
 #endif
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                break;
        }
 
@@ -152,7 +154,7 @@ static void nft_socket_eval(const struct nft_expr *expr,
                break;
 #endif
        default:
-               WARN_ON(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                regs->verdict.code = NFT_BREAK;
        }
 

diff --git a/net/netfilter/nft_tunnel.c b/net/netfilter/nft_tunnel.c
index 68f7cfbbee063e562c74c795ef7ce50f89c95437..0a018d4706a9e621c31abb66d0bbae9adec9cacd 100644 (file)
--- a/net/netfilter/nft_tunnel.c
+++ b/net/netfilter/nft_tunnel.c
@@ -60,7 +60,7 @@ static void nft_tunnel_get_eval(const struct nft_expr *expr,
                        regs->verdict.code = NFT_BREAK;
                break;
        default:
-               WARN_ON(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                regs->verdict.code = NFT_BREAK;
        }
 }

diff --git a/net/netfilter/nft_xfrm.c b/net/netfilter/nft_xfrm.c
index 65a75d88e5f0fed8a7327b2b937923199b2a292d..8cec4306431926c4fcf7b79f3436b71c845404c6 100644 (file)
--- a/net/netfilter/nft_xfrm.c
+++ b/net/netfilter/nft_xfrm.c
@@ -132,7 +132,7 @@ static void nft_xfrm_state_get_key(const struct nft_xfrm *priv,
        switch (priv->key) {
        case NFT_XFRM_KEY_UNSPEC:
        case __NFT_XFRM_KEY_MAX:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                break;
        case NFT_XFRM_KEY_DADDR_IP4:
                *dest = (__force __u32)state->id.daddr.a4;
@@ -206,7 +206,7 @@ static void nft_xfrm_get_eval(const struct nft_expr *expr,
                nft_xfrm_get_eval_out(priv, regs, pkt);
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                regs->verdict.code = NFT_BREAK;
                break;
        }
@@ -252,7 +252,7 @@ static int nft_xfrm_validate(const struct nft_ctx *ctx, const struct nft_expr *e
                        (1 << NF_INET_POST_ROUTING);
                break;
        default:
-               WARN_ON_ONCE(1);
+               DEBUG_NET_WARN_ON_ONCE(1);
                return -EINVAL;
        }