include/net/flow_offload.h

   1 #ifndef _NET_FLOW_OFFLOAD_H
   2 #define _NET_FLOW_OFFLOAD_H
   3
   4 #include <linux/kernel.h>
   5 #include <linux/list.h>
   6 #include <net/flow_dissector.h>
   7 #include <linux/rhashtable.h>
   8
   9 struct flow_match {
  10         struct flow_dissector   *dissector;
  11         void                    *mask;
  12         void                    *key;
  13 };
  14
  15 struct flow_match_meta {
  16         struct flow_dissector_key_meta *key, *mask;
  17 };
  18
  19 struct flow_match_basic {
  20         struct flow_dissector_key_basic *key, *mask;
  21 };
  22
  23 struct flow_match_control {
  24         struct flow_dissector_key_control *key, *mask;
  25 };
  26
  27 struct flow_match_eth_addrs {
  28         struct flow_dissector_key_eth_addrs *key, *mask;
  29 };
  30
  31 struct flow_match_vlan {
  32         struct flow_dissector_key_vlan *key, *mask;
  33 };
  34
  35 struct flow_match_ipv4_addrs {
  36         struct flow_dissector_key_ipv4_addrs *key, *mask;
  37 };
  38
  39 struct flow_match_ipv6_addrs {
  40         struct flow_dissector_key_ipv6_addrs *key, *mask;
  41 };
  42
  43 struct flow_match_ip {
  44         struct flow_dissector_key_ip *key, *mask;
  45 };
  46
  47 struct flow_match_ports {
  48         struct flow_dissector_key_ports *key, *mask;
  49 };
  50
  51 struct flow_match_icmp {
  52         struct flow_dissector_key_icmp *key, *mask;
  53 };
  54
  55 struct flow_match_tcp {
  56         struct flow_dissector_key_tcp *key, *mask;
  57 };
  58
  59 struct flow_match_mpls {
  60         struct flow_dissector_key_mpls *key, *mask;
  61 };
  62
  63 struct flow_match_enc_keyid {
  64         struct flow_dissector_key_keyid *key, *mask;
  65 };
  66
  67 struct flow_match_enc_opts {
  68         struct flow_dissector_key_enc_opts *key, *mask;
  69 };
  70
  71 struct flow_rule;
  72
  73 void flow_rule_match_meta(const struct flow_rule *rule,
  74                           struct flow_match_meta *out);
  75 void flow_rule_match_basic(const struct flow_rule *rule,
  76                            struct flow_match_basic *out);
  77 void flow_rule_match_control(const struct flow_rule *rule,
  78                              struct flow_match_control *out);
  79 void flow_rule_match_eth_addrs(const struct flow_rule *rule,
  80                                struct flow_match_eth_addrs *out);
  81 void flow_rule_match_vlan(const struct flow_rule *rule,
  82                           struct flow_match_vlan *out);
  83 void flow_rule_match_cvlan(const struct flow_rule *rule,
  84                            struct flow_match_vlan *out);
  85 void flow_rule_match_ipv4_addrs(const struct flow_rule *rule,
  86                                 struct flow_match_ipv4_addrs *out);
  87 void flow_rule_match_ipv6_addrs(const struct flow_rule *rule,
  88                                 struct flow_match_ipv6_addrs *out);
  89 void flow_rule_match_ip(const struct flow_rule *rule,
  90                         struct flow_match_ip *out);
  91 void flow_rule_match_ports(const struct flow_rule *rule,
  92                            struct flow_match_ports *out);
  93 void flow_rule_match_tcp(const struct flow_rule *rule,
  94                          struct flow_match_tcp *out);
  95 void flow_rule_match_icmp(const struct flow_rule *rule,
  96                           struct flow_match_icmp *out);
  97 void flow_rule_match_mpls(const struct flow_rule *rule,
  98                           struct flow_match_mpls *out);
  99 void flow_rule_match_enc_control(const struct flow_rule *rule,
 100                                  struct flow_match_control *out);
 101 void flow_rule_match_enc_ipv4_addrs(const struct flow_rule *rule,
 102                                     struct flow_match_ipv4_addrs *out);
 103 void flow_rule_match_enc_ipv6_addrs(const struct flow_rule *rule,
 104                                     struct flow_match_ipv6_addrs *out);
 105 void flow_rule_match_enc_ip(const struct flow_rule *rule,
 106                             struct flow_match_ip *out);
 107 void flow_rule_match_enc_ports(const struct flow_rule *rule,
 108                                struct flow_match_ports *out);
 109 void flow_rule_match_enc_keyid(const struct flow_rule *rule,
 110                                struct flow_match_enc_keyid *out);
 111 void flow_rule_match_enc_opts(const struct flow_rule *rule,
 112                               struct flow_match_enc_opts *out);
 113
 114 enum flow_action_id {
 115         FLOW_ACTION_ACCEPT              = 0,
 116         FLOW_ACTION_DROP,
 117         FLOW_ACTION_TRAP,
 118         FLOW_ACTION_GOTO,
 119         FLOW_ACTION_REDIRECT,
 120         FLOW_ACTION_MIRRED,
 121         FLOW_ACTION_REDIRECT_INGRESS,
 122         FLOW_ACTION_MIRRED_INGRESS,
 123         FLOW_ACTION_VLAN_PUSH,
 124         FLOW_ACTION_VLAN_POP,
 125         FLOW_ACTION_VLAN_MANGLE,
 126         FLOW_ACTION_TUNNEL_ENCAP,
 127         FLOW_ACTION_TUNNEL_DECAP,
 128         FLOW_ACTION_MANGLE,
 129         FLOW_ACTION_ADD,
 130         FLOW_ACTION_CSUM,
 131         FLOW_ACTION_MARK,
 132         FLOW_ACTION_PTYPE,
 133         FLOW_ACTION_WAKE,
 134         FLOW_ACTION_QUEUE,
 135         FLOW_ACTION_SAMPLE,
 136         FLOW_ACTION_POLICE,
 137         FLOW_ACTION_CT,
 138         FLOW_ACTION_MPLS_PUSH,
 139         FLOW_ACTION_MPLS_POP,
 140         FLOW_ACTION_MPLS_MANGLE,
 141         NUM_FLOW_ACTIONS,
 142 };
 143
 144 /* This is mirroring enum pedit_header_type definition for easy mapping between
 145  * tc pedit action. Legacy TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK is mapped to
 146  * FLOW_ACT_MANGLE_UNSPEC, which is supported by no driver.
 147  */
 148 enum flow_action_mangle_base {
 149         FLOW_ACT_MANGLE_UNSPEC          = 0,
 150         FLOW_ACT_MANGLE_HDR_TYPE_ETH,
 151         FLOW_ACT_MANGLE_HDR_TYPE_IP4,
 152         FLOW_ACT_MANGLE_HDR_TYPE_IP6,
 153         FLOW_ACT_MANGLE_HDR_TYPE_TCP,
 154         FLOW_ACT_MANGLE_HDR_TYPE_UDP,
 155 };
 156
 157 typedef void (*action_destr)(void *priv);
 158
 159 struct flow_action_entry {
 160         enum flow_action_id             id;
 161         action_destr                    destructor;
 162         void                            *destructor_priv;
 163         union {
 164                 u32                     chain_index;    /* FLOW_ACTION_GOTO */
 165                 struct net_device       *dev;           /* FLOW_ACTION_REDIRECT */
 166                 struct {                                /* FLOW_ACTION_VLAN */
 167                         u16             vid;
 168                         __be16          proto;
 169                         u8              prio;
 170                 } vlan;
 171                 struct {                                /* FLOW_ACTION_PACKET_EDIT */
 172                         enum flow_action_mangle_base htype;
 173                         u32             offset;
 174                         u32             mask;
 175                         u32             val;
 176                 } mangle;
 177                 struct ip_tunnel_info   *tunnel;        /* FLOW_ACTION_TUNNEL_ENCAP */
 178                 u32                     csum_flags;     /* FLOW_ACTION_CSUM */
 179                 u32                     mark;           /* FLOW_ACTION_MARK */
 180                 u16                     ptype;          /* FLOW_ACTION_PTYPE */
 181                 struct {                                /* FLOW_ACTION_QUEUE */
 182                         u32             ctx;
 183                         u32             index;
 184                         u8              vf;
 185                 } queue;
 186                 struct {                                /* FLOW_ACTION_SAMPLE */
 187                         struct psample_group    *psample_group;
 188                         u32                     rate;
 189                         u32                     trunc_size;
 190                         bool                    truncate;
 191                 } sample;
 192                 struct {                                /* FLOW_ACTION_POLICE */
 193                         s64                     burst;
 194                         u64                     rate_bytes_ps;
 195                 } police;
 196                 struct {                                /* FLOW_ACTION_CT */
 197                         int action;
 198                         u16 zone;
 199                 } ct;
 200                 struct {                                /* FLOW_ACTION_MPLS_PUSH */
 201                         u32             label;
 202                         __be16          proto;
 203                         u8              tc;
 204                         u8              bos;
 205                         u8              ttl;
 206                 } mpls_push;
 207                 struct {                                /* FLOW_ACTION_MPLS_POP */
 208                         __be16          proto;
 209                 } mpls_pop;
 210                 struct {                                /* FLOW_ACTION_MPLS_MANGLE */
 211                         u32             label;
 212                         u8              tc;
 213                         u8              bos;
 214                         u8              ttl;
 215                 } mpls_mangle;
 216         };
 217 };
 218
 219 struct flow_action {
 220         unsigned int                    num_entries;
 221         struct flow_action_entry        entries[0];
 222 };
 223
 224 static inline bool flow_action_has_entries(const struct flow_action *action)
 225 {
 226         return action->num_entries;
 227 }
 228
 229 /**
 230  * flow_action_has_one_action() - check if exactly one action is present
 231  * @action: tc filter flow offload action
 232  *
 233  * Returns true if exactly one action is present.
 234  */
 235 static inline bool flow_offload_has_one_action(const struct flow_action *action)
 236 {
 237         return action->num_entries == 1;
 238 }
 239
 240 #define flow_action_for_each(__i, __act, __actions)                     \
 241         for (__i = 0, __act = &(__actions)->entries[0]; __i < (__actions)->num_entries; __act = &(__actions)->entries[++__i])
 242
 243 struct flow_rule {
 244         struct flow_match       match;
 245         struct flow_action      action;
 246 };
 247
 248 struct flow_rule *flow_rule_alloc(unsigned int num_actions);
 249
 250 static inline bool flow_rule_match_key(const struct flow_rule *rule,
 251                                        enum flow_dissector_key_id key)
 252 {
 253         return dissector_uses_key(rule->match.dissector, key);
 254 }
 255
 256 struct flow_stats {
 257         u64     pkts;
 258         u64     bytes;
 259         u64     lastused;
 260 };
 261
 262 static inline void flow_stats_update(struct flow_stats *flow_stats,
 263                                      u64 bytes, u64 pkts, u64 lastused)
 264 {
 265         flow_stats->pkts        += pkts;
 266         flow_stats->bytes       += bytes;
 267         flow_stats->lastused    = max_t(u64, flow_stats->lastused, lastused);
 268 }
 269
 270 enum flow_block_command {
 271         FLOW_BLOCK_BIND,
 272         FLOW_BLOCK_UNBIND,
 273 };
 274
 275 enum flow_block_binder_type {
 276         FLOW_BLOCK_BINDER_TYPE_UNSPEC,
 277         FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS,
 278         FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS,
 279 };
 280
 281 struct flow_block {
 282         struct list_head cb_list;
 283 };
 284
 285 struct netlink_ext_ack;
 286
 287 struct flow_block_offload {
 288         enum flow_block_command command;
 289         enum flow_block_binder_type binder_type;
 290         bool block_shared;
 291         bool unlocked_driver_cb;
 292         struct net *net;
 293         struct flow_block *block;
 294         struct list_head cb_list;
 295         struct list_head *driver_block_list;
 296         struct netlink_ext_ack *extack;
 297 };
 298
 299 enum tc_setup_type;
 300 typedef int flow_setup_cb_t(enum tc_setup_type type, void *type_data,
 301                             void *cb_priv);
 302
 303 struct flow_block_cb {
 304         struct list_head        driver_list;
 305         struct list_head        list;
 306         flow_setup_cb_t         *cb;
 307         void                    *cb_ident;
 308         void                    *cb_priv;
 309         void                    (*release)(void *cb_priv);
 310         unsigned int            refcnt;
 311 };
 312
 313 struct flow_block_cb *flow_block_cb_alloc(flow_setup_cb_t *cb,
 314                                           void *cb_ident, void *cb_priv,
 315                                           void (*release)(void *cb_priv));
 316 void flow_block_cb_free(struct flow_block_cb *block_cb);
 317
 318 struct flow_block_cb *flow_block_cb_lookup(struct flow_block *block,
 319                                            flow_setup_cb_t *cb, void *cb_ident);
 320
 321 void *flow_block_cb_priv(struct flow_block_cb *block_cb);
 322 void flow_block_cb_incref(struct flow_block_cb *block_cb);
 323 unsigned int flow_block_cb_decref(struct flow_block_cb *block_cb);
 324
 325 static inline void flow_block_cb_add(struct flow_block_cb *block_cb,
 326                                      struct flow_block_offload *offload)
 327 {
 328         list_add_tail(&block_cb->list, &offload->cb_list);
 329 }
 330
 331 static inline void flow_block_cb_remove(struct flow_block_cb *block_cb,
 332                                         struct flow_block_offload *offload)
 333 {
 334         list_move(&block_cb->list, &offload->cb_list);
 335 }
 336
 337 bool flow_block_cb_is_busy(flow_setup_cb_t *cb, void *cb_ident,
 338                            struct list_head *driver_block_list);
 339
 340 int flow_block_cb_setup_simple(struct flow_block_offload *f,
 341                                struct list_head *driver_list,
 342                                flow_setup_cb_t *cb,
 343                                void *cb_ident, void *cb_priv, bool ingress_only);
 344
 345 enum flow_cls_command {
 346         FLOW_CLS_REPLACE,
 347         FLOW_CLS_DESTROY,
 348         FLOW_CLS_STATS,
 349         FLOW_CLS_TMPLT_CREATE,
 350         FLOW_CLS_TMPLT_DESTROY,
 351 };
 352
 353 struct flow_cls_common_offload {
 354         u32 chain_index;
 355         __be16 protocol;
 356         u32 prio;
 357         struct netlink_ext_ack *extack;
 358 };
 359
 360 struct flow_cls_offload {
 361         struct flow_cls_common_offload common;
 362         enum flow_cls_command command;
 363         unsigned long cookie;
 364         struct flow_rule *rule;
 365         struct flow_stats stats;
 366         u32 classid;
 367 };
 368
 369 static inline struct flow_rule *
 370 flow_cls_offload_flow_rule(struct flow_cls_offload *flow_cmd)
 371 {
 372         return flow_cmd->rule;
 373 }
 374
 375 static inline void flow_block_init(struct flow_block *flow_block)
 376 {
 377         INIT_LIST_HEAD(&flow_block->cb_list);
 378 }
 379
 380 typedef int flow_indr_block_bind_cb_t(struct net_device *dev, void *cb_priv,
 381                                       enum tc_setup_type type, void *type_data);
 382
 383 typedef void flow_indr_block_cmd_t(struct net_device *dev,
 384                                    flow_indr_block_bind_cb_t *cb, void *cb_priv,
 385                                    enum flow_block_command command);
 386
 387 struct flow_indr_block_entry {
 388         flow_indr_block_cmd_t *cb;
 389         struct list_head        list;
 390 };
 391
 392 void flow_indr_add_block_cb(struct flow_indr_block_entry *entry);
 393
 394 void flow_indr_del_block_cb(struct flow_indr_block_entry *entry);
 395
 396 int __flow_indr_block_cb_register(struct net_device *dev, void *cb_priv,
 397                                   flow_indr_block_bind_cb_t *cb,
 398                                   void *cb_ident);
 399
 400 void __flow_indr_block_cb_unregister(struct net_device *dev,
 401                                      flow_indr_block_bind_cb_t *cb,
 402                                      void *cb_ident);
 403
 404 int flow_indr_block_cb_register(struct net_device *dev, void *cb_priv,
 405                                 flow_indr_block_bind_cb_t *cb, void *cb_ident);
 406
 407 void flow_indr_block_cb_unregister(struct net_device *dev,
 408                                    flow_indr_block_bind_cb_t *cb,
 409                                    void *cb_ident);
 410
 411 void flow_indr_block_call(struct net_device *dev,
 412                           struct flow_block_offload *bo,
 413                           enum flow_block_command command);
 414
 415 #endif /* _NET_FLOW_OFFLOAD_H */