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_cookie {
 160         u32 cookie_len;
 161         u8 cookie[];
 162 };
 163
 164 struct flow_action_cookie *flow_action_cookie_create(void *data,
 165                                                      unsigned int len,
 166                                                      gfp_t gfp);
 167 void flow_action_cookie_destroy(struct flow_action_cookie *cookie);
 168
 169 struct flow_action_entry {
 170         enum flow_action_id             id;
 171         action_destr                    destructor;
 172         void                            *destructor_priv;
 173         union {
 174                 u32                     chain_index;    /* FLOW_ACTION_GOTO */
 175                 struct net_device       *dev;           /* FLOW_ACTION_REDIRECT */
 176                 struct {                                /* FLOW_ACTION_VLAN */
 177                         u16             vid;
 178                         __be16          proto;
 179                         u8              prio;
 180                 } vlan;
 181                 struct {                                /* FLOW_ACTION_PACKET_EDIT */
 182                         enum flow_action_mangle_base htype;
 183                         u32             offset;
 184                         u32             mask;
 185                         u32             val;
 186                 } mangle;
 187                 struct ip_tunnel_info   *tunnel;        /* FLOW_ACTION_TUNNEL_ENCAP */
 188                 u32                     csum_flags;     /* FLOW_ACTION_CSUM */
 189                 u32                     mark;           /* FLOW_ACTION_MARK */
 190                 u16                     ptype;          /* FLOW_ACTION_PTYPE */
 191                 struct {                                /* FLOW_ACTION_QUEUE */
 192                         u32             ctx;
 193                         u32             index;
 194                         u8              vf;
 195                 } queue;
 196                 struct {                                /* FLOW_ACTION_SAMPLE */
 197                         struct psample_group    *psample_group;
 198                         u32                     rate;
 199                         u32                     trunc_size;
 200                         bool                    truncate;
 201                 } sample;
 202                 struct {                                /* FLOW_ACTION_POLICE */
 203                         s64                     burst;
 204                         u64                     rate_bytes_ps;
 205                 } police;
 206                 struct {                                /* FLOW_ACTION_CT */
 207                         int action;
 208                         u16 zone;
 209                 } ct;
 210                 struct {                                /* FLOW_ACTION_MPLS_PUSH */
 211                         u32             label;
 212                         __be16          proto;
 213                         u8              tc;
 214                         u8              bos;
 215                         u8              ttl;
 216                 } mpls_push;
 217                 struct {                                /* FLOW_ACTION_MPLS_POP */
 218                         __be16          proto;
 219                 } mpls_pop;
 220                 struct {                                /* FLOW_ACTION_MPLS_MANGLE */
 221                         u32             label;
 222                         u8              tc;
 223                         u8              bos;
 224                         u8              ttl;
 225                 } mpls_mangle;
 226         };
 227         struct flow_action_cookie *cookie; /* user defined action cookie */
 228 };
 229
 230 struct flow_action {
 231         unsigned int                    num_entries;
 232         struct flow_action_entry        entries[0];
 233 };
 234
 235 static inline bool flow_action_has_entries(const struct flow_action *action)
 236 {
 237         return action->num_entries;
 238 }
 239
 240 /**
 241  * flow_action_has_one_action() - check if exactly one action is present
 242  * @action: tc filter flow offload action
 243  *
 244  * Returns true if exactly one action is present.
 245  */
 246 static inline bool flow_offload_has_one_action(const struct flow_action *action)
 247 {
 248         return action->num_entries == 1;
 249 }
 250
 251 #define flow_action_for_each(__i, __act, __actions)                     \
 252         for (__i = 0, __act = &(__actions)->entries[0]; __i < (__actions)->num_entries; __act = &(__actions)->entries[++__i])
 253
 254 struct flow_rule {
 255         struct flow_match       match;
 256         struct flow_action      action;
 257 };
 258
 259 struct flow_rule *flow_rule_alloc(unsigned int num_actions);
 260
 261 static inline bool flow_rule_match_key(const struct flow_rule *rule,
 262                                        enum flow_dissector_key_id key)
 263 {
 264         return dissector_uses_key(rule->match.dissector, key);
 265 }
 266
 267 struct flow_stats {
 268         u64     pkts;
 269         u64     bytes;
 270         u64     lastused;
 271 };
 272
 273 static inline void flow_stats_update(struct flow_stats *flow_stats,
 274                                      u64 bytes, u64 pkts, u64 lastused)
 275 {
 276         flow_stats->pkts        += pkts;
 277         flow_stats->bytes       += bytes;
 278         flow_stats->lastused    = max_t(u64, flow_stats->lastused, lastused);
 279 }
 280
 281 enum flow_block_command {
 282         FLOW_BLOCK_BIND,
 283         FLOW_BLOCK_UNBIND,
 284 };
 285
 286 enum flow_block_binder_type {
 287         FLOW_BLOCK_BINDER_TYPE_UNSPEC,
 288         FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS,
 289         FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS,
 290 };
 291
 292 struct flow_block {
 293         struct list_head cb_list;
 294 };
 295
 296 struct netlink_ext_ack;
 297
 298 struct flow_block_offload {
 299         enum flow_block_command command;
 300         enum flow_block_binder_type binder_type;
 301         bool block_shared;
 302         bool unlocked_driver_cb;
 303         struct net *net;
 304         struct flow_block *block;
 305         struct list_head cb_list;
 306         struct list_head *driver_block_list;
 307         struct netlink_ext_ack *extack;
 308 };
 309
 310 enum tc_setup_type;
 311 typedef int flow_setup_cb_t(enum tc_setup_type type, void *type_data,
 312                             void *cb_priv);
 313
 314 struct flow_block_cb {
 315         struct list_head        driver_list;
 316         struct list_head        list;
 317         flow_setup_cb_t         *cb;
 318         void                    *cb_ident;
 319         void                    *cb_priv;
 320         void                    (*release)(void *cb_priv);
 321         unsigned int            refcnt;
 322 };
 323
 324 struct flow_block_cb *flow_block_cb_alloc(flow_setup_cb_t *cb,
 325                                           void *cb_ident, void *cb_priv,
 326                                           void (*release)(void *cb_priv));
 327 void flow_block_cb_free(struct flow_block_cb *block_cb);
 328
 329 struct flow_block_cb *flow_block_cb_lookup(struct flow_block *block,
 330                                            flow_setup_cb_t *cb, void *cb_ident);
 331
 332 void *flow_block_cb_priv(struct flow_block_cb *block_cb);
 333 void flow_block_cb_incref(struct flow_block_cb *block_cb);
 334 unsigned int flow_block_cb_decref(struct flow_block_cb *block_cb);
 335
 336 static inline void flow_block_cb_add(struct flow_block_cb *block_cb,
 337                                      struct flow_block_offload *offload)
 338 {
 339         list_add_tail(&block_cb->list, &offload->cb_list);
 340 }
 341
 342 static inline void flow_block_cb_remove(struct flow_block_cb *block_cb,
 343                                         struct flow_block_offload *offload)
 344 {
 345         list_move(&block_cb->list, &offload->cb_list);
 346 }
 347
 348 bool flow_block_cb_is_busy(flow_setup_cb_t *cb, void *cb_ident,
 349                            struct list_head *driver_block_list);
 350
 351 int flow_block_cb_setup_simple(struct flow_block_offload *f,
 352                                struct list_head *driver_list,
 353                                flow_setup_cb_t *cb,
 354                                void *cb_ident, void *cb_priv, bool ingress_only);
 355
 356 enum flow_cls_command {
 357         FLOW_CLS_REPLACE,
 358         FLOW_CLS_DESTROY,
 359         FLOW_CLS_STATS,
 360         FLOW_CLS_TMPLT_CREATE,
 361         FLOW_CLS_TMPLT_DESTROY,
 362 };
 363
 364 struct flow_cls_common_offload {
 365         u32 chain_index;
 366         __be16 protocol;
 367         u32 prio;
 368         struct netlink_ext_ack *extack;
 369 };
 370
 371 struct flow_cls_offload {
 372         struct flow_cls_common_offload common;
 373         enum flow_cls_command command;
 374         unsigned long cookie;
 375         struct flow_rule *rule;
 376         struct flow_stats stats;
 377         u32 classid;
 378 };
 379
 380 static inline struct flow_rule *
 381 flow_cls_offload_flow_rule(struct flow_cls_offload *flow_cmd)
 382 {
 383         return flow_cmd->rule;
 384 }
 385
 386 static inline void flow_block_init(struct flow_block *flow_block)
 387 {
 388         INIT_LIST_HEAD(&flow_block->cb_list);
 389 }
 390
 391 typedef int flow_indr_block_bind_cb_t(struct net_device *dev, void *cb_priv,
 392                                       enum tc_setup_type type, void *type_data);
 393
 394 typedef void flow_indr_block_cmd_t(struct net_device *dev,
 395                                    flow_indr_block_bind_cb_t *cb, void *cb_priv,
 396                                    enum flow_block_command command);
 397
 398 struct flow_indr_block_entry {
 399         flow_indr_block_cmd_t *cb;
 400         struct list_head        list;
 401 };
 402
 403 void flow_indr_add_block_cb(struct flow_indr_block_entry *entry);
 404
 405 void flow_indr_del_block_cb(struct flow_indr_block_entry *entry);
 406
 407 int __flow_indr_block_cb_register(struct net_device *dev, void *cb_priv,
 408                                   flow_indr_block_bind_cb_t *cb,
 409                                   void *cb_ident);
 410
 411 void __flow_indr_block_cb_unregister(struct net_device *dev,
 412                                      flow_indr_block_bind_cb_t *cb,
 413                                      void *cb_ident);
 414
 415 int flow_indr_block_cb_register(struct net_device *dev, void *cb_priv,
 416                                 flow_indr_block_bind_cb_t *cb, void *cb_ident);
 417
 418 void flow_indr_block_cb_unregister(struct net_device *dev,
 419                                    flow_indr_block_bind_cb_t *cb,
 420                                    void *cb_ident);
 421
 422 void flow_indr_block_call(struct net_device *dev,
 423                           struct flow_block_offload *bo,
 424                           enum flow_block_command command);
 425
 426 #endif /* _NET_FLOW_OFFLOAD_H */