lib/tc.h

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Nicira, Inc.
   3  * Copyright (c) 2016 Mellanox Technologies, Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #ifndef TC_H
  19 #define TC_H 1
  20
  21 #include <sys/types.h>
  22 #include <netinet/in.h> /* Must happen before linux/pkt_cls.h - Glibc #20215 */
  23 #include <linux/pkt_cls.h>
  24 #include <linux/pkt_sched.h>
  25
  26 #include "netlink-socket.h"
  27 #include "odp-netlink.h"
  28 #include "openvswitch/ofpbuf.h"
  29 #include "openvswitch/flow.h"
  30 #include "openvswitch/tun-metadata.h"
  31
  32 /* For backwards compatability with older kernels */
  33 #ifndef TC_H_CLSACT
  34 #define TC_H_CLSACT    TC_H_INGRESS
  35 #endif
  36 #ifndef TC_H_MIN_INGRESS
  37 #define TC_H_MIN_INGRESS       0xFFF2U
  38 #endif
  39 #ifndef TC_H_MIN_EGRESS
  40 #define TC_H_MIN_EGRESS       0xFFF3U
  41 #endif
  42
  43 #define TC_INGRESS_PARENT TC_H_MAKE(TC_H_CLSACT, TC_H_MIN_INGRESS)
  44 #define TC_EGRESS_PARENT TC_H_MAKE(TC_H_CLSACT, TC_H_MIN_EGRESS)
  45
  46 #define TC_POLICY_DEFAULT "none"
  47
  48 enum tc_flower_reserved_prio {
  49     TC_RESERVED_PRIORITY_NONE,
  50     TC_RESERVED_PRIORITY_POLICE,
  51     __TC_RESERVED_PRIORITY_MAX
  52 };
  53 #define TC_RESERVED_PRIORITY_MAX (__TC_RESERVED_PRIORITY_MAX -1)
  54
  55 enum tc_qdisc_hook {
  56     TC_INGRESS,
  57     TC_EGRESS,
  58 };
  59
  60 /* Returns tc handle 'major':'minor'. */
  61 static inline unsigned int
  62 tc_make_handle(unsigned int major, unsigned int minor)
  63 {
  64     return TC_H_MAKE(major << 16, minor);
  65 }
  66
  67 /* Returns the major number from 'handle'. */
  68 static inline unsigned int
  69 tc_get_major(unsigned int handle)
  70 {
  71     return TC_H_MAJ(handle) >> 16;
  72 }
  73
  74 /* Returns the minor number from 'handle'. */
  75 static inline unsigned int
  76 tc_get_minor(unsigned int handle)
  77 {
  78     return TC_H_MIN(handle);
  79 }
  80
  81 struct tcmsg *tc_make_request(int ifindex, int type,
  82                               unsigned int flags, struct ofpbuf *);
  83 int tc_transact(struct ofpbuf *request, struct ofpbuf **replyp);
  84 int tc_add_del_qdisc(int ifindex, bool add, uint32_t block_id,
  85                      enum tc_qdisc_hook hook);
  86
  87 struct tc_cookie {
  88     const void *data;
  89     size_t len;
  90 };
  91
  92 struct tc_flower_key {
  93     ovs_be16 eth_type;
  94     uint8_t ip_proto;
  95
  96     struct eth_addr dst_mac;
  97     struct eth_addr src_mac;
  98
  99     ovs_be32 mpls_lse;
 100     ovs_be16 tcp_src;
 101     ovs_be16 tcp_dst;
 102     ovs_be16 tcp_flags;
 103
 104     ovs_be16 udp_src;
 105     ovs_be16 udp_dst;
 106
 107     ovs_be16 sctp_src;
 108     ovs_be16 sctp_dst;
 109
 110     uint16_t vlan_id[FLOW_MAX_VLAN_HEADERS];
 111     uint8_t vlan_prio[FLOW_MAX_VLAN_HEADERS];
 112
 113     ovs_be16 encap_eth_type[FLOW_MAX_VLAN_HEADERS];
 114
 115     uint8_t flags;
 116     uint8_t ip_ttl;
 117     uint8_t ip_tos;
 118
 119     uint16_t ct_state;
 120     uint16_t ct_zone;
 121     uint32_t ct_mark;
 122     ovs_u128 ct_label;
 123
 124     struct {
 125         ovs_be32 spa;
 126         ovs_be32 tpa;
 127         struct eth_addr sha;
 128         struct eth_addr tha;
 129         uint8_t opcode;
 130     } arp;
 131
 132     struct {
 133         ovs_be32 ipv4_src;
 134         ovs_be32 ipv4_dst;
 135         uint8_t rewrite_ttl;
 136         uint8_t rewrite_tos;
 137     } ipv4;
 138     struct {
 139         struct in6_addr ipv6_src;
 140         struct in6_addr ipv6_dst;
 141         uint8_t rewrite_hlimit;
 142         uint8_t rewrite_tclass;
 143     } ipv6;
 144
 145     struct {
 146         struct {
 147             ovs_be32 ipv4_src;
 148             ovs_be32 ipv4_dst;
 149         } ipv4;
 150         struct {
 151             struct in6_addr ipv6_src;
 152             struct in6_addr ipv6_dst;
 153         } ipv6;
 154         uint8_t tos;
 155         uint8_t ttl;
 156         ovs_be16 tp_src;
 157         ovs_be16 tp_dst;
 158         ovs_be64 id;
 159         struct tun_metadata metadata;
 160     } tunnel;
 161 };
 162
 163 enum tc_action_type {
 164     TC_ACT_OUTPUT,
 165     TC_ACT_ENCAP,
 166     TC_ACT_PEDIT,
 167     TC_ACT_VLAN_POP,
 168     TC_ACT_VLAN_PUSH,
 169     TC_ACT_MPLS_POP,
 170     TC_ACT_MPLS_PUSH,
 171     TC_ACT_MPLS_SET,
 172     TC_ACT_GOTO,
 173     TC_ACT_CT,
 174 };
 175
 176 enum nat_type {
 177     TC_NO_NAT = 0,
 178     TC_NAT_SRC,
 179     TC_NAT_DST,
 180     TC_NAT_RESTORE,
 181 };
 182
 183 struct tc_action {
 184     union {
 185         int chain;
 186
 187         struct {
 188             int ifindex_out;
 189             bool ingress;
 190         } out;
 191
 192         struct {
 193             ovs_be16 vlan_push_tpid;
 194             uint16_t vlan_push_id;
 195             uint8_t vlan_push_prio;
 196         } vlan;
 197
 198         struct {
 199             ovs_be16 proto;
 200             uint32_t label;
 201             uint8_t tc;
 202             uint8_t ttl;
 203             uint8_t bos;
 204         } mpls;
 205
 206         struct {
 207             bool id_present;
 208             ovs_be64 id;
 209             ovs_be16 tp_src;
 210             ovs_be16 tp_dst;
 211             uint8_t tos;
 212             uint8_t ttl;
 213             uint8_t no_csum;
 214             struct {
 215                 ovs_be32 ipv4_src;
 216                 ovs_be32 ipv4_dst;
 217             } ipv4;
 218             struct {
 219                 struct in6_addr ipv6_src;
 220                 struct in6_addr ipv6_dst;
 221             } ipv6;
 222             struct tun_metadata data;
 223         } encap;
 224
 225         struct {
 226             uint16_t zone;
 227             uint32_t mark;
 228             uint32_t mark_mask;
 229             ovs_u128 label;
 230             ovs_u128 label_mask;
 231             uint8_t nat_type;
 232             struct {
 233                 uint8_t ip_family;
 234
 235                 union {
 236                     struct {
 237                         ovs_be32 min;
 238                         ovs_be32 max;
 239                     } ipv4;
 240                     struct {
 241                         struct in6_addr min;
 242                         struct in6_addr max;
 243                     } ipv6;
 244                 };
 245
 246                 struct {
 247                     ovs_be16 min;
 248                     ovs_be16 max;
 249                 } port;
 250
 251             } range;
 252             bool clear;
 253             bool force;
 254             bool commit;
 255         } ct;
 256      };
 257
 258      enum tc_action_type type;
 259 };
 260
 261 enum tc_offloaded_state {
 262     TC_OFFLOADED_STATE_UNDEFINED,
 263     TC_OFFLOADED_STATE_IN_HW,
 264     TC_OFFLOADED_STATE_NOT_IN_HW,
 265 };
 266
 267 #define TCA_ACT_MAX_NUM 16
 268
 269 struct tcf_id {
 270     enum tc_qdisc_hook hook;
 271     uint32_t block_id;
 272     int ifindex;
 273     uint32_t chain;
 274     uint16_t prio;
 275     uint32_t handle;
 276 };
 277
 278 static inline struct tcf_id
 279 tc_make_tcf_id(int ifindex, uint32_t block_id, uint16_t prio,
 280                enum tc_qdisc_hook hook)
 281 {
 282     struct tcf_id id = {
 283         .hook = hook,
 284         .block_id = block_id,
 285         .ifindex = ifindex,
 286         .prio = prio,
 287     };
 288
 289     return id;
 290 }
 291
 292 static inline struct tcf_id
 293 tc_make_tcf_id_chain(int ifindex, uint32_t block_id, uint32_t chain,
 294                      uint16_t prio, enum tc_qdisc_hook hook)
 295 {
 296     struct tcf_id id = tc_make_tcf_id(ifindex, block_id, prio, hook);
 297
 298     id.chain = chain;
 299
 300     return id;
 301 }
 302
 303 static inline bool
 304 is_tcf_id_eq(struct tcf_id *id1, struct tcf_id *id2)
 305 {
 306     return id1->prio == id2->prio
 307            && id1->handle == id2->handle
 308            && id1->handle == id2->handle
 309            && id1->hook == id2->hook
 310            && id1->block_id == id2->block_id
 311            && id1->ifindex == id2->ifindex
 312            && id1->chain == id2->chain;
 313 }
 314
 315 enum tc_offload_policy {
 316     TC_POLICY_NONE = 0,
 317     TC_POLICY_SKIP_SW,
 318     TC_POLICY_SKIP_HW
 319 };
 320
 321 BUILD_ASSERT_DECL(TC_POLICY_NONE == 0);
 322
 323 struct tc_flower {
 324     struct tc_flower_key key;
 325     struct tc_flower_key mask;
 326
 327     int action_count;
 328     struct tc_action actions[TCA_ACT_MAX_NUM];
 329
 330     struct ovs_flow_stats stats;
 331     uint64_t lastused;
 332
 333     struct {
 334         bool rewrite;
 335         struct tc_flower_key key;
 336         struct tc_flower_key mask;
 337     } rewrite;
 338
 339     uint32_t csum_update_flags;
 340
 341     bool tunnel;
 342
 343     struct tc_cookie act_cookie;
 344
 345     bool needs_full_ip_proto_mask;
 346
 347     enum tc_offloaded_state offloaded_state;
 348     /* Used to force skip_hw when probing tc features. */
 349     enum tc_offload_policy tc_policy;
 350 };
 351
 352 /* assert that if we overflow with a masked write of uint32_t to the last byte
 353  * of flower.rewrite we overflow inside struct flower.
 354  * shouldn't happen unless someone moves rewrite to the end of flower */
 355 BUILD_ASSERT_DECL(offsetof(struct tc_flower, rewrite)
 356                   + MEMBER_SIZEOF(struct tc_flower, rewrite)
 357                   + sizeof(uint32_t) - 2 < sizeof(struct tc_flower));
 358
 359 int tc_replace_flower(struct tcf_id *id, struct tc_flower *flower);
 360 int tc_del_filter(struct tcf_id *id);
 361 int tc_get_flower(struct tcf_id *id, struct tc_flower *flower);
 362 int tc_dump_flower_start(struct tcf_id *id, struct nl_dump *dump, bool terse);
 363 int parse_netlink_to_tc_flower(struct ofpbuf *reply,
 364                                struct tcf_id *id,
 365                                struct tc_flower *flower,
 366                                bool terse);
 367 void tc_set_policy(const char *policy);
 368
 369 #endif /* tc.h */