1 #include <linux/kernel.h> 2 #include <linux/skbuff.h> 3 #include <linux/export.h> 4 #include <linux/ip.h> 5 #include <linux/ipv6.h> 6 #include <linux/if_vlan.h> 7 #include <net/dsa.h> 8 #include <net/dst_metadata.h> 9 #include <net/ip.h> 10 #include <net/ipv6.h> 11 #include <net/gre.h> 12 #include <net/pptp.h> 13 #include <linux/igmp.h> 14 #include <linux/icmp.h> 15 #include <linux/sctp.h> 16 #include <linux/dccp.h> 17 #include <linux/if_tunnel.h> 18 #include <linux/if_pppox.h> 19 #include <linux/ppp_defs.h> 20 #include <linux/stddef.h> 21 #include <linux/if_ether.h> 22 #include <linux/mpls.h> 23 #include <linux/tcp.h> 24 #include <net/flow_dissector.h> 25 #include <scsi/fc/fc_fcoe.h> 26 27 static void dissector_set_key(struct flow_dissector *flow_dissector, 28 enum flow_dissector_key_id key_id) 29 { 30 flow_dissector->used_keys |= (1 << key_id); 31 } 32 33 void skb_flow_dissector_init(struct flow_dissector *flow_dissector, 34 const struct flow_dissector_key *key, 35 unsigned int key_count) 36 { 37 unsigned int i; 38 39 memset(flow_dissector, 0, sizeof(*flow_dissector)); 40 41 for (i = 0; i < key_count; i++, key++) { 42 /* User should make sure that every key target offset is withing 43 * boundaries of unsigned short. 44 */ 45 BUG_ON(key->offset > USHRT_MAX); 46 BUG_ON(dissector_uses_key(flow_dissector, 47 key->key_id)); 48 49 dissector_set_key(flow_dissector, key->key_id); 50 flow_dissector->offset[key->key_id] = key->offset; 51 } 52 53 /* Ensure that the dissector always includes control and basic key. 54 * That way we are able to avoid handling lack of these in fast path. 55 */ 56 BUG_ON(!dissector_uses_key(flow_dissector, 57 FLOW_DISSECTOR_KEY_CONTROL)); 58 BUG_ON(!dissector_uses_key(flow_dissector, 59 FLOW_DISSECTOR_KEY_BASIC)); 60 } 61 EXPORT_SYMBOL(skb_flow_dissector_init); 62 63 /** 64 * skb_flow_get_be16 - extract be16 entity 65 * @skb: sk_buff to extract from 66 * @poff: offset to extract at 67 * @data: raw buffer pointer to the packet 68 * @hlen: packet header length 69 * 70 * The function will try to retrieve a be32 entity at 71 * offset poff 72 */ 73 static __be16 skb_flow_get_be16(const struct sk_buff *skb, int poff, 74 void *data, int hlen) 75 { 76 __be16 *u, _u; 77 78 u = __skb_header_pointer(skb, poff, sizeof(_u), data, hlen, &_u); 79 if (u) 80 return *u; 81 82 return 0; 83 } 84 85 /** 86 * __skb_flow_get_ports - extract the upper layer ports and return them 87 * @skb: sk_buff to extract the ports from 88 * @thoff: transport header offset 89 * @ip_proto: protocol for which to get port offset 90 * @data: raw buffer pointer to the packet, if NULL use skb->data 91 * @hlen: packet header length, if @data is NULL use skb_headlen(skb) 92 * 93 * The function will try to retrieve the ports at offset thoff + poff where poff 94 * is the protocol port offset returned from proto_ports_offset 95 */ 96 __be32 __skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto, 97 void *data, int hlen) 98 { 99 int poff = proto_ports_offset(ip_proto); 100 101 if (!data) { 102 data = skb->data; 103 hlen = skb_headlen(skb); 104 } 105 106 if (poff >= 0) { 107 __be32 *ports, _ports; 108 109 ports = __skb_header_pointer(skb, thoff + poff, 110 sizeof(_ports), data, hlen, &_ports); 111 if (ports) 112 return *ports; 113 } 114 115 return 0; 116 } 117 EXPORT_SYMBOL(__skb_flow_get_ports); 118 119 static void 120 skb_flow_dissect_set_enc_addr_type(enum flow_dissector_key_id type, 121 struct flow_dissector *flow_dissector, 122 void *target_container) 123 { 124 struct flow_dissector_key_control *ctrl; 125 126 if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ENC_CONTROL)) 127 return; 128 129 ctrl = skb_flow_dissector_target(flow_dissector, 130 FLOW_DISSECTOR_KEY_ENC_CONTROL, 131 target_container); 132 ctrl->addr_type = type; 133 } 134 135 static void 136 __skb_flow_dissect_tunnel_info(const struct sk_buff *skb, 137 struct flow_dissector *flow_dissector, 138 void *target_container) 139 { 140 struct ip_tunnel_info *info; 141 struct ip_tunnel_key *key; 142 143 /* A quick check to see if there might be something to do. */ 144 if (!dissector_uses_key(flow_dissector, 145 FLOW_DISSECTOR_KEY_ENC_KEYID) && 146 !dissector_uses_key(flow_dissector, 147 FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS) && 148 !dissector_uses_key(flow_dissector, 149 FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS) && 150 !dissector_uses_key(flow_dissector, 151 FLOW_DISSECTOR_KEY_ENC_CONTROL) && 152 !dissector_uses_key(flow_dissector, 153 FLOW_DISSECTOR_KEY_ENC_PORTS)) 154 return; 155 156 info = skb_tunnel_info(skb); 157 if (!info) 158 return; 159 160 key = &info->key; 161 162 switch (ip_tunnel_info_af(info)) { 163 case AF_INET: 164 skb_flow_dissect_set_enc_addr_type(FLOW_DISSECTOR_KEY_IPV4_ADDRS, 165 flow_dissector, 166 target_container); 167 if (dissector_uses_key(flow_dissector, 168 FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS)) { 169 struct flow_dissector_key_ipv4_addrs *ipv4; 170 171 ipv4 = skb_flow_dissector_target(flow_dissector, 172 FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS, 173 target_container); 174 ipv4->src = key->u.ipv4.src; 175 ipv4->dst = key->u.ipv4.dst; 176 } 177 break; 178 case AF_INET6: 179 skb_flow_dissect_set_enc_addr_type(FLOW_DISSECTOR_KEY_IPV6_ADDRS, 180 flow_dissector, 181 target_container); 182 if (dissector_uses_key(flow_dissector, 183 FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS)) { 184 struct flow_dissector_key_ipv6_addrs *ipv6; 185 186 ipv6 = skb_flow_dissector_target(flow_dissector, 187 FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS, 188 target_container); 189 ipv6->src = key->u.ipv6.src; 190 ipv6->dst = key->u.ipv6.dst; 191 } 192 break; 193 } 194 195 if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ENC_KEYID)) { 196 struct flow_dissector_key_keyid *keyid; 197 198 keyid = skb_flow_dissector_target(flow_dissector, 199 FLOW_DISSECTOR_KEY_ENC_KEYID, 200 target_container); 201 keyid->keyid = tunnel_id_to_key32(key->tun_id); 202 } 203 204 if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ENC_PORTS)) { 205 struct flow_dissector_key_ports *tp; 206 207 tp = skb_flow_dissector_target(flow_dissector, 208 FLOW_DISSECTOR_KEY_ENC_PORTS, 209 target_container); 210 tp->src = key->tp_src; 211 tp->dst = key->tp_dst; 212 } 213 } 214 215 static enum flow_dissect_ret 216 __skb_flow_dissect_mpls(const struct sk_buff *skb, 217 struct flow_dissector *flow_dissector, 218 void *target_container, void *data, int nhoff, int hlen) 219 { 220 struct flow_dissector_key_keyid *key_keyid; 221 struct mpls_label *hdr, _hdr[2]; 222 u32 entry, label; 223 224 if (!dissector_uses_key(flow_dissector, 225 FLOW_DISSECTOR_KEY_MPLS_ENTROPY) && 226 !dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_MPLS)) 227 return FLOW_DISSECT_RET_OUT_GOOD; 228 229 hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, 230 hlen, &_hdr); 231 if (!hdr) 232 return FLOW_DISSECT_RET_OUT_BAD; 233 234 entry = ntohl(hdr[0].entry); 235 label = (entry & MPLS_LS_LABEL_MASK) >> MPLS_LS_LABEL_SHIFT; 236 237 if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_MPLS)) { 238 struct flow_dissector_key_mpls *key_mpls; 239 240 key_mpls = skb_flow_dissector_target(flow_dissector, 241 FLOW_DISSECTOR_KEY_MPLS, 242 target_container); 243 key_mpls->mpls_label = label; 244 key_mpls->mpls_ttl = (entry & MPLS_LS_TTL_MASK) 245 >> MPLS_LS_TTL_SHIFT; 246 key_mpls->mpls_tc = (entry & MPLS_LS_TC_MASK) 247 >> MPLS_LS_TC_SHIFT; 248 key_mpls->mpls_bos = (entry & MPLS_LS_S_MASK) 249 >> MPLS_LS_S_SHIFT; 250 } 251 252 if (label == MPLS_LABEL_ENTROPY) { 253 key_keyid = skb_flow_dissector_target(flow_dissector, 254 FLOW_DISSECTOR_KEY_MPLS_ENTROPY, 255 target_container); 256 key_keyid->keyid = hdr[1].entry & htonl(MPLS_LS_LABEL_MASK); 257 } 258 return FLOW_DISSECT_RET_OUT_GOOD; 259 } 260 261 static enum flow_dissect_ret 262 __skb_flow_dissect_arp(const struct sk_buff *skb, 263 struct flow_dissector *flow_dissector, 264 void *target_container, void *data, int nhoff, int hlen) 265 { 266 struct flow_dissector_key_arp *key_arp; 267 struct { 268 unsigned char ar_sha[ETH_ALEN]; 269 unsigned char ar_sip[4]; 270 unsigned char ar_tha[ETH_ALEN]; 271 unsigned char ar_tip[4]; 272 } *arp_eth, _arp_eth; 273 const struct arphdr *arp; 274 struct arphdr _arp; 275 276 if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ARP)) 277 return FLOW_DISSECT_RET_OUT_GOOD; 278 279 arp = __skb_header_pointer(skb, nhoff, sizeof(_arp), data, 280 hlen, &_arp); 281 if (!arp) 282 return FLOW_DISSECT_RET_OUT_BAD; 283 284 if (arp->ar_hrd != htons(ARPHRD_ETHER) || 285 arp->ar_pro != htons(ETH_P_IP) || 286 arp->ar_hln != ETH_ALEN || 287 arp->ar_pln != 4 || 288 (arp->ar_op != htons(ARPOP_REPLY) && 289 arp->ar_op != htons(ARPOP_REQUEST))) 290 return FLOW_DISSECT_RET_OUT_BAD; 291 292 arp_eth = __skb_header_pointer(skb, nhoff + sizeof(_arp), 293 sizeof(_arp_eth), data, 294 hlen, &_arp_eth); 295 if (!arp_eth) 296 return FLOW_DISSECT_RET_OUT_BAD; 297 298 key_arp = skb_flow_dissector_target(flow_dissector, 299 FLOW_DISSECTOR_KEY_ARP, 300 target_container); 301 302 memcpy(&key_arp->sip, arp_eth->ar_sip, sizeof(key_arp->sip)); 303 memcpy(&key_arp->tip, arp_eth->ar_tip, sizeof(key_arp->tip)); 304 305 /* Only store the lower byte of the opcode; 306 * this covers ARPOP_REPLY and ARPOP_REQUEST. 307 */ 308 key_arp->op = ntohs(arp->ar_op) & 0xff; 309 310 ether_addr_copy(key_arp->sha, arp_eth->ar_sha); 311 ether_addr_copy(key_arp->tha, arp_eth->ar_tha); 312 313 return FLOW_DISSECT_RET_OUT_GOOD; 314 } 315 316 static enum flow_dissect_ret 317 __skb_flow_dissect_gre(const struct sk_buff *skb, 318 struct flow_dissector_key_control *key_control, 319 struct flow_dissector *flow_dissector, 320 void *target_container, void *data, 321 __be16 *p_proto, int *p_nhoff, int *p_hlen, 322 unsigned int flags) 323 { 324 struct flow_dissector_key_keyid *key_keyid; 325 struct gre_base_hdr *hdr, _hdr; 326 int offset = 0; 327 u16 gre_ver; 328 329 hdr = __skb_header_pointer(skb, *p_nhoff, sizeof(_hdr), 330 data, *p_hlen, &_hdr); 331 if (!hdr) 332 return FLOW_DISSECT_RET_OUT_BAD; 333 334 /* Only look inside GRE without routing */ 335 if (hdr->flags & GRE_ROUTING) 336 return FLOW_DISSECT_RET_OUT_GOOD; 337 338 /* Only look inside GRE for version 0 and 1 */ 339 gre_ver = ntohs(hdr->flags & GRE_VERSION); 340 if (gre_ver > 1) 341 return FLOW_DISSECT_RET_OUT_GOOD; 342 343 *p_proto = hdr->protocol; 344 if (gre_ver) { 345 /* Version1 must be PPTP, and check the flags */ 346 if (!(*p_proto == GRE_PROTO_PPP && (hdr->flags & GRE_KEY))) 347 return FLOW_DISSECT_RET_OUT_GOOD; 348 } 349 350 offset += sizeof(struct gre_base_hdr); 351 352 if (hdr->flags & GRE_CSUM) 353 offset += sizeof(((struct gre_full_hdr *) 0)->csum) + 354 sizeof(((struct gre_full_hdr *) 0)->reserved1); 355 356 if (hdr->flags & GRE_KEY) { 357 const __be32 *keyid; 358 __be32 _keyid; 359 360 keyid = __skb_header_pointer(skb, *p_nhoff + offset, 361 sizeof(_keyid), 362 data, *p_hlen, &_keyid); 363 if (!keyid) 364 return FLOW_DISSECT_RET_OUT_BAD; 365 366 if (dissector_uses_key(flow_dissector, 367 FLOW_DISSECTOR_KEY_GRE_KEYID)) { 368 key_keyid = skb_flow_dissector_target(flow_dissector, 369 FLOW_DISSECTOR_KEY_GRE_KEYID, 370 target_container); 371 if (gre_ver == 0) 372 key_keyid->keyid = *keyid; 373 else 374 key_keyid->keyid = *keyid & GRE_PPTP_KEY_MASK; 375 } 376 offset += sizeof(((struct gre_full_hdr *) 0)->key); 377 } 378 379 if (hdr->flags & GRE_SEQ) 380 offset += sizeof(((struct pptp_gre_header *) 0)->seq); 381 382 if (gre_ver == 0) { 383 if (*p_proto == htons(ETH_P_TEB)) { 384 const struct ethhdr *eth; 385 struct ethhdr _eth; 386 387 eth = __skb_header_pointer(skb, *p_nhoff + offset, 388 sizeof(_eth), 389 data, *p_hlen, &_eth); 390 if (!eth) 391 return FLOW_DISSECT_RET_OUT_BAD; 392 *p_proto = eth->h_proto; 393 offset += sizeof(*eth); 394 395 /* Cap headers that we access via pointers at the 396 * end of the Ethernet header as our maximum alignment 397 * at that point is only 2 bytes. 398 */ 399 if (NET_IP_ALIGN) 400 *p_hlen = *p_nhoff + offset; 401 } 402 } else { /* version 1, must be PPTP */ 403 u8 _ppp_hdr[PPP_HDRLEN]; 404 u8 *ppp_hdr; 405 406 if (hdr->flags & GRE_ACK) 407 offset += sizeof(((struct pptp_gre_header *) 0)->ack); 408 409 ppp_hdr = __skb_header_pointer(skb, *p_nhoff + offset, 410 sizeof(_ppp_hdr), 411 data, *p_hlen, _ppp_hdr); 412 if (!ppp_hdr) 413 return FLOW_DISSECT_RET_OUT_BAD; 414 415 switch (PPP_PROTOCOL(ppp_hdr)) { 416 case PPP_IP: 417 *p_proto = htons(ETH_P_IP); 418 break; 419 case PPP_IPV6: 420 *p_proto = htons(ETH_P_IPV6); 421 break; 422 default: 423 /* Could probably catch some more like MPLS */ 424 break; 425 } 426 427 offset += PPP_HDRLEN; 428 } 429 430 *p_nhoff += offset; 431 key_control->flags |= FLOW_DIS_ENCAPSULATION; 432 if (flags & FLOW_DISSECTOR_F_STOP_AT_ENCAP) 433 return FLOW_DISSECT_RET_OUT_GOOD; 434 435 return FLOW_DISSECT_RET_PROTO_AGAIN; 436 } 437 438 static void 439 __skb_flow_dissect_tcp(const struct sk_buff *skb, 440 struct flow_dissector *flow_dissector, 441 void *target_container, void *data, int thoff, int hlen) 442 { 443 struct flow_dissector_key_tcp *key_tcp; 444 struct tcphdr *th, _th; 445 446 if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_TCP)) 447 return; 448 449 th = __skb_header_pointer(skb, thoff, sizeof(_th), data, hlen, &_th); 450 if (!th) 451 return; 452 453 if (unlikely(__tcp_hdrlen(th) < sizeof(_th))) 454 return; 455 456 key_tcp = skb_flow_dissector_target(flow_dissector, 457 FLOW_DISSECTOR_KEY_TCP, 458 target_container); 459 key_tcp->flags = (*(__be16 *) &tcp_flag_word(th) & htons(0x0FFF)); 460 } 461 462 static void 463 __skb_flow_dissect_ipv4(const struct sk_buff *skb, 464 struct flow_dissector *flow_dissector, 465 void *target_container, void *data, const struct iphdr *iph) 466 { 467 struct flow_dissector_key_ip *key_ip; 468 469 if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_IP)) 470 return; 471 472 key_ip = skb_flow_dissector_target(flow_dissector, 473 FLOW_DISSECTOR_KEY_IP, 474 target_container); 475 key_ip->tos = iph->tos; 476 key_ip->ttl = iph->ttl; 477 } 478 479 static void 480 __skb_flow_dissect_ipv6(const struct sk_buff *skb, 481 struct flow_dissector *flow_dissector, 482 void *target_container, void *data, const struct ipv6hdr *iph) 483 { 484 struct flow_dissector_key_ip *key_ip; 485 486 if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_IP)) 487 return; 488 489 key_ip = skb_flow_dissector_target(flow_dissector, 490 FLOW_DISSECTOR_KEY_IP, 491 target_container); 492 key_ip->tos = ipv6_get_dsfield(iph); 493 key_ip->ttl = iph->hop_limit; 494 } 495 496 /* Maximum number of protocol headers that can be parsed in 497 * __skb_flow_dissect 498 */ 499 #define MAX_FLOW_DISSECT_HDRS 15 500 501 static bool skb_flow_dissect_allowed(int *num_hdrs) 502 { 503 ++*num_hdrs; 504 505 return (*num_hdrs <= MAX_FLOW_DISSECT_HDRS); 506 } 507 508 /** 509 * __skb_flow_dissect - extract the flow_keys struct and return it 510 * @skb: sk_buff to extract the flow from, can be NULL if the rest are specified 511 * @flow_dissector: list of keys to dissect 512 * @target_container: target structure to put dissected values into 513 * @data: raw buffer pointer to the packet, if NULL use skb->data 514 * @proto: protocol for which to get the flow, if @data is NULL use skb->protocol 515 * @nhoff: network header offset, if @data is NULL use skb_network_offset(skb) 516 * @hlen: packet header length, if @data is NULL use skb_headlen(skb) 517 * 518 * The function will try to retrieve individual keys into target specified 519 * by flow_dissector from either the skbuff or a raw buffer specified by the 520 * rest parameters. 521 * 522 * Caller must take care of zeroing target container memory. 523 */ 524 bool __skb_flow_dissect(const struct sk_buff *skb, 525 struct flow_dissector *flow_dissector, 526 void *target_container, 527 void *data, __be16 proto, int nhoff, int hlen, 528 unsigned int flags) 529 { 530 struct flow_dissector_key_control *key_control; 531 struct flow_dissector_key_basic *key_basic; 532 struct flow_dissector_key_addrs *key_addrs; 533 struct flow_dissector_key_ports *key_ports; 534 struct flow_dissector_key_icmp *key_icmp; 535 struct flow_dissector_key_tags *key_tags; 536 struct flow_dissector_key_vlan *key_vlan; 537 enum flow_dissect_ret fdret; 538 bool skip_vlan = false; 539 int num_hdrs = 0; 540 u8 ip_proto = 0; 541 bool ret; 542 543 if (!data) { 544 data = skb->data; 545 proto = skb_vlan_tag_present(skb) ? 546 skb->vlan_proto : skb->protocol; 547 nhoff = skb_network_offset(skb); 548 hlen = skb_headlen(skb); 549 #if IS_ENABLED(CONFIG_NET_DSA) 550 if (unlikely(skb->dev && netdev_uses_dsa(skb->dev))) { 551 const struct dsa_device_ops *ops; 552 int offset; 553 554 ops = skb->dev->dsa_ptr->tag_ops; 555 if (ops->flow_dissect && 556 !ops->flow_dissect(skb, &proto, &offset)) { 557 hlen -= offset; 558 nhoff += offset; 559 } 560 } 561 #endif 562 } 563 564 /* It is ensured by skb_flow_dissector_init() that control key will 565 * be always present. 566 */ 567 key_control = skb_flow_dissector_target(flow_dissector, 568 FLOW_DISSECTOR_KEY_CONTROL, 569 target_container); 570 571 /* It is ensured by skb_flow_dissector_init() that basic key will 572 * be always present. 573 */ 574 key_basic = skb_flow_dissector_target(flow_dissector, 575 FLOW_DISSECTOR_KEY_BASIC, 576 target_container); 577 578 __skb_flow_dissect_tunnel_info(skb, flow_dissector, 579 target_container); 580 581 if (dissector_uses_key(flow_dissector, 582 FLOW_DISSECTOR_KEY_ETH_ADDRS)) { 583 struct ethhdr *eth = eth_hdr(skb); 584 struct flow_dissector_key_eth_addrs *key_eth_addrs; 585 586 key_eth_addrs = skb_flow_dissector_target(flow_dissector, 587 FLOW_DISSECTOR_KEY_ETH_ADDRS, 588 target_container); 589 memcpy(key_eth_addrs, ð->h_dest, sizeof(*key_eth_addrs)); 590 } 591 592 proto_again: 593 fdret = FLOW_DISSECT_RET_CONTINUE; 594 595 switch (proto) { 596 case htons(ETH_P_IP): { 597 const struct iphdr *iph; 598 struct iphdr _iph; 599 600 iph = __skb_header_pointer(skb, nhoff, sizeof(_iph), data, hlen, &_iph); 601 if (!iph || iph->ihl < 5) { 602 fdret = FLOW_DISSECT_RET_OUT_BAD; 603 break; 604 } 605 606 nhoff += iph->ihl * 4; 607 608 ip_proto = iph->protocol; 609 610 if (dissector_uses_key(flow_dissector, 611 FLOW_DISSECTOR_KEY_IPV4_ADDRS)) { 612 key_addrs = skb_flow_dissector_target(flow_dissector, 613 FLOW_DISSECTOR_KEY_IPV4_ADDRS, 614 target_container); 615 616 memcpy(&key_addrs->v4addrs, &iph->saddr, 617 sizeof(key_addrs->v4addrs)); 618 key_control->addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS; 619 } 620 621 if (ip_is_fragment(iph)) { 622 key_control->flags |= FLOW_DIS_IS_FRAGMENT; 623 624 if (iph->frag_off & htons(IP_OFFSET)) { 625 fdret = FLOW_DISSECT_RET_OUT_GOOD; 626 break; 627 } else { 628 key_control->flags |= FLOW_DIS_FIRST_FRAG; 629 if (!(flags & 630 FLOW_DISSECTOR_F_PARSE_1ST_FRAG)) { 631 fdret = FLOW_DISSECT_RET_OUT_GOOD; 632 break; 633 } 634 } 635 } 636 637 __skb_flow_dissect_ipv4(skb, flow_dissector, 638 target_container, data, iph); 639 640 if (flags & FLOW_DISSECTOR_F_STOP_AT_L3) { 641 fdret = FLOW_DISSECT_RET_OUT_GOOD; 642 break; 643 } 644 645 break; 646 } 647 case htons(ETH_P_IPV6): { 648 const struct ipv6hdr *iph; 649 struct ipv6hdr _iph; 650 651 iph = __skb_header_pointer(skb, nhoff, sizeof(_iph), data, hlen, &_iph); 652 if (!iph) { 653 fdret = FLOW_DISSECT_RET_OUT_BAD; 654 break; 655 } 656 657 ip_proto = iph->nexthdr; 658 nhoff += sizeof(struct ipv6hdr); 659 660 if (dissector_uses_key(flow_dissector, 661 FLOW_DISSECTOR_KEY_IPV6_ADDRS)) { 662 key_addrs = skb_flow_dissector_target(flow_dissector, 663 FLOW_DISSECTOR_KEY_IPV6_ADDRS, 664 target_container); 665 666 memcpy(&key_addrs->v6addrs, &iph->saddr, 667 sizeof(key_addrs->v6addrs)); 668 key_control->addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS; 669 } 670 671 if ((dissector_uses_key(flow_dissector, 672 FLOW_DISSECTOR_KEY_FLOW_LABEL) || 673 (flags & FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL)) && 674 ip6_flowlabel(iph)) { 675 __be32 flow_label = ip6_flowlabel(iph); 676 677 if (dissector_uses_key(flow_dissector, 678 FLOW_DISSECTOR_KEY_FLOW_LABEL)) { 679 key_tags = skb_flow_dissector_target(flow_dissector, 680 FLOW_DISSECTOR_KEY_FLOW_LABEL, 681 target_container); 682 key_tags->flow_label = ntohl(flow_label); 683 } 684 if (flags & FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL) { 685 fdret = FLOW_DISSECT_RET_OUT_GOOD; 686 break; 687 } 688 } 689 690 __skb_flow_dissect_ipv6(skb, flow_dissector, 691 target_container, data, iph); 692 693 if (flags & FLOW_DISSECTOR_F_STOP_AT_L3) 694 fdret = FLOW_DISSECT_RET_OUT_GOOD; 695 696 break; 697 } 698 case htons(ETH_P_8021AD): 699 case htons(ETH_P_8021Q): { 700 const struct vlan_hdr *vlan; 701 struct vlan_hdr _vlan; 702 bool vlan_tag_present = skb && skb_vlan_tag_present(skb); 703 704 if (vlan_tag_present) 705 proto = skb->protocol; 706 707 if (!vlan_tag_present || eth_type_vlan(skb->protocol)) { 708 vlan = __skb_header_pointer(skb, nhoff, sizeof(_vlan), 709 data, hlen, &_vlan); 710 if (!vlan) { 711 fdret = FLOW_DISSECT_RET_OUT_BAD; 712 break; 713 } 714 715 proto = vlan->h_vlan_encapsulated_proto; 716 nhoff += sizeof(*vlan); 717 if (skip_vlan) { 718 fdret = FLOW_DISSECT_RET_PROTO_AGAIN; 719 break; 720 } 721 } 722 723 skip_vlan = true; 724 if (dissector_uses_key(flow_dissector, 725 FLOW_DISSECTOR_KEY_VLAN)) { 726 key_vlan = skb_flow_dissector_target(flow_dissector, 727 FLOW_DISSECTOR_KEY_VLAN, 728 target_container); 729 730 if (vlan_tag_present) { 731 key_vlan->vlan_id = skb_vlan_tag_get_id(skb); 732 key_vlan->vlan_priority = 733 (skb_vlan_tag_get_prio(skb) >> VLAN_PRIO_SHIFT); 734 } else { 735 key_vlan->vlan_id = ntohs(vlan->h_vlan_TCI) & 736 VLAN_VID_MASK; 737 key_vlan->vlan_priority = 738 (ntohs(vlan->h_vlan_TCI) & 739 VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT; 740 } 741 } 742 743 fdret = FLOW_DISSECT_RET_PROTO_AGAIN; 744 break; 745 } 746 case htons(ETH_P_PPP_SES): { 747 struct { 748 struct pppoe_hdr hdr; 749 __be16 proto; 750 } *hdr, _hdr; 751 hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr); 752 if (!hdr) { 753 fdret = FLOW_DISSECT_RET_OUT_BAD; 754 break; 755 } 756 757 proto = hdr->proto; 758 nhoff += PPPOE_SES_HLEN; 759 switch (proto) { 760 case htons(PPP_IP): 761 proto = htons(ETH_P_IP); 762 fdret = FLOW_DISSECT_RET_PROTO_AGAIN; 763 break; 764 case htons(PPP_IPV6): 765 proto = htons(ETH_P_IPV6); 766 fdret = FLOW_DISSECT_RET_PROTO_AGAIN; 767 break; 768 default: 769 fdret = FLOW_DISSECT_RET_OUT_BAD; 770 break; 771 } 772 break; 773 } 774 case htons(ETH_P_TIPC): { 775 struct { 776 __be32 pre[3]; 777 __be32 srcnode; 778 } *hdr, _hdr; 779 hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr); 780 if (!hdr) { 781 fdret = FLOW_DISSECT_RET_OUT_BAD; 782 break; 783 } 784 785 if (dissector_uses_key(flow_dissector, 786 FLOW_DISSECTOR_KEY_TIPC_ADDRS)) { 787 key_addrs = skb_flow_dissector_target(flow_dissector, 788 FLOW_DISSECTOR_KEY_TIPC_ADDRS, 789 target_container); 790 key_addrs->tipcaddrs.srcnode = hdr->srcnode; 791 key_control->addr_type = FLOW_DISSECTOR_KEY_TIPC_ADDRS; 792 } 793 fdret = FLOW_DISSECT_RET_OUT_GOOD; 794 break; 795 } 796 797 case htons(ETH_P_MPLS_UC): 798 case htons(ETH_P_MPLS_MC): 799 fdret = __skb_flow_dissect_mpls(skb, flow_dissector, 800 target_container, data, 801 nhoff, hlen); 802 break; 803 case htons(ETH_P_FCOE): 804 if ((hlen - nhoff) < FCOE_HEADER_LEN) { 805 fdret = FLOW_DISSECT_RET_OUT_BAD; 806 break; 807 } 808 809 nhoff += FCOE_HEADER_LEN; 810 fdret = FLOW_DISSECT_RET_OUT_GOOD; 811 break; 812 813 case htons(ETH_P_ARP): 814 case htons(ETH_P_RARP): 815 fdret = __skb_flow_dissect_arp(skb, flow_dissector, 816 target_container, data, 817 nhoff, hlen); 818 break; 819 820 default: 821 fdret = FLOW_DISSECT_RET_OUT_BAD; 822 break; 823 } 824 825 /* Process result of proto processing */ 826 switch (fdret) { 827 case FLOW_DISSECT_RET_OUT_GOOD: 828 goto out_good; 829 case FLOW_DISSECT_RET_PROTO_AGAIN: 830 if (skb_flow_dissect_allowed(&num_hdrs)) 831 goto proto_again; 832 goto out_good; 833 case FLOW_DISSECT_RET_CONTINUE: 834 case FLOW_DISSECT_RET_IPPROTO_AGAIN: 835 break; 836 case FLOW_DISSECT_RET_OUT_BAD: 837 default: 838 goto out_bad; 839 } 840 841 ip_proto_again: 842 fdret = FLOW_DISSECT_RET_CONTINUE; 843 844 switch (ip_proto) { 845 case IPPROTO_GRE: 846 fdret = __skb_flow_dissect_gre(skb, key_control, flow_dissector, 847 target_container, data, 848 &proto, &nhoff, &hlen, flags); 849 break; 850 851 case NEXTHDR_HOP: 852 case NEXTHDR_ROUTING: 853 case NEXTHDR_DEST: { 854 u8 _opthdr[2], *opthdr; 855 856 if (proto != htons(ETH_P_IPV6)) 857 break; 858 859 opthdr = __skb_header_pointer(skb, nhoff, sizeof(_opthdr), 860 data, hlen, &_opthdr); 861 if (!opthdr) { 862 fdret = FLOW_DISSECT_RET_OUT_BAD; 863 break; 864 } 865 866 ip_proto = opthdr[0]; 867 nhoff += (opthdr[1] + 1) << 3; 868 869 fdret = FLOW_DISSECT_RET_IPPROTO_AGAIN; 870 break; 871 } 872 case NEXTHDR_FRAGMENT: { 873 struct frag_hdr _fh, *fh; 874 875 if (proto != htons(ETH_P_IPV6)) 876 break; 877 878 fh = __skb_header_pointer(skb, nhoff, sizeof(_fh), 879 data, hlen, &_fh); 880 881 if (!fh) { 882 fdret = FLOW_DISSECT_RET_OUT_BAD; 883 break; 884 } 885 886 key_control->flags |= FLOW_DIS_IS_FRAGMENT; 887 888 nhoff += sizeof(_fh); 889 ip_proto = fh->nexthdr; 890 891 if (!(fh->frag_off & htons(IP6_OFFSET))) { 892 key_control->flags |= FLOW_DIS_FIRST_FRAG; 893 if (flags & FLOW_DISSECTOR_F_PARSE_1ST_FRAG) { 894 fdret = FLOW_DISSECT_RET_IPPROTO_AGAIN; 895 break; 896 } 897 } 898 899 fdret = FLOW_DISSECT_RET_OUT_GOOD; 900 break; 901 } 902 case IPPROTO_IPIP: 903 proto = htons(ETH_P_IP); 904 905 key_control->flags |= FLOW_DIS_ENCAPSULATION; 906 if (flags & FLOW_DISSECTOR_F_STOP_AT_ENCAP) { 907 fdret = FLOW_DISSECT_RET_OUT_GOOD; 908 break; 909 } 910 911 fdret = FLOW_DISSECT_RET_PROTO_AGAIN; 912 break; 913 914 case IPPROTO_IPV6: 915 proto = htons(ETH_P_IPV6); 916 917 key_control->flags |= FLOW_DIS_ENCAPSULATION; 918 if (flags & FLOW_DISSECTOR_F_STOP_AT_ENCAP) { 919 fdret = FLOW_DISSECT_RET_OUT_GOOD; 920 break; 921 } 922 923 fdret = FLOW_DISSECT_RET_PROTO_AGAIN; 924 break; 925 926 927 case IPPROTO_MPLS: 928 proto = htons(ETH_P_MPLS_UC); 929 fdret = FLOW_DISSECT_RET_PROTO_AGAIN; 930 break; 931 932 case IPPROTO_TCP: 933 __skb_flow_dissect_tcp(skb, flow_dissector, target_container, 934 data, nhoff, hlen); 935 break; 936 937 default: 938 break; 939 } 940 941 if (dissector_uses_key(flow_dissector, 942 FLOW_DISSECTOR_KEY_PORTS)) { 943 key_ports = skb_flow_dissector_target(flow_dissector, 944 FLOW_DISSECTOR_KEY_PORTS, 945 target_container); 946 key_ports->ports = __skb_flow_get_ports(skb, nhoff, ip_proto, 947 data, hlen); 948 } 949 950 if (dissector_uses_key(flow_dissector, 951 FLOW_DISSECTOR_KEY_ICMP)) { 952 key_icmp = skb_flow_dissector_target(flow_dissector, 953 FLOW_DISSECTOR_KEY_ICMP, 954 target_container); 955 key_icmp->icmp = skb_flow_get_be16(skb, nhoff, data, hlen); 956 } 957 958 /* Process result of IP proto processing */ 959 switch (fdret) { 960 case FLOW_DISSECT_RET_PROTO_AGAIN: 961 if (skb_flow_dissect_allowed(&num_hdrs)) 962 goto proto_again; 963 break; 964 case FLOW_DISSECT_RET_IPPROTO_AGAIN: 965 if (skb_flow_dissect_allowed(&num_hdrs)) 966 goto ip_proto_again; 967 break; 968 case FLOW_DISSECT_RET_OUT_GOOD: 969 case FLOW_DISSECT_RET_CONTINUE: 970 break; 971 case FLOW_DISSECT_RET_OUT_BAD: 972 default: 973 goto out_bad; 974 } 975 976 out_good: 977 ret = true; 978 979 key_control->thoff = (u16)nhoff; 980 out: 981 key_basic->n_proto = proto; 982 key_basic->ip_proto = ip_proto; 983 984 return ret; 985 986 out_bad: 987 ret = false; 988 key_control->thoff = min_t(u16, nhoff, skb ? skb->len : hlen); 989 goto out; 990 } 991 EXPORT_SYMBOL(__skb_flow_dissect); 992 993 static u32 hashrnd __read_mostly; 994 static __always_inline void __flow_hash_secret_init(void) 995 { 996 net_get_random_once(&hashrnd, sizeof(hashrnd)); 997 } 998 999 static __always_inline u32 __flow_hash_words(const u32 *words, u32 length, 1000 u32 keyval) 1001 { 1002 return jhash2(words, length, keyval); 1003 } 1004 1005 static inline const u32 *flow_keys_hash_start(const struct flow_keys *flow) 1006 { 1007 const void *p = flow; 1008 1009 BUILD_BUG_ON(FLOW_KEYS_HASH_OFFSET % sizeof(u32)); 1010 return (const u32 *)(p + FLOW_KEYS_HASH_OFFSET); 1011 } 1012 1013 static inline size_t flow_keys_hash_length(const struct flow_keys *flow) 1014 { 1015 size_t diff = FLOW_KEYS_HASH_OFFSET + sizeof(flow->addrs); 1016 BUILD_BUG_ON((sizeof(*flow) - FLOW_KEYS_HASH_OFFSET) % sizeof(u32)); 1017 BUILD_BUG_ON(offsetof(typeof(*flow), addrs) != 1018 sizeof(*flow) - sizeof(flow->addrs)); 1019 1020 switch (flow->control.addr_type) { 1021 case FLOW_DISSECTOR_KEY_IPV4_ADDRS: 1022 diff -= sizeof(flow->addrs.v4addrs); 1023 break; 1024 case FLOW_DISSECTOR_KEY_IPV6_ADDRS: 1025 diff -= sizeof(flow->addrs.v6addrs); 1026 break; 1027 case FLOW_DISSECTOR_KEY_TIPC_ADDRS: 1028 diff -= sizeof(flow->addrs.tipcaddrs); 1029 break; 1030 } 1031 return (sizeof(*flow) - diff) / sizeof(u32); 1032 } 1033 1034 __be32 flow_get_u32_src(const struct flow_keys *flow) 1035 { 1036 switch (flow->control.addr_type) { 1037 case FLOW_DISSECTOR_KEY_IPV4_ADDRS: 1038 return flow->addrs.v4addrs.src; 1039 case FLOW_DISSECTOR_KEY_IPV6_ADDRS: 1040 return (__force __be32)ipv6_addr_hash( 1041 &flow->addrs.v6addrs.src); 1042 case FLOW_DISSECTOR_KEY_TIPC_ADDRS: 1043 return flow->addrs.tipcaddrs.srcnode; 1044 default: 1045 return 0; 1046 } 1047 } 1048 EXPORT_SYMBOL(flow_get_u32_src); 1049 1050 __be32 flow_get_u32_dst(const struct flow_keys *flow) 1051 { 1052 switch (flow->control.addr_type) { 1053 case FLOW_DISSECTOR_KEY_IPV4_ADDRS: 1054 return flow->addrs.v4addrs.dst; 1055 case FLOW_DISSECTOR_KEY_IPV6_ADDRS: 1056 return (__force __be32)ipv6_addr_hash( 1057 &flow->addrs.v6addrs.dst); 1058 default: 1059 return 0; 1060 } 1061 } 1062 EXPORT_SYMBOL(flow_get_u32_dst); 1063 1064 static inline void __flow_hash_consistentify(struct flow_keys *keys) 1065 { 1066 int addr_diff, i; 1067 1068 switch (keys->control.addr_type) { 1069 case FLOW_DISSECTOR_KEY_IPV4_ADDRS: 1070 addr_diff = (__force u32)keys->addrs.v4addrs.dst - 1071 (__force u32)keys->addrs.v4addrs.src; 1072 if ((addr_diff < 0) || 1073 (addr_diff == 0 && 1074 ((__force u16)keys->ports.dst < 1075 (__force u16)keys->ports.src))) { 1076 swap(keys->addrs.v4addrs.src, keys->addrs.v4addrs.dst); 1077 swap(keys->ports.src, keys->ports.dst); 1078 } 1079 break; 1080 case FLOW_DISSECTOR_KEY_IPV6_ADDRS: 1081 addr_diff = memcmp(&keys->addrs.v6addrs.dst, 1082 &keys->addrs.v6addrs.src, 1083 sizeof(keys->addrs.v6addrs.dst)); 1084 if ((addr_diff < 0) || 1085 (addr_diff == 0 && 1086 ((__force u16)keys->ports.dst < 1087 (__force u16)keys->ports.src))) { 1088 for (i = 0; i < 4; i++) 1089 swap(keys->addrs.v6addrs.src.s6_addr32[i], 1090 keys->addrs.v6addrs.dst.s6_addr32[i]); 1091 swap(keys->ports.src, keys->ports.dst); 1092 } 1093 break; 1094 } 1095 } 1096 1097 static inline u32 __flow_hash_from_keys(struct flow_keys *keys, u32 keyval) 1098 { 1099 u32 hash; 1100 1101 __flow_hash_consistentify(keys); 1102 1103 hash = __flow_hash_words(flow_keys_hash_start(keys), 1104 flow_keys_hash_length(keys), keyval); 1105 if (!hash) 1106 hash = 1; 1107 1108 return hash; 1109 } 1110 1111 u32 flow_hash_from_keys(struct flow_keys *keys) 1112 { 1113 __flow_hash_secret_init(); 1114 return __flow_hash_from_keys(keys, hashrnd); 1115 } 1116 EXPORT_SYMBOL(flow_hash_from_keys); 1117 1118 static inline u32 ___skb_get_hash(const struct sk_buff *skb, 1119 struct flow_keys *keys, u32 keyval) 1120 { 1121 skb_flow_dissect_flow_keys(skb, keys, 1122 FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL); 1123 1124 return __flow_hash_from_keys(keys, keyval); 1125 } 1126 1127 struct _flow_keys_digest_data { 1128 __be16 n_proto; 1129 u8 ip_proto; 1130 u8 padding; 1131 __be32 ports; 1132 __be32 src; 1133 __be32 dst; 1134 }; 1135 1136 void make_flow_keys_digest(struct flow_keys_digest *digest, 1137 const struct flow_keys *flow) 1138 { 1139 struct _flow_keys_digest_data *data = 1140 (struct _flow_keys_digest_data *)digest; 1141 1142 BUILD_BUG_ON(sizeof(*data) > sizeof(*digest)); 1143 1144 memset(digest, 0, sizeof(*digest)); 1145 1146 data->n_proto = flow->basic.n_proto; 1147 data->ip_proto = flow->basic.ip_proto; 1148 data->ports = flow->ports.ports; 1149 data->src = flow->addrs.v4addrs.src; 1150 data->dst = flow->addrs.v4addrs.dst; 1151 } 1152 EXPORT_SYMBOL(make_flow_keys_digest); 1153 1154 static struct flow_dissector flow_keys_dissector_symmetric __read_mostly; 1155 1156 u32 __skb_get_hash_symmetric(const struct sk_buff *skb) 1157 { 1158 struct flow_keys keys; 1159 1160 __flow_hash_secret_init(); 1161 1162 memset(&keys, 0, sizeof(keys)); 1163 __skb_flow_dissect(skb, &flow_keys_dissector_symmetric, &keys, 1164 NULL, 0, 0, 0, 1165 FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL); 1166 1167 return __flow_hash_from_keys(&keys, hashrnd); 1168 } 1169 EXPORT_SYMBOL_GPL(__skb_get_hash_symmetric); 1170 1171 /** 1172 * __skb_get_hash: calculate a flow hash 1173 * @skb: sk_buff to calculate flow hash from 1174 * 1175 * This function calculates a flow hash based on src/dst addresses 1176 * and src/dst port numbers. Sets hash in skb to non-zero hash value 1177 * on success, zero indicates no valid hash. Also, sets l4_hash in skb 1178 * if hash is a canonical 4-tuple hash over transport ports. 1179 */ 1180 void __skb_get_hash(struct sk_buff *skb) 1181 { 1182 struct flow_keys keys; 1183 u32 hash; 1184 1185 __flow_hash_secret_init(); 1186 1187 hash = ___skb_get_hash(skb, &keys, hashrnd); 1188 1189 __skb_set_sw_hash(skb, hash, flow_keys_have_l4(&keys)); 1190 } 1191 EXPORT_SYMBOL(__skb_get_hash); 1192 1193 __u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb) 1194 { 1195 struct flow_keys keys; 1196 1197 return ___skb_get_hash(skb, &keys, perturb); 1198 } 1199 EXPORT_SYMBOL(skb_get_hash_perturb); 1200 1201 u32 __skb_get_poff(const struct sk_buff *skb, void *data, 1202 const struct flow_keys *keys, int hlen) 1203 { 1204 u32 poff = keys->control.thoff; 1205 1206 /* skip L4 headers for fragments after the first */ 1207 if ((keys->control.flags & FLOW_DIS_IS_FRAGMENT) && 1208 !(keys->control.flags & FLOW_DIS_FIRST_FRAG)) 1209 return poff; 1210 1211 switch (keys->basic.ip_proto) { 1212 case IPPROTO_TCP: { 1213 /* access doff as u8 to avoid unaligned access */ 1214 const u8 *doff; 1215 u8 _doff; 1216 1217 doff = __skb_header_pointer(skb, poff + 12, sizeof(_doff), 1218 data, hlen, &_doff); 1219 if (!doff) 1220 return poff; 1221 1222 poff += max_t(u32, sizeof(struct tcphdr), (*doff & 0xF0) >> 2); 1223 break; 1224 } 1225 case IPPROTO_UDP: 1226 case IPPROTO_UDPLITE: 1227 poff += sizeof(struct udphdr); 1228 break; 1229 /* For the rest, we do not really care about header 1230 * extensions at this point for now. 1231 */ 1232 case IPPROTO_ICMP: 1233 poff += sizeof(struct icmphdr); 1234 break; 1235 case IPPROTO_ICMPV6: 1236 poff += sizeof(struct icmp6hdr); 1237 break; 1238 case IPPROTO_IGMP: 1239 poff += sizeof(struct igmphdr); 1240 break; 1241 case IPPROTO_DCCP: 1242 poff += sizeof(struct dccp_hdr); 1243 break; 1244 case IPPROTO_SCTP: 1245 poff += sizeof(struct sctphdr); 1246 break; 1247 } 1248 1249 return poff; 1250 } 1251 1252 /** 1253 * skb_get_poff - get the offset to the payload 1254 * @skb: sk_buff to get the payload offset from 1255 * 1256 * The function will get the offset to the payload as far as it could 1257 * be dissected. The main user is currently BPF, so that we can dynamically 1258 * truncate packets without needing to push actual payload to the user 1259 * space and can analyze headers only, instead. 1260 */ 1261 u32 skb_get_poff(const struct sk_buff *skb) 1262 { 1263 struct flow_keys keys; 1264 1265 if (!skb_flow_dissect_flow_keys(skb, &keys, 0)) 1266 return 0; 1267 1268 return __skb_get_poff(skb, skb->data, &keys, skb_headlen(skb)); 1269 } 1270 1271 __u32 __get_hash_from_flowi6(const struct flowi6 *fl6, struct flow_keys *keys) 1272 { 1273 memset(keys, 0, sizeof(*keys)); 1274 1275 memcpy(&keys->addrs.v6addrs.src, &fl6->saddr, 1276 sizeof(keys->addrs.v6addrs.src)); 1277 memcpy(&keys->addrs.v6addrs.dst, &fl6->daddr, 1278 sizeof(keys->addrs.v6addrs.dst)); 1279 keys->control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS; 1280 keys->ports.src = fl6->fl6_sport; 1281 keys->ports.dst = fl6->fl6_dport; 1282 keys->keyid.keyid = fl6->fl6_gre_key; 1283 keys->tags.flow_label = (__force u32)fl6->flowlabel; 1284 keys->basic.ip_proto = fl6->flowi6_proto; 1285 1286 return flow_hash_from_keys(keys); 1287 } 1288 EXPORT_SYMBOL(__get_hash_from_flowi6); 1289 1290 __u32 __get_hash_from_flowi4(const struct flowi4 *fl4, struct flow_keys *keys) 1291 { 1292 memset(keys, 0, sizeof(*keys)); 1293 1294 keys->addrs.v4addrs.src = fl4->saddr; 1295 keys->addrs.v4addrs.dst = fl4->daddr; 1296 keys->control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS; 1297 keys->ports.src = fl4->fl4_sport; 1298 keys->ports.dst = fl4->fl4_dport; 1299 keys->keyid.keyid = fl4->fl4_gre_key; 1300 keys->basic.ip_proto = fl4->flowi4_proto; 1301 1302 return flow_hash_from_keys(keys); 1303 } 1304 EXPORT_SYMBOL(__get_hash_from_flowi4); 1305 1306 static const struct flow_dissector_key flow_keys_dissector_keys[] = { 1307 { 1308 .key_id = FLOW_DISSECTOR_KEY_CONTROL, 1309 .offset = offsetof(struct flow_keys, control), 1310 }, 1311 { 1312 .key_id = FLOW_DISSECTOR_KEY_BASIC, 1313 .offset = offsetof(struct flow_keys, basic), 1314 }, 1315 { 1316 .key_id = FLOW_DISSECTOR_KEY_IPV4_ADDRS, 1317 .offset = offsetof(struct flow_keys, addrs.v4addrs), 1318 }, 1319 { 1320 .key_id = FLOW_DISSECTOR_KEY_IPV6_ADDRS, 1321 .offset = offsetof(struct flow_keys, addrs.v6addrs), 1322 }, 1323 { 1324 .key_id = FLOW_DISSECTOR_KEY_TIPC_ADDRS, 1325 .offset = offsetof(struct flow_keys, addrs.tipcaddrs), 1326 }, 1327 { 1328 .key_id = FLOW_DISSECTOR_KEY_PORTS, 1329 .offset = offsetof(struct flow_keys, ports), 1330 }, 1331 { 1332 .key_id = FLOW_DISSECTOR_KEY_VLAN, 1333 .offset = offsetof(struct flow_keys, vlan), 1334 }, 1335 { 1336 .key_id = FLOW_DISSECTOR_KEY_FLOW_LABEL, 1337 .offset = offsetof(struct flow_keys, tags), 1338 }, 1339 { 1340 .key_id = FLOW_DISSECTOR_KEY_GRE_KEYID, 1341 .offset = offsetof(struct flow_keys, keyid), 1342 }, 1343 }; 1344 1345 static const struct flow_dissector_key flow_keys_dissector_symmetric_keys[] = { 1346 { 1347 .key_id = FLOW_DISSECTOR_KEY_CONTROL, 1348 .offset = offsetof(struct flow_keys, control), 1349 }, 1350 { 1351 .key_id = FLOW_DISSECTOR_KEY_BASIC, 1352 .offset = offsetof(struct flow_keys, basic), 1353 }, 1354 { 1355 .key_id = FLOW_DISSECTOR_KEY_IPV4_ADDRS, 1356 .offset = offsetof(struct flow_keys, addrs.v4addrs), 1357 }, 1358 { 1359 .key_id = FLOW_DISSECTOR_KEY_IPV6_ADDRS, 1360 .offset = offsetof(struct flow_keys, addrs.v6addrs), 1361 }, 1362 { 1363 .key_id = FLOW_DISSECTOR_KEY_PORTS, 1364 .offset = offsetof(struct flow_keys, ports), 1365 }, 1366 }; 1367 1368 static const struct flow_dissector_key flow_keys_buf_dissector_keys[] = { 1369 { 1370 .key_id = FLOW_DISSECTOR_KEY_CONTROL, 1371 .offset = offsetof(struct flow_keys, control), 1372 }, 1373 { 1374 .key_id = FLOW_DISSECTOR_KEY_BASIC, 1375 .offset = offsetof(struct flow_keys, basic), 1376 }, 1377 }; 1378 1379 struct flow_dissector flow_keys_dissector __read_mostly; 1380 EXPORT_SYMBOL(flow_keys_dissector); 1381 1382 struct flow_dissector flow_keys_buf_dissector __read_mostly; 1383 1384 static int __init init_default_flow_dissectors(void) 1385 { 1386 skb_flow_dissector_init(&flow_keys_dissector, 1387 flow_keys_dissector_keys, 1388 ARRAY_SIZE(flow_keys_dissector_keys)); 1389 skb_flow_dissector_init(&flow_keys_dissector_symmetric, 1390 flow_keys_dissector_symmetric_keys, 1391 ARRAY_SIZE(flow_keys_dissector_symmetric_keys)); 1392 skb_flow_dissector_init(&flow_keys_buf_dissector, 1393 flow_keys_buf_dissector_keys, 1394 ARRAY_SIZE(flow_keys_buf_dissector_keys)); 1395 return 0; 1396 } 1397 1398 core_initcall(init_default_flow_dissectors); 1399