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         FLOW_ACTION_SAMPLE,
 122         FLOW_ACTION_POLICE,
 123 };
 124
 125 /* This is mirroring enum pedit_header_type definition for easy mapping between
 126  * tc pedit action. Legacy TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK is mapped to
 127  * FLOW_ACT_MANGLE_UNSPEC, which is supported by no driver.
 128  */
 129 enum flow_action_mangle_base {
 130         FLOW_ACT_MANGLE_UNSPEC          = 0,
 131         FLOW_ACT_MANGLE_HDR_TYPE_ETH,
 132         FLOW_ACT_MANGLE_HDR_TYPE_IP4,
 133         FLOW_ACT_MANGLE_HDR_TYPE_IP6,
 134         FLOW_ACT_MANGLE_HDR_TYPE_TCP,
 135         FLOW_ACT_MANGLE_HDR_TYPE_UDP,
 136 };
 137
 138 struct flow_action_entry {
 139         enum flow_action_id             id;
 140         union {
 141                 u32                     chain_index;    /* FLOW_ACTION_GOTO */
 142                 struct net_device       *dev;           /* FLOW_ACTION_REDIRECT */
 143                 struct {                                /* FLOW_ACTION_VLAN */
 144                         u16             vid;
 145                         __be16          proto;
 146                         u8              prio;
 147                 } vlan;
 148                 struct {                                /* FLOW_ACTION_PACKET_EDIT */
 149                         enum flow_action_mangle_base htype;
 150                         u32             offset;
 151                         u32             mask;
 152                         u32             val;
 153                 } mangle;
 154                 const struct ip_tunnel_info *tunnel;    /* FLOW_ACTION_TUNNEL_ENCAP */
 155                 u32                     csum_flags;     /* FLOW_ACTION_CSUM */
 156                 u32                     mark;           /* FLOW_ACTION_MARK */
 157                 struct {                                /* FLOW_ACTION_QUEUE */
 158                         u32             ctx;
 159                         u32             index;
 160                         u8              vf;
 161                 } queue;
 162                 struct {                                /* FLOW_ACTION_SAMPLE */
 163                         struct psample_group    *psample_group;
 164                         u32                     rate;
 165                         u32                     trunc_size;
 166                         bool                    truncate;
 167                 } sample;
 168                 struct {                                /* FLOW_ACTION_POLICE */
 169                         s64                     burst;
 170                         u64                     rate_bytes_ps;
 171                 } police;
 172         };
 173 };
 174
 175 struct flow_action {
 176         unsigned int                    num_entries;
 177         struct flow_action_entry        entries[0];
 178 };
 179
 180 static inline bool flow_action_has_entries(const struct flow_action *action)
 181 {
 182         return action->num_entries;
 183 }
 184
 185 /**
 186  * flow_action_has_one_action() - check if exactly one action is present
 187  * @action: tc filter flow offload action
 188  *
 189  * Returns true if exactly one action is present.
 190  */
 191 static inline bool flow_offload_has_one_action(const struct flow_action *action)
 192 {
 193         return action->num_entries == 1;
 194 }
 195
 196 #define flow_action_for_each(__i, __act, __actions)                     \
 197         for (__i = 0, __act = &(__actions)->entries[0]; __i < (__actions)->num_entries; __act = &(__actions)->entries[++__i])
 198
 199 struct flow_rule {
 200         struct flow_match       match;
 201         struct flow_action      action;
 202 };
 203
 204 struct flow_rule *flow_rule_alloc(unsigned int num_actions);
 205
 206 static inline bool flow_rule_match_key(const struct flow_rule *rule,
 207                                        enum flow_dissector_key_id key)
 208 {
 209         return dissector_uses_key(rule->match.dissector, key);
 210 }
 211
 212 struct flow_stats {
 213         u64     pkts;
 214         u64     bytes;
 215         u64     lastused;
 216 };
 217
 218 static inline void flow_stats_update(struct flow_stats *flow_stats,
 219                                      u64 bytes, u64 pkts, u64 lastused)
 220 {
 221         flow_stats->pkts        += pkts;
 222         flow_stats->bytes       += bytes;
 223         flow_stats->lastused    = max_t(u64, flow_stats->lastused, lastused);
 224 }
 225
 226 #endif /* _NET_FLOW_OFFLOAD_H */