flow_dissector.c 19.4 KB
Newer Older
1
#include <linux/kernel.h>
E
Eric Dumazet 已提交
2
#include <linux/skbuff.h>
3
#include <linux/export.h>
E
Eric Dumazet 已提交
4 5 6 7
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/if_vlan.h>
#include <net/ip.h>
E
Eric Dumazet 已提交
8
#include <net/ipv6.h>
9 10 11 12
#include <linux/igmp.h>
#include <linux/icmp.h>
#include <linux/sctp.h>
#include <linux/dccp.h>
E
Eric Dumazet 已提交
13 14 15
#include <linux/if_tunnel.h>
#include <linux/if_pppox.h>
#include <linux/ppp_defs.h>
16
#include <linux/stddef.h>
17
#include <linux/if_ether.h>
18
#include <linux/mpls.h>
19
#include <net/flow_dissector.h>
20
#include <scsi/fc/fc_fcoe.h>
E
Eric Dumazet 已提交
21

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
static bool skb_flow_dissector_uses_key(struct flow_dissector *flow_dissector,
					enum flow_dissector_key_id key_id)
{
	return flow_dissector->used_keys & (1 << key_id);
}

static void skb_flow_dissector_set_key(struct flow_dissector *flow_dissector,
				       enum flow_dissector_key_id key_id)
{
	flow_dissector->used_keys |= (1 << key_id);
}

static void *skb_flow_dissector_target(struct flow_dissector *flow_dissector,
				       enum flow_dissector_key_id key_id,
				       void *target_container)
{
	return ((char *) target_container) + flow_dissector->offset[key_id];
}

void skb_flow_dissector_init(struct flow_dissector *flow_dissector,
			     const struct flow_dissector_key *key,
			     unsigned int key_count)
{
	unsigned int i;

	memset(flow_dissector, 0, sizeof(*flow_dissector));

	for (i = 0; i < key_count; i++, key++) {
		/* User should make sure that every key target offset is withing
		 * boundaries of unsigned short.
		 */
		BUG_ON(key->offset > USHRT_MAX);
		BUG_ON(skb_flow_dissector_uses_key(flow_dissector,
						   key->key_id));

		skb_flow_dissector_set_key(flow_dissector, key->key_id);
		flow_dissector->offset[key->key_id] = key->offset;
	}

61 62
	/* Ensure that the dissector always includes control and basic key.
	 * That way we are able to avoid handling lack of these in fast path.
63
	 */
64 65
	BUG_ON(!skb_flow_dissector_uses_key(flow_dissector,
					    FLOW_DISSECTOR_KEY_CONTROL));
66 67 68 69 70
	BUG_ON(!skb_flow_dissector_uses_key(flow_dissector,
					    FLOW_DISSECTOR_KEY_BASIC));
}
EXPORT_SYMBOL(skb_flow_dissector_init);

71
/**
72 73
 * __skb_flow_get_ports - extract the upper layer ports and return them
 * @skb: sk_buff to extract the ports from
74 75
 * @thoff: transport header offset
 * @ip_proto: protocol for which to get port offset
76 77
 * @data: raw buffer pointer to the packet, if NULL use skb->data
 * @hlen: packet header length, if @data is NULL use skb_headlen(skb)
78 79 80 81
 *
 * The function will try to retrieve the ports at offset thoff + poff where poff
 * is the protocol port offset returned from proto_ports_offset
 */
82 83
__be32 __skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto,
			    void *data, int hlen)
84 85 86
{
	int poff = proto_ports_offset(ip_proto);

87 88 89 90 91
	if (!data) {
		data = skb->data;
		hlen = skb_headlen(skb);
	}

92 93 94
	if (poff >= 0) {
		__be32 *ports, _ports;

95 96
		ports = __skb_header_pointer(skb, thoff + poff,
					     sizeof(_ports), data, hlen, &_ports);
97 98 99 100 101 102
		if (ports)
			return *ports;
	}

	return 0;
}
103
EXPORT_SYMBOL(__skb_flow_get_ports);
104

105 106 107
/**
 * __skb_flow_dissect - extract the flow_keys struct and return it
 * @skb: sk_buff to extract the flow from, can be NULL if the rest are specified
108 109
 * @flow_dissector: list of keys to dissect
 * @target_container: target structure to put dissected values into
110 111 112 113 114
 * @data: raw buffer pointer to the packet, if NULL use skb->data
 * @proto: protocol for which to get the flow, if @data is NULL use skb->protocol
 * @nhoff: network header offset, if @data is NULL use skb_network_offset(skb)
 * @hlen: packet header length, if @data is NULL use skb_headlen(skb)
 *
115 116 117 118 119
 * The function will try to retrieve individual keys into target specified
 * by flow_dissector from either the skbuff or a raw buffer specified by the
 * rest parameters.
 *
 * Caller must take care of zeroing target container memory.
120
 */
121 122 123
bool __skb_flow_dissect(const struct sk_buff *skb,
			struct flow_dissector *flow_dissector,
			void *target_container,
124
			void *data, __be16 proto, int nhoff, int hlen)
E
Eric Dumazet 已提交
125
{
126
	struct flow_dissector_key_control *key_control;
127 128 129
	struct flow_dissector_key_basic *key_basic;
	struct flow_dissector_key_addrs *key_addrs;
	struct flow_dissector_key_ports *key_ports;
T
Tom Herbert 已提交
130
	struct flow_dissector_key_tags *key_tags;
T
Tom Herbert 已提交
131
	struct flow_dissector_key_keyid *key_keyid;
132
	u8 ip_proto = 0;
E
Eric Dumazet 已提交
133

134 135
	if (!data) {
		data = skb->data;
136 137
		proto = skb->protocol;
		nhoff = skb_network_offset(skb);
138 139 140
		hlen = skb_headlen(skb);
	}

141 142 143 144 145 146 147
	/* It is ensured by skb_flow_dissector_init() that control key will
	 * be always present.
	 */
	key_control = skb_flow_dissector_target(flow_dissector,
						FLOW_DISSECTOR_KEY_CONTROL,
						target_container);

148 149 150 151 152 153
	/* It is ensured by skb_flow_dissector_init() that basic key will
	 * be always present.
	 */
	key_basic = skb_flow_dissector_target(flow_dissector,
					      FLOW_DISSECTOR_KEY_BASIC,
					      target_container);
E
Eric Dumazet 已提交
154

155 156 157 158 159 160 161 162 163 164 165
	if (skb_flow_dissector_uses_key(flow_dissector,
					FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
		struct ethhdr *eth = eth_hdr(skb);
		struct flow_dissector_key_eth_addrs *key_eth_addrs;

		key_eth_addrs = skb_flow_dissector_target(flow_dissector,
							  FLOW_DISSECTOR_KEY_ETH_ADDRS,
							  target_container);
		memcpy(key_eth_addrs, &eth->h_dest, sizeof(*key_eth_addrs));
	}

E
Eric Dumazet 已提交
166 167
again:
	switch (proto) {
168
	case htons(ETH_P_IP): {
E
Eric Dumazet 已提交
169 170 171
		const struct iphdr *iph;
		struct iphdr _iph;
ip:
172
		iph = __skb_header_pointer(skb, nhoff, sizeof(_iph), data, hlen, &_iph);
173
		if (!iph || iph->ihl < 5)
E
Eric Dumazet 已提交
174
			return false;
175
		nhoff += iph->ihl * 4;
E
Eric Dumazet 已提交
176

177
		ip_proto = iph->protocol;
E
Eric Dumazet 已提交
178 179
		if (ip_is_fragment(iph))
			ip_proto = 0;
180

181 182
		if (!skb_flow_dissector_uses_key(flow_dissector,
						 FLOW_DISSECTOR_KEY_IPV4_ADDRS))
183
			break;
184

185
		key_addrs = skb_flow_dissector_target(flow_dissector,
186 187 188 189
			      FLOW_DISSECTOR_KEY_IPV4_ADDRS, target_container);
		memcpy(&key_addrs->v4addrs, &iph->saddr,
		       sizeof(key_addrs->v4addrs));
		key_control->addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
E
Eric Dumazet 已提交
190 191
		break;
	}
192
	case htons(ETH_P_IPV6): {
E
Eric Dumazet 已提交
193 194
		const struct ipv6hdr *iph;
		struct ipv6hdr _iph;
195 196
		__be32 flow_label;

E
Eric Dumazet 已提交
197
ipv6:
198
		iph = __skb_header_pointer(skb, nhoff, sizeof(_iph), data, hlen, &_iph);
E
Eric Dumazet 已提交
199 200 201 202 203
		if (!iph)
			return false;

		ip_proto = iph->nexthdr;
		nhoff += sizeof(struct ipv6hdr);
204

205 206 207 208 209 210 211
		if (skb_flow_dissector_uses_key(flow_dissector,
						FLOW_DISSECTOR_KEY_IPV6_ADDRS)) {
			struct flow_dissector_key_ipv6_addrs *key_ipv6_addrs;

			key_ipv6_addrs = skb_flow_dissector_target(flow_dissector,
								   FLOW_DISSECTOR_KEY_IPV6_ADDRS,
								   target_container);
212

213
			memcpy(key_ipv6_addrs, &iph->saddr, sizeof(*key_ipv6_addrs));
214
			key_control->addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
215
		}
216

217 218
		flow_label = ip6_flowlabel(iph);
		if (flow_label) {
219
			if (skb_flow_dissector_uses_key(flow_dissector,
220 221 222 223 224
				FLOW_DISSECTOR_KEY_FLOW_LABEL)) {
				key_tags = skb_flow_dissector_target(flow_dissector,
								     FLOW_DISSECTOR_KEY_FLOW_LABEL,
								     target_container);
				key_tags->flow_label = ntohl(flow_label);
225
			}
226 227
		}

E
Eric Dumazet 已提交
228 229
		break;
	}
230 231
	case htons(ETH_P_8021AD):
	case htons(ETH_P_8021Q): {
E
Eric Dumazet 已提交
232 233 234
		const struct vlan_hdr *vlan;
		struct vlan_hdr _vlan;

235
		vlan = __skb_header_pointer(skb, nhoff, sizeof(_vlan), data, hlen, &_vlan);
E
Eric Dumazet 已提交
236 237 238
		if (!vlan)
			return false;

T
Tom Herbert 已提交
239 240 241 242 243 244 245 246 247
		if (skb_flow_dissector_uses_key(flow_dissector,
						FLOW_DISSECTOR_KEY_VLANID)) {
			key_tags = skb_flow_dissector_target(flow_dissector,
							     FLOW_DISSECTOR_KEY_VLANID,
							     target_container);

			key_tags->vlan_id = skb_vlan_tag_get_id(skb);
		}

E
Eric Dumazet 已提交
248 249 250 251
		proto = vlan->h_vlan_encapsulated_proto;
		nhoff += sizeof(*vlan);
		goto again;
	}
252
	case htons(ETH_P_PPP_SES): {
E
Eric Dumazet 已提交
253 254 255 256
		struct {
			struct pppoe_hdr hdr;
			__be16 proto;
		} *hdr, _hdr;
257
		hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr);
E
Eric Dumazet 已提交
258 259 260 261 262
		if (!hdr)
			return false;
		proto = hdr->proto;
		nhoff += PPPOE_SES_HLEN;
		switch (proto) {
263
		case htons(PPP_IP):
E
Eric Dumazet 已提交
264
			goto ip;
265
		case htons(PPP_IPV6):
E
Eric Dumazet 已提交
266 267 268 269 270
			goto ipv6;
		default:
			return false;
		}
	}
E
Erik Hugne 已提交
271 272 273 274 275 276 277 278
	case htons(ETH_P_TIPC): {
		struct {
			__be32 pre[3];
			__be32 srcnode;
		} *hdr, _hdr;
		hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr);
		if (!hdr)
			return false;
279
		key_basic->n_proto = proto;
280
		key_control->thoff = (u16)nhoff;
281 282

		if (skb_flow_dissector_uses_key(flow_dissector,
T
Tom Herbert 已提交
283
						FLOW_DISSECTOR_KEY_TIPC_ADDRS)) {
284
			key_addrs = skb_flow_dissector_target(flow_dissector,
T
Tom Herbert 已提交
285
							      FLOW_DISSECTOR_KEY_TIPC_ADDRS,
286
							      target_container);
T
Tom Herbert 已提交
287 288
			key_addrs->tipcaddrs.srcnode = hdr->srcnode;
			key_control->addr_type = FLOW_DISSECTOR_KEY_TIPC_ADDRS;
289
		}
E
Erik Hugne 已提交
290 291
		return true;
	}
292 293 294 295 296 297 298 299 300 301

	case htons(ETH_P_MPLS_UC):
	case htons(ETH_P_MPLS_MC): {
		struct mpls_label *hdr, _hdr[2];
mpls:
		hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data,
					   hlen, &_hdr);
		if (!hdr)
			return false;

302 303
		if ((ntohl(hdr[0].entry) & MPLS_LS_LABEL_MASK) >>
		     MPLS_LS_LABEL_SHIFT == MPLS_LABEL_ENTROPY) {
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
			if (skb_flow_dissector_uses_key(flow_dissector,
							FLOW_DISSECTOR_KEY_MPLS_ENTROPY)) {
				key_keyid = skb_flow_dissector_target(flow_dissector,
								      FLOW_DISSECTOR_KEY_MPLS_ENTROPY,
								      target_container);
				key_keyid->keyid = hdr[1].entry &
					htonl(MPLS_LS_LABEL_MASK);
			}

			key_basic->n_proto = proto;
			key_basic->ip_proto = ip_proto;
			key_control->thoff = (u16)nhoff;

			return true;
		}

		return true;
	}

323
	case htons(ETH_P_FCOE):
324
		key_control->thoff = (u16)(nhoff + FCOE_HEADER_LEN);
325
		/* fall through */
E
Eric Dumazet 已提交
326 327 328 329
	default:
		return false;
	}

330
ip_proto_again:
E
Eric Dumazet 已提交
331 332 333 334 335 336 337
	switch (ip_proto) {
	case IPPROTO_GRE: {
		struct gre_hdr {
			__be16 flags;
			__be16 proto;
		} *hdr, _hdr;

338
		hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr);
E
Eric Dumazet 已提交
339 340 341 342 343 344
		if (!hdr)
			return false;
		/*
		 * Only look inside GRE if version zero and no
		 * routing
		 */
345 346 347 348 349 350
		if (hdr->flags & (GRE_VERSION | GRE_ROUTING))
			break;

		proto = hdr->proto;
		nhoff += 4;
		if (hdr->flags & GRE_CSUM)
E
Eric Dumazet 已提交
351
			nhoff += 4;
T
Tom Herbert 已提交
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
		if (hdr->flags & GRE_KEY) {
			const __be32 *keyid;
			__be32 _keyid;

			keyid = __skb_header_pointer(skb, nhoff, sizeof(_keyid),
						     data, hlen, &_keyid);

			if (!keyid)
				return false;

			if (skb_flow_dissector_uses_key(flow_dissector,
							FLOW_DISSECTOR_KEY_GRE_KEYID)) {
				key_keyid = skb_flow_dissector_target(flow_dissector,
								      FLOW_DISSECTOR_KEY_GRE_KEYID,
								      target_container);
				key_keyid->keyid = *keyid;
			}
369
			nhoff += 4;
T
Tom Herbert 已提交
370
		}
371 372 373 374 375 376 377 378 379 380 381 382 383
		if (hdr->flags & GRE_SEQ)
			nhoff += 4;
		if (proto == htons(ETH_P_TEB)) {
			const struct ethhdr *eth;
			struct ethhdr _eth;

			eth = __skb_header_pointer(skb, nhoff,
						   sizeof(_eth),
						   data, hlen, &_eth);
			if (!eth)
				return false;
			proto = eth->h_proto;
			nhoff += sizeof(*eth);
E
Eric Dumazet 已提交
384
		}
385
		goto again;
E
Eric Dumazet 已提交
386
	}
387 388 389 390 391 392 393 394 395 396
	case NEXTHDR_HOP:
	case NEXTHDR_ROUTING:
	case NEXTHDR_DEST: {
		u8 _opthdr[2], *opthdr;

		if (proto != htons(ETH_P_IPV6))
			break;

		opthdr = __skb_header_pointer(skb, nhoff, sizeof(_opthdr),
					      data, hlen, &_opthdr);
397 398
		if (!opthdr)
			return false;
399

400 401
		ip_proto = opthdr[0];
		nhoff += (opthdr[1] + 1) << 3;
402 403 404

		goto ip_proto_again;
	}
E
Eric Dumazet 已提交
405
	case IPPROTO_IPIP:
T
Tom Herbert 已提交
406 407
		proto = htons(ETH_P_IP);
		goto ip;
408 409 410
	case IPPROTO_IPV6:
		proto = htons(ETH_P_IPV6);
		goto ipv6;
411 412 413
	case IPPROTO_MPLS:
		proto = htons(ETH_P_MPLS_UC);
		goto mpls;
E
Eric Dumazet 已提交
414 415 416 417
	default:
		break;
	}

418 419
	key_basic->n_proto = proto;
	key_basic->ip_proto = ip_proto;
420
	key_control->thoff = (u16)nhoff;
421 422 423 424 425 426 427 428 429

	if (skb_flow_dissector_uses_key(flow_dissector,
					FLOW_DISSECTOR_KEY_PORTS)) {
		key_ports = skb_flow_dissector_target(flow_dissector,
						      FLOW_DISSECTOR_KEY_PORTS,
						      target_container);
		key_ports->ports = __skb_flow_get_ports(skb, nhoff, ip_proto,
							data, hlen);
	}
430

E
Eric Dumazet 已提交
431 432
	return true;
}
433
EXPORT_SYMBOL(__skb_flow_dissect);
434 435

static u32 hashrnd __read_mostly;
436 437 438 439 440
static __always_inline void __flow_hash_secret_init(void)
{
	net_get_random_once(&hashrnd, sizeof(hashrnd));
}

441 442 443 444 445 446
static __always_inline u32 __flow_hash_words(u32 *words, u32 length, u32 keyval)
{
	return jhash2(words, length, keyval);
}

static inline void *flow_keys_hash_start(struct flow_keys *flow)
447
{
448 449 450 451 452 453
	BUILD_BUG_ON(FLOW_KEYS_HASH_OFFSET % sizeof(u32));
	return (void *)flow + FLOW_KEYS_HASH_OFFSET;
}

static inline size_t flow_keys_hash_length(struct flow_keys *flow)
{
454
	size_t diff = FLOW_KEYS_HASH_OFFSET + sizeof(flow->addrs);
455
	BUILD_BUG_ON((sizeof(*flow) - FLOW_KEYS_HASH_OFFSET) % sizeof(u32));
456 457 458 459 460 461 462 463 464 465
	BUILD_BUG_ON(offsetof(typeof(*flow), addrs) !=
		     sizeof(*flow) - sizeof(flow->addrs));

	switch (flow->control.addr_type) {
	case FLOW_DISSECTOR_KEY_IPV4_ADDRS:
		diff -= sizeof(flow->addrs.v4addrs);
		break;
	case FLOW_DISSECTOR_KEY_IPV6_ADDRS:
		diff -= sizeof(flow->addrs.v6addrs);
		break;
T
Tom Herbert 已提交
466 467 468
	case FLOW_DISSECTOR_KEY_TIPC_ADDRS:
		diff -= sizeof(flow->addrs.tipcaddrs);
		break;
469 470 471 472 473 474 475 476 477 478 479 480
	}
	return (sizeof(*flow) - diff) / sizeof(u32);
}

__be32 flow_get_u32_src(const struct flow_keys *flow)
{
	switch (flow->control.addr_type) {
	case FLOW_DISSECTOR_KEY_IPV4_ADDRS:
		return flow->addrs.v4addrs.src;
	case FLOW_DISSECTOR_KEY_IPV6_ADDRS:
		return (__force __be32)ipv6_addr_hash(
			&flow->addrs.v6addrs.src);
T
Tom Herbert 已提交
481 482
	case FLOW_DISSECTOR_KEY_TIPC_ADDRS:
		return flow->addrs.tipcaddrs.srcnode;
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
	default:
		return 0;
	}
}
EXPORT_SYMBOL(flow_get_u32_src);

__be32 flow_get_u32_dst(const struct flow_keys *flow)
{
	switch (flow->control.addr_type) {
	case FLOW_DISSECTOR_KEY_IPV4_ADDRS:
		return flow->addrs.v4addrs.dst;
	case FLOW_DISSECTOR_KEY_IPV6_ADDRS:
		return (__force __be32)ipv6_addr_hash(
			&flow->addrs.v6addrs.dst);
	default:
		return 0;
	}
}
EXPORT_SYMBOL(flow_get_u32_dst);

static inline void __flow_hash_consistentify(struct flow_keys *keys)
{
	int addr_diff, i;

	switch (keys->control.addr_type) {
	case FLOW_DISSECTOR_KEY_IPV4_ADDRS:
		addr_diff = (__force u32)keys->addrs.v4addrs.dst -
			    (__force u32)keys->addrs.v4addrs.src;
		if ((addr_diff < 0) ||
		    (addr_diff == 0 &&
		     ((__force u16)keys->ports.dst <
		      (__force u16)keys->ports.src))) {
			swap(keys->addrs.v4addrs.src, keys->addrs.v4addrs.dst);
			swap(keys->ports.src, keys->ports.dst);
		}
		break;
	case FLOW_DISSECTOR_KEY_IPV6_ADDRS:
		addr_diff = memcmp(&keys->addrs.v6addrs.dst,
				   &keys->addrs.v6addrs.src,
				   sizeof(keys->addrs.v6addrs.dst));
		if ((addr_diff < 0) ||
		    (addr_diff == 0 &&
		     ((__force u16)keys->ports.dst <
		      (__force u16)keys->ports.src))) {
			for (i = 0; i < 4; i++)
				swap(keys->addrs.v6addrs.src.s6_addr32[i],
				     keys->addrs.v6addrs.dst.s6_addr32[i]);
			swap(keys->ports.src, keys->ports.dst);
		}
		break;
	}
534 535
}

T
Tom Herbert 已提交
536
static inline u32 __flow_hash_from_keys(struct flow_keys *keys, u32 keyval)
537 538 539
{
	u32 hash;

540
	__flow_hash_consistentify(keys);
541

542 543
	hash = __flow_hash_words((u32 *)flow_keys_hash_start(keys),
				 flow_keys_hash_length(keys), keyval);
544 545 546 547 548 549 550 551
	if (!hash)
		hash = 1;

	return hash;
}

u32 flow_hash_from_keys(struct flow_keys *keys)
{
T
Tom Herbert 已提交
552 553
	__flow_hash_secret_init();
	return __flow_hash_from_keys(keys, hashrnd);
554 555 556
}
EXPORT_SYMBOL(flow_hash_from_keys);

T
Tom Herbert 已提交
557 558 559
static inline u32 ___skb_get_hash(const struct sk_buff *skb,
				  struct flow_keys *keys, u32 keyval)
{
560
	if (!skb_flow_dissect_flow_keys(skb, keys))
T
Tom Herbert 已提交
561 562 563 564 565
		return 0;

	return __flow_hash_from_keys(keys, keyval);
}

T
Tom Herbert 已提交
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
struct _flow_keys_digest_data {
	__be16	n_proto;
	u8	ip_proto;
	u8	padding;
	__be32	ports;
	__be32	src;
	__be32	dst;
};

void make_flow_keys_digest(struct flow_keys_digest *digest,
			   const struct flow_keys *flow)
{
	struct _flow_keys_digest_data *data =
	    (struct _flow_keys_digest_data *)digest;

	BUILD_BUG_ON(sizeof(*data) > sizeof(*digest));

	memset(digest, 0, sizeof(*digest));

585 586 587
	data->n_proto = flow->basic.n_proto;
	data->ip_proto = flow->basic.ip_proto;
	data->ports = flow->ports.ports;
588 589
	data->src = flow->addrs.v4addrs.src;
	data->dst = flow->addrs.v4addrs.dst;
T
Tom Herbert 已提交
590 591 592
}
EXPORT_SYMBOL(make_flow_keys_digest);

593 594 595 596 597
/**
 * __skb_get_hash: calculate a flow hash
 * @skb: sk_buff to calculate flow hash from
 *
 * This function calculates a flow hash based on src/dst addresses
598 599
 * and src/dst port numbers.  Sets hash in skb to non-zero hash value
 * on success, zero indicates no valid hash.  Also, sets l4_hash in skb
600 601
 * if hash is a canonical 4-tuple hash over transport ports.
 */
602
void __skb_get_hash(struct sk_buff *skb)
603 604
{
	struct flow_keys keys;
T
Tom Herbert 已提交
605
	u32 hash;
606

T
Tom Herbert 已提交
607 608 609 610
	__flow_hash_secret_init();

	hash = ___skb_get_hash(skb, &keys, hashrnd);
	if (!hash)
611
		return;
612
	if (keys.ports.ports)
613
		skb->l4_hash = 1;
614
	skb->sw_hash = 1;
T
Tom Herbert 已提交
615
	skb->hash = hash;
616
}
617
EXPORT_SYMBOL(__skb_get_hash);
618

T
Tom Herbert 已提交
619 620 621 622 623 624 625 626
__u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb)
{
	struct flow_keys keys;

	return ___skb_get_hash(skb, &keys, perturb);
}
EXPORT_SYMBOL(skb_get_hash_perturb);

627 628
u32 __skb_get_poff(const struct sk_buff *skb, void *data,
		   const struct flow_keys *keys, int hlen)
629
{
630
	u32 poff = keys->control.thoff;
631

632
	switch (keys->basic.ip_proto) {
633
	case IPPROTO_TCP: {
634 635 636
		/* access doff as u8 to avoid unaligned access */
		const u8 *doff;
		u8 _doff;
637

638 639 640
		doff = __skb_header_pointer(skb, poff + 12, sizeof(_doff),
					    data, hlen, &_doff);
		if (!doff)
641 642
			return poff;

643
		poff += max_t(u32, sizeof(struct tcphdr), (*doff & 0xF0) >> 2);
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
		break;
	}
	case IPPROTO_UDP:
	case IPPROTO_UDPLITE:
		poff += sizeof(struct udphdr);
		break;
	/* For the rest, we do not really care about header
	 * extensions at this point for now.
	 */
	case IPPROTO_ICMP:
		poff += sizeof(struct icmphdr);
		break;
	case IPPROTO_ICMPV6:
		poff += sizeof(struct icmp6hdr);
		break;
	case IPPROTO_IGMP:
		poff += sizeof(struct igmphdr);
		break;
	case IPPROTO_DCCP:
		poff += sizeof(struct dccp_hdr);
		break;
	case IPPROTO_SCTP:
		poff += sizeof(struct sctphdr);
		break;
	}

	return poff;
}

673 674 675 676 677 678
/**
 * skb_get_poff - get the offset to the payload
 * @skb: sk_buff to get the payload offset from
 *
 * The function will get the offset to the payload as far as it could
 * be dissected.  The main user is currently BPF, so that we can dynamically
679 680 681 682 683 684 685
 * truncate packets without needing to push actual payload to the user
 * space and can analyze headers only, instead.
 */
u32 skb_get_poff(const struct sk_buff *skb)
{
	struct flow_keys keys;

686
	if (!skb_flow_dissect_flow_keys(skb, &keys))
687 688 689 690
		return 0;

	return __skb_get_poff(skb, skb->data, &keys, skb_headlen(skb));
}
691 692

static const struct flow_dissector_key flow_keys_dissector_keys[] = {
693 694 695 696
	{
		.key_id = FLOW_DISSECTOR_KEY_CONTROL,
		.offset = offsetof(struct flow_keys, control),
	},
697 698 699 700 701 702
	{
		.key_id = FLOW_DISSECTOR_KEY_BASIC,
		.offset = offsetof(struct flow_keys, basic),
	},
	{
		.key_id = FLOW_DISSECTOR_KEY_IPV4_ADDRS,
703 704 705 706 707
		.offset = offsetof(struct flow_keys, addrs.v4addrs),
	},
	{
		.key_id = FLOW_DISSECTOR_KEY_IPV6_ADDRS,
		.offset = offsetof(struct flow_keys, addrs.v6addrs),
708
	},
T
Tom Herbert 已提交
709 710 711 712
	{
		.key_id = FLOW_DISSECTOR_KEY_TIPC_ADDRS,
		.offset = offsetof(struct flow_keys, addrs.tipcaddrs),
	},
713 714 715 716
	{
		.key_id = FLOW_DISSECTOR_KEY_PORTS,
		.offset = offsetof(struct flow_keys, ports),
	},
T
Tom Herbert 已提交
717 718 719 720
	{
		.key_id = FLOW_DISSECTOR_KEY_VLANID,
		.offset = offsetof(struct flow_keys, tags),
	},
721 722 723 724
	{
		.key_id = FLOW_DISSECTOR_KEY_FLOW_LABEL,
		.offset = offsetof(struct flow_keys, tags),
	},
T
Tom Herbert 已提交
725 726 727 728
	{
		.key_id = FLOW_DISSECTOR_KEY_GRE_KEYID,
		.offset = offsetof(struct flow_keys, keyid),
	},
729 730 731
};

static const struct flow_dissector_key flow_keys_buf_dissector_keys[] = {
732 733 734 735
	{
		.key_id = FLOW_DISSECTOR_KEY_CONTROL,
		.offset = offsetof(struct flow_keys, control),
	},
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
	{
		.key_id = FLOW_DISSECTOR_KEY_BASIC,
		.offset = offsetof(struct flow_keys, basic),
	},
};

struct flow_dissector flow_keys_dissector __read_mostly;
EXPORT_SYMBOL(flow_keys_dissector);

struct flow_dissector flow_keys_buf_dissector __read_mostly;

static int __init init_default_flow_dissectors(void)
{
	skb_flow_dissector_init(&flow_keys_dissector,
				flow_keys_dissector_keys,
				ARRAY_SIZE(flow_keys_dissector_keys));
	skb_flow_dissector_init(&flow_keys_buf_dissector,
				flow_keys_buf_dissector_keys,
				ARRAY_SIZE(flow_keys_buf_dissector_keys));
	return 0;
}

late_initcall_sync(init_default_flow_dissectors);