linux-imx

/* SPDX-License-Identifier: GPL-2.0 */

#include <linux/kernel.h>

#include <linux/slab.h>

#include <net/flow_offload.h>

​

struct flow_rule *flow_rule_alloc(unsigned int num_actions)

{

    struct flow_rule *rule;

​

    rule = kzalloc(sizeof(struct flow_rule) +

               sizeof(struct flow_action_entry) * num_actions,

               GFP_KERNEL);

    if (!rule)

        return NULL;

​

    rule->action.num_entries = num_actions;

​

    return rule;

}

EXPORT_SYMBOL(flow_rule_alloc);

​

#define FLOW_DISSECTOR_MATCH(__rule, __type, __out)             \

    const struct flow_match *__m = &(__rule)->match;            \

    struct flow_dissector *__d = (__m)->dissector;              \

                                        \

    (__out)->key = skb_flow_dissector_target(__d, __type, (__m)->key);  \

    (__out)->mask = skb_flow_dissector_target(__d, __type, (__m)->mask);    \

​

void flow_rule_match_basic(const struct flow_rule *rule,

               struct flow_match_basic *out)

{

    FLOW_DISSECTOR_MATCH(rule, FLOW_DISSECTOR_KEY_BASIC, out);

}

EXPORT_SYMBOL(flow_rule_match_basic);

​

void flow_rule_match_control(const struct flow_rule *rule,

                 struct flow_match_control *out)

{

    FLOW_DISSECTOR_MATCH(rule, FLOW_DISSECTOR_KEY_CONTROL, out);

}

EXPORT_SYMBOL(flow_rule_match_control);

​

void flow_rule_match_eth_addrs(const struct flow_rule *rule,

                   struct flow_match_eth_addrs *out)

{

    FLOW_DISSECTOR_MATCH(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS, out);

}

EXPORT_SYMBOL(flow_rule_match_eth_addrs);

​

void flow_rule_match_vlan(const struct flow_rule *rule,

              struct flow_match_vlan *out)

{

    FLOW_DISSECTOR_MATCH(rule, FLOW_DISSECTOR_KEY_VLAN, out);

}

EXPORT_SYMBOL(flow_rule_match_vlan);

​

void flow_rule_match_ipv4_addrs(const struct flow_rule *rule,

                struct flow_match_ipv4_addrs *out)

{

    FLOW_DISSECTOR_MATCH(rule, FLOW_DISSECTOR_KEY_IPV4_ADDRS, out);

}

EXPORT_SYMBOL(flow_rule_match_ipv4_addrs);

​