include/net/flow_dissector.h

   1 #ifndef _NET_FLOW_DISSECTOR_H
   2 #define _NET_FLOW_DISSECTOR_H
   3
   4 #include <linux/types.h>
   5 #include <linux/in6.h>
   6 #include <uapi/linux/if_ether.h>
   7
   8 /**
   9  * struct flow_dissector_key_control:
  10  * @thoff: Transport header offset
  11  */
  12 struct flow_dissector_key_control {
  13         u16     thoff;
  14         u16     addr_type;
  15         u32     flags;
  16 };
  17
  18 #define FLOW_DIS_IS_FRAGMENT    BIT(0)
  19 #define FLOW_DIS_FIRST_FRAG     BIT(1)
  20 #define FLOW_DIS_ENCAPSULATION  BIT(2)
  21
  22 /**
  23  * struct flow_dissector_key_basic:
  24  * @thoff: Transport header offset
  25  * @n_proto: Network header protocol (eg. IPv4/IPv6)
  26  * @ip_proto: Transport header protocol (eg. TCP/UDP)
  27  */
  28 struct flow_dissector_key_basic {
  29         __be16  n_proto;
  30         u8      ip_proto;
  31         u8      padding;
  32 };
  33
  34 struct flow_dissector_key_tags {
  35         u32     flow_label;
  36 };
  37
  38 struct flow_dissector_key_vlan {
  39         u16     vlan_id:12,
  40                 vlan_priority:3;
  41         u16     padding;
  42 };
  43
  44 struct flow_dissector_key_keyid {
  45         __be32  keyid;
  46 };
  47
  48 /**
  49  * struct flow_dissector_key_ipv4_addrs:
  50  * @src: source ip address
  51  * @dst: destination ip address
  52  */
  53 struct flow_dissector_key_ipv4_addrs {
  54         /* (src,dst) must be grouped, in the same way than in IP header */
  55         __be32 src;
  56         __be32 dst;
  57 };
  58
  59 /**
  60  * struct flow_dissector_key_ipv6_addrs:
  61  * @src: source ip address
  62  * @dst: destination ip address
  63  */
  64 struct flow_dissector_key_ipv6_addrs {
  65         /* (src,dst) must be grouped, in the same way than in IP header */
  66         struct in6_addr src;
  67         struct in6_addr dst;
  68 };
  69
  70 /**
  71  * struct flow_dissector_key_tipc_addrs:
  72  * @srcnode: source node address
  73  */
  74 struct flow_dissector_key_tipc_addrs {
  75         __be32 srcnode;
  76 };
  77
  78 /**
  79  * struct flow_dissector_key_addrs:
  80  * @v4addrs: IPv4 addresses
  81  * @v6addrs: IPv6 addresses
  82  */
  83 struct flow_dissector_key_addrs {
  84         union {
  85                 struct flow_dissector_key_ipv4_addrs v4addrs;
  86                 struct flow_dissector_key_ipv6_addrs v6addrs;
  87                 struct flow_dissector_key_tipc_addrs tipcaddrs;
  88         };
  89 };
  90
  91 /**
  92  * flow_dissector_key_arp:
  93  *      @ports: Operation, source and target addresses for an ARP header
  94  *              for Ethernet hardware addresses and IPv4 protocol addresses
  95  *              sip: Sender IP address
  96  *              tip: Target IP address
  97  *              op:  Operation
  98  *              sha: Sender hardware address
  99  *              tpa: Target hardware address
 100  */
 101 struct flow_dissector_key_arp {
 102         __u32 sip;
 103         __u32 tip;
 104         __u8 op;
 105         unsigned char sha[ETH_ALEN];
 106         unsigned char tha[ETH_ALEN];
 107 };
 108
 109 /**
 110  * flow_dissector_key_tp_ports:
 111  *      @ports: port numbers of Transport header
 112  *              src: source port number
 113  *              dst: destination port number
 114  */
 115 struct flow_dissector_key_ports {
 116         union {
 117                 __be32 ports;
 118                 struct {
 119                         __be16 src;
 120                         __be16 dst;
 121                 };
 122         };
 123 };
 124
 125 /**
 126  * flow_dissector_key_icmp:
 127  *      @ports: type and code of ICMP header
 128  *              icmp: ICMP type (high) and code (low)
 129  *              type: ICMP type
 130  *              code: ICMP code
 131  */
 132 struct flow_dissector_key_icmp {
 133         union {
 134                 __be16 icmp;
 135                 struct {
 136                         u8 type;
 137                         u8 code;
 138                 };
 139         };
 140 };
 141
 142 /**
 143  * struct flow_dissector_key_eth_addrs:
 144  * @src: source Ethernet address
 145  * @dst: destination Ethernet address
 146  */
 147 struct flow_dissector_key_eth_addrs {
 148         /* (dst,src) must be grouped, in the same way than in ETH header */
 149         unsigned char dst[ETH_ALEN];
 150         unsigned char src[ETH_ALEN];
 151 };
 152
 153 enum flow_dissector_key_id {
 154         FLOW_DISSECTOR_KEY_CONTROL, /* struct flow_dissector_key_control */
 155         FLOW_DISSECTOR_KEY_BASIC, /* struct flow_dissector_key_basic */
 156         FLOW_DISSECTOR_KEY_IPV4_ADDRS, /* struct flow_dissector_key_ipv4_addrs */
 157         FLOW_DISSECTOR_KEY_IPV6_ADDRS, /* struct flow_dissector_key_ipv6_addrs */
 158         FLOW_DISSECTOR_KEY_PORTS, /* struct flow_dissector_key_ports */
 159         FLOW_DISSECTOR_KEY_ICMP, /* struct flow_dissector_key_icmp */
 160         FLOW_DISSECTOR_KEY_ETH_ADDRS, /* struct flow_dissector_key_eth_addrs */
 161         FLOW_DISSECTOR_KEY_TIPC_ADDRS, /* struct flow_dissector_key_tipc_addrs */
 162         FLOW_DISSECTOR_KEY_ARP, /* struct flow_dissector_key_arp */
 163         FLOW_DISSECTOR_KEY_VLAN, /* struct flow_dissector_key_flow_vlan */
 164         FLOW_DISSECTOR_KEY_FLOW_LABEL, /* struct flow_dissector_key_flow_tags */
 165         FLOW_DISSECTOR_KEY_GRE_KEYID, /* struct flow_dissector_key_keyid */
 166         FLOW_DISSECTOR_KEY_MPLS_ENTROPY, /* struct flow_dissector_key_keyid */
 167         FLOW_DISSECTOR_KEY_ENC_KEYID, /* struct flow_dissector_key_keyid */
 168         FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS, /* struct flow_dissector_key_ipv4_addrs */
 169         FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS, /* struct flow_dissector_key_ipv6_addrs */
 170         FLOW_DISSECTOR_KEY_ENC_CONTROL, /* struct flow_dissector_key_control */
 171         FLOW_DISSECTOR_KEY_ENC_PORTS, /* struct flow_dissector_key_ports */
 172
 173         FLOW_DISSECTOR_KEY_MAX,
 174 };
 175
 176 #define FLOW_DISSECTOR_F_PARSE_1ST_FRAG         BIT(0)
 177 #define FLOW_DISSECTOR_F_STOP_AT_L3             BIT(1)
 178 #define FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL     BIT(2)
 179 #define FLOW_DISSECTOR_F_STOP_AT_ENCAP          BIT(3)
 180
 181 struct flow_dissector_key {
 182         enum flow_dissector_key_id key_id;
 183         size_t offset; /* offset of struct flow_dissector_key_*
 184                           in target the struct */
 185 };
 186
 187 struct flow_dissector {
 188         unsigned int used_keys; /* each bit repesents presence of one key id */
 189         unsigned short int offset[FLOW_DISSECTOR_KEY_MAX];
 190 };
 191
 192 struct flow_keys {
 193         struct flow_dissector_key_control control;
 194 #define FLOW_KEYS_HASH_START_FIELD basic
 195         struct flow_dissector_key_basic basic;
 196         struct flow_dissector_key_tags tags;
 197         struct flow_dissector_key_vlan vlan;
 198         struct flow_dissector_key_keyid keyid;
 199         struct flow_dissector_key_ports ports;
 200         struct flow_dissector_key_addrs addrs;
 201 };
 202
 203 #define FLOW_KEYS_HASH_OFFSET           \
 204         offsetof(struct flow_keys, FLOW_KEYS_HASH_START_FIELD)
 205
 206 __be32 flow_get_u32_src(const struct flow_keys *flow);
 207 __be32 flow_get_u32_dst(const struct flow_keys *flow);
 208
 209 extern struct flow_dissector flow_keys_dissector;
 210 extern struct flow_dissector flow_keys_buf_dissector;
 211
 212 /* struct flow_keys_digest:
 213  *
 214  * This structure is used to hold a digest of the full flow keys. This is a
 215  * larger "hash" of a flow to allow definitively matching specific flows where
 216  * the 32 bit skb->hash is not large enough. The size is limited to 16 bytes so
 217  * that it can by used in CB of skb (see sch_choke for an example).
 218  */
 219 #define FLOW_KEYS_DIGEST_LEN    16
 220 struct flow_keys_digest {
 221         u8      data[FLOW_KEYS_DIGEST_LEN];
 222 };
 223
 224 void make_flow_keys_digest(struct flow_keys_digest *digest,
 225                            const struct flow_keys *flow);
 226
 227 static inline bool flow_keys_have_l4(const struct flow_keys *keys)
 228 {
 229         return (keys->ports.ports || keys->tags.flow_label);
 230 }
 231
 232 u32 flow_hash_from_keys(struct flow_keys *keys);
 233
 234 static inline bool dissector_uses_key(const struct flow_dissector *flow_dissector,
 235                                       enum flow_dissector_key_id key_id)
 236 {
 237         return flow_dissector->used_keys & (1 << key_id);
 238 }
 239
 240 static inline void *skb_flow_dissector_target(struct flow_dissector *flow_dissector,
 241                                               enum flow_dissector_key_id key_id,
 242                                               void *target_container)
 243 {
 244         return ((char *)target_container) + flow_dissector->offset[key_id];
 245 }
 246
 247 #endif