include/net/flow_offload.h

   1 #ifndef _NET_FLOW_OFFLOAD_H
   2 #define _NET_FLOW_OFFLOAD_H
   3
   4 #include <net/flow_dissector.h>
   5
   6 struct flow_match {
   7         struct flow_dissector   *dissector;
   8         void                    *mask;
   9         void                    *key;
  10 };
  11
  12 struct flow_match_basic {
  13         struct flow_dissector_key_basic *key, *mask;
  14 };
  15
  16 struct flow_match_control {
  17         struct flow_dissector_key_control *key, *mask;
  18 };
  19
  20 struct flow_match_eth_addrs {
  21         struct flow_dissector_key_eth_addrs *key, *mask;
  22 };
  23
  24 struct flow_match_vlan {
  25         struct flow_dissector_key_vlan *key, *mask;
  26 };
  27
  28 struct flow_match_ipv4_addrs {
  29         struct flow_dissector_key_ipv4_addrs *key, *mask;
  30 };
  31
  32 struct flow_match_ipv6_addrs {
  33         struct flow_dissector_key_ipv6_addrs *key, *mask;
  34 };
  35
  36 struct flow_match_ip {
  37         struct flow_dissector_key_ip *key, *mask;
  38 };
  39
  40 struct flow_match_ports {
  41         struct flow_dissector_key_ports *key, *mask;
  42 };
  43
  44 struct flow_match_icmp {
  45         struct flow_dissector_key_icmp *key, *mask;
  46 };
  47
  48 struct flow_match_tcp {
  49         struct flow_dissector_key_tcp *key, *mask;
  50 };
  51
  52 struct flow_match_mpls {
  53         struct flow_dissector_key_mpls *key, *mask;
  54 };
  55
  56 struct flow_match_enc_keyid {
  57         struct flow_dissector_key_keyid *key, *mask;
  58 };
  59
  60 struct flow_match_enc_opts {
  61         struct flow_dissector_key_enc_opts *key, *mask;
  62 };
  63
  64 struct flow_rule;
  65
  66 void flow_rule_match_basic(const struct flow_rule *rule,
  67                            struct flow_match_basic *out);
  68 void flow_rule_match_control(const struct flow_rule *rule,
  69                              struct flow_match_control *out);
  70 void flow_rule_match_eth_addrs(const struct flow_rule *rule,
  71                                struct flow_match_eth_addrs *out);
  72 void flow_rule_match_vlan(const struct flow_rule *rule,
  73                           struct flow_match_vlan *out);
  74 void flow_rule_match_ipv4_addrs(const struct flow_rule *rule,
  75                                 struct flow_match_ipv4_addrs *out);
  76 void flow_rule_match_ipv6_addrs(const struct flow_rule *rule,
  77                                 struct flow_match_ipv6_addrs *out);
  78 void flow_rule_match_ip(const struct flow_rule *rule,
  79                         struct flow_match_ip *out);
  80 void flow_rule_match_ports(const struct flow_rule *rule,
  81                            struct flow_match_ports *out);
  82 void flow_rule_match_tcp(const struct flow_rule *rule,
  83                          struct flow_match_tcp *out);
  84 void flow_rule_match_icmp(const struct flow_rule *rule,
  85                           struct flow_match_icmp *out);
  86 void flow_rule_match_mpls(const struct flow_rule *rule,
  87                           struct flow_match_mpls *out);
  88 void flow_rule_match_enc_control(const struct flow_rule *rule,
  89                                  struct flow_match_control *out);
  90 void flow_rule_match_enc_ipv4_addrs(const struct flow_rule *rule,
  91                                     struct flow_match_ipv4_addrs *out);
  92 void flow_rule_match_enc_ipv6_addrs(const struct flow_rule *rule,
  93                                     struct flow_match_ipv6_addrs *out);
  94 void flow_rule_match_enc_ip(const struct flow_rule *rule,
  95                             struct flow_match_ip *out);
  96 void flow_rule_match_enc_ports(const struct flow_rule *rule,
  97                                struct flow_match_ports *out);
  98 void flow_rule_match_enc_keyid(const struct flow_rule *rule,
  99                                struct flow_match_enc_keyid *out);
 100 void flow_rule_match_enc_opts(const struct flow_rule *rule,
 101                               struct flow_match_enc_opts *out);
 102
 103 enum flow_action_id {
 104         FLOW_ACTION_ACCEPT              = 0,
 105         FLOW_ACTION_DROP,
 106         FLOW_ACTION_TRAP,
 107         FLOW_ACTION_GOTO,
 108         FLOW_ACTION_REDIRECT,
 109         FLOW_ACTION_MIRRED,
 110         FLOW_ACTION_VLAN_PUSH,
 111         FLOW_ACTION_VLAN_POP,
 112         FLOW_ACTION_VLAN_MANGLE,
 113         FLOW_ACTION_TUNNEL_ENCAP,
 114         FLOW_ACTION_TUNNEL_DECAP,
 115         FLOW_ACTION_MANGLE,
 116         FLOW_ACTION_ADD,
 117         FLOW_ACTION_CSUM,
 118         FLOW_ACTION_MARK,
 119         FLOW_ACTION_WAKE,
 120         FLOW_ACTION_QUEUE,
 121 };
 122
 123 /* This is mirroring enum pedit_header_type definition for easy mapping between
 124  * tc pedit action. Legacy TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK is mapped to
 125  * FLOW_ACT_MANGLE_UNSPEC, which is supported by no driver.
 126  */
 127 enum flow_action_mangle_base {
 128         FLOW_ACT_MANGLE_UNSPEC          = 0,
 129         FLOW_ACT_MANGLE_HDR_TYPE_ETH,
 130         FLOW_ACT_MANGLE_HDR_TYPE_IP4,
 131         FLOW_ACT_MANGLE_HDR_TYPE_IP6,
 132         FLOW_ACT_MANGLE_HDR_TYPE_TCP,
 133         FLOW_ACT_MANGLE_HDR_TYPE_UDP,
 134 };
 135
 136 struct flow_action_entry {
 137         enum flow_action_id             id;
 138         union {
 139                 u32                     chain_index;    /* FLOW_ACTION_GOTO */
 140                 struct net_device       *dev;           /* FLOW_ACTION_REDIRECT */
 141                 struct {                                /* FLOW_ACTION_VLAN */
 142                         u16             vid;
 143                         __be16          proto;
 144                         u8              prio;
 145                 } vlan;
 146                 struct {                                /* FLOW_ACTION_PACKET_EDIT */
 147                         enum flow_action_mangle_base htype;
 148                         u32             offset;
 149                         u32             mask;
 150                         u32             val;
 151                 } mangle;
 152                 const struct ip_tunnel_info *tunnel;    /* FLOW_ACTION_TUNNEL_ENCAP */
 153                 u32                     csum_flags;     /* FLOW_ACTION_CSUM */
 154                 u32                     mark;           /* FLOW_ACTION_MARK */
 155                 struct {                                /* FLOW_ACTION_QUEUE */
 156                         u32             ctx;
 157                         u32             index;
 158                         u8              vf;
 159                 } queue;
 160         };
 161 };
 162
 163 struct flow_action {
 164         unsigned int                    num_entries;
 165         struct flow_action_entry        entries[0];
 166 };
 167
 168 static inline bool flow_action_has_entries(const struct flow_action *action)
 169 {
 170         return action->num_entries;
 171 }
 172
 173 #define flow_action_for_each(__i, __act, __actions)                     \
 174         for (__i = 0, __act = &(__actions)->entries[0]; __i < (__actions)->num_entries; __act = &(__actions)->entries[++__i])
 175
 176 struct flow_rule {
 177         struct flow_match       match;
 178         struct flow_action      action;
 179 };
 180
 181 struct flow_rule *flow_rule_alloc(unsigned int num_actions);
 182
 183 static inline bool flow_rule_match_key(const struct flow_rule *rule,
 184                                        enum flow_dissector_key_id key)
 185 {
 186         return dissector_uses_key(rule->match.dissector, key);
 187 }
 188
 189 struct flow_stats {
 190         u64     pkts;
 191         u64     bytes;
 192         u64     lastused;
 193 };
 194
 195 static inline void flow_stats_update(struct flow_stats *flow_stats,
 196                                      u64 bytes, u64 pkts, u64 lastused)
 197 {
 198         flow_stats->pkts        += pkts;
 199         flow_stats->bytes       += bytes;
 200         flow_stats->lastused    = max_t(u64, flow_stats->lastused, lastused);
 201 }
 202
 203 #endif /* _NET_FLOW_OFFLOAD_H */