flow_dissector.c 17.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 <net/flow_dissector.h>
19
#include <scsi/fc/fc_fcoe.h>
E
Eric Dumazet 已提交
20

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
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;
	}

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

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

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

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

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

	return 0;
}
102
EXPORT_SYMBOL(__skb_flow_get_ports);
103

104 105 106
/**
 * __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
107 108
 * @flow_dissector: list of keys to dissect
 * @target_container: target structure to put dissected values into
109 110 111 112 113
 * @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)
 *
114 115 116 117 118
 * 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.
119
 */
120 121 122
bool __skb_flow_dissect(const struct sk_buff *skb,
			struct flow_dissector *flow_dissector,
			void *target_container,
123
			void *data, __be16 proto, int nhoff, int hlen)
E
Eric Dumazet 已提交
124
{
125
	struct flow_dissector_key_control *key_control;
126 127 128
	struct flow_dissector_key_basic *key_basic;
	struct flow_dissector_key_addrs *key_addrs;
	struct flow_dissector_key_ports *key_ports;
E
Eric Dumazet 已提交
129 130
	u8 ip_proto;

131 132
	if (!data) {
		data = skb->data;
133 134
		proto = skb->protocol;
		nhoff = skb_network_offset(skb);
135 136 137
		hlen = skb_headlen(skb);
	}

138 139 140 141 142 143 144
	/* 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);

145 146 147 148 149 150
	/* 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 已提交
151

152 153 154 155 156 157 158 159 160 161 162
	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 已提交
163 164
again:
	switch (proto) {
165
	case htons(ETH_P_IP): {
E
Eric Dumazet 已提交
166 167 168
		const struct iphdr *iph;
		struct iphdr _iph;
ip:
169
		iph = __skb_header_pointer(skb, nhoff, sizeof(_iph), data, hlen, &_iph);
170
		if (!iph || iph->ihl < 5)
E
Eric Dumazet 已提交
171
			return false;
172
		nhoff += iph->ihl * 4;
E
Eric Dumazet 已提交
173

174
		ip_proto = iph->protocol;
E
Eric Dumazet 已提交
175 176
		if (ip_is_fragment(iph))
			ip_proto = 0;
177

178 179
		if (!skb_flow_dissector_uses_key(flow_dissector,
						 FLOW_DISSECTOR_KEY_IPV4_ADDRS))
180
			break;
181

182
		key_addrs = skb_flow_dissector_target(flow_dissector,
183 184 185 186
			      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 已提交
187 188
		break;
	}
189
	case htons(ETH_P_IPV6): {
E
Eric Dumazet 已提交
190 191
		const struct ipv6hdr *iph;
		struct ipv6hdr _iph;
192 193
		__be32 flow_label;

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

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

202 203 204 205 206 207 208
		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);
209

210
			memcpy(key_ipv6_addrs, &iph->saddr, sizeof(*key_ipv6_addrs));
211
			key_control->addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
212 213 214 215
			goto flow_label;
		}
		break;
flow_label:
216 217 218 219 220 221
		flow_label = ip6_flowlabel(iph);
		if (flow_label) {
			/* Awesome, IPv6 packet has a flow label so we can
			 * use that to represent the ports without any
			 * further dissection.
			 */
222 223 224

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

227 228 229 230 231 232 233
			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 = flow_label;
			}
234 235 236 237

			return true;
		}

E
Eric Dumazet 已提交
238 239
		break;
	}
240 241
	case htons(ETH_P_8021AD):
	case htons(ETH_P_8021Q): {
E
Eric Dumazet 已提交
242 243 244
		const struct vlan_hdr *vlan;
		struct vlan_hdr _vlan;

245
		vlan = __skb_header_pointer(skb, nhoff, sizeof(_vlan), data, hlen, &_vlan);
E
Eric Dumazet 已提交
246 247 248 249 250 251 252
		if (!vlan)
			return false;

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

		if (skb_flow_dissector_uses_key(flow_dissector,
T
Tom Herbert 已提交
284
						FLOW_DISSECTOR_KEY_TIPC_ADDRS)) {
285
			key_addrs = skb_flow_dissector_target(flow_dissector,
T
Tom Herbert 已提交
286
							      FLOW_DISSECTOR_KEY_TIPC_ADDRS,
287
							      target_container);
T
Tom Herbert 已提交
288 289
			key_addrs->tipcaddrs.srcnode = hdr->srcnode;
			key_control->addr_type = FLOW_DISSECTOR_KEY_TIPC_ADDRS;
290
		}
E
Erik Hugne 已提交
291 292
		return true;
	}
293
	case htons(ETH_P_FCOE):
294
		key_control->thoff = (u16)(nhoff + FCOE_HEADER_LEN);
295
		/* fall through */
E
Eric Dumazet 已提交
296 297 298 299 300 301 302 303 304 305 306
	default:
		return false;
	}

	switch (ip_proto) {
	case IPPROTO_GRE: {
		struct gre_hdr {
			__be16 flags;
			__be16 proto;
		} *hdr, _hdr;

307
		hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr);
E
Eric Dumazet 已提交
308 309 310 311 312 313
		if (!hdr)
			return false;
		/*
		 * Only look inside GRE if version zero and no
		 * routing
		 */
314 315 316 317 318 319
		if (hdr->flags & (GRE_VERSION | GRE_ROUTING))
			break;

		proto = hdr->proto;
		nhoff += 4;
		if (hdr->flags & GRE_CSUM)
E
Eric Dumazet 已提交
320
			nhoff += 4;
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
		if (hdr->flags & GRE_KEY)
			nhoff += 4;
		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 已提交
336
		}
337
		goto again;
E
Eric Dumazet 已提交
338 339
	}
	case IPPROTO_IPIP:
T
Tom Herbert 已提交
340 341
		proto = htons(ETH_P_IP);
		goto ip;
342 343 344
	case IPPROTO_IPV6:
		proto = htons(ETH_P_IPV6);
		goto ipv6;
E
Eric Dumazet 已提交
345 346 347 348
	default:
		break;
	}

349 350
	key_basic->n_proto = proto;
	key_basic->ip_proto = ip_proto;
351
	key_control->thoff = (u16)nhoff;
352 353 354 355 356 357 358 359 360

	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);
	}
361

E
Eric Dumazet 已提交
362 363
	return true;
}
364
EXPORT_SYMBOL(__skb_flow_dissect);
365 366

static u32 hashrnd __read_mostly;
367 368 369 370 371
static __always_inline void __flow_hash_secret_init(void)
{
	net_get_random_once(&hashrnd, sizeof(hashrnd));
}

372 373 374 375 376 377
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)
378
{
379 380 381 382 383 384
	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)
{
385
	size_t diff = FLOW_KEYS_HASH_OFFSET + sizeof(flow->addrs);
386
	BUILD_BUG_ON((sizeof(*flow) - FLOW_KEYS_HASH_OFFSET) % sizeof(u32));
387 388 389 390 391 392 393 394 395 396
	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 已提交
397 398 399
	case FLOW_DISSECTOR_KEY_TIPC_ADDRS:
		diff -= sizeof(flow->addrs.tipcaddrs);
		break;
400 401 402 403 404 405 406 407 408 409 410 411
	}
	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 已提交
412 413
	case FLOW_DISSECTOR_KEY_TIPC_ADDRS:
		return flow->addrs.tipcaddrs.srcnode;
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
	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;
	}
465 466
}

T
Tom Herbert 已提交
467
static inline u32 __flow_hash_from_keys(struct flow_keys *keys, u32 keyval)
468 469 470
{
	u32 hash;

471
	__flow_hash_consistentify(keys);
472

473 474
	hash = __flow_hash_words((u32 *)flow_keys_hash_start(keys),
				 flow_keys_hash_length(keys), keyval);
475 476 477 478 479 480 481 482
	if (!hash)
		hash = 1;

	return hash;
}

u32 flow_hash_from_keys(struct flow_keys *keys)
{
T
Tom Herbert 已提交
483 484
	__flow_hash_secret_init();
	return __flow_hash_from_keys(keys, hashrnd);
485 486 487
}
EXPORT_SYMBOL(flow_hash_from_keys);

T
Tom Herbert 已提交
488 489 490
static inline u32 ___skb_get_hash(const struct sk_buff *skb,
				  struct flow_keys *keys, u32 keyval)
{
491
	if (!skb_flow_dissect_flow_keys(skb, keys))
T
Tom Herbert 已提交
492 493 494 495 496
		return 0;

	return __flow_hash_from_keys(keys, keyval);
}

T
Tom Herbert 已提交
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
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));

516 517 518
	data->n_proto = flow->basic.n_proto;
	data->ip_proto = flow->basic.ip_proto;
	data->ports = flow->ports.ports;
519 520
	data->src = flow->addrs.v4addrs.src;
	data->dst = flow->addrs.v4addrs.dst;
T
Tom Herbert 已提交
521 522 523
}
EXPORT_SYMBOL(make_flow_keys_digest);

524 525 526 527 528
/**
 * __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
529 530
 * 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
531 532
 * if hash is a canonical 4-tuple hash over transport ports.
 */
533
void __skb_get_hash(struct sk_buff *skb)
534 535
{
	struct flow_keys keys;
T
Tom Herbert 已提交
536
	u32 hash;
537

T
Tom Herbert 已提交
538 539 540 541
	__flow_hash_secret_init();

	hash = ___skb_get_hash(skb, &keys, hashrnd);
	if (!hash)
542
		return;
543
	if (keys.ports.ports)
544
		skb->l4_hash = 1;
545
	skb->sw_hash = 1;
T
Tom Herbert 已提交
546
	skb->hash = hash;
547
}
548
EXPORT_SYMBOL(__skb_get_hash);
549

T
Tom Herbert 已提交
550 551 552 553 554 555 556 557
__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);

558 559
u32 __skb_get_poff(const struct sk_buff *skb, void *data,
		   const struct flow_keys *keys, int hlen)
560
{
561
	u32 poff = keys->control.thoff;
562

563
	switch (keys->basic.ip_proto) {
564
	case IPPROTO_TCP: {
565 566 567
		/* access doff as u8 to avoid unaligned access */
		const u8 *doff;
		u8 _doff;
568

569 570 571
		doff = __skb_header_pointer(skb, poff + 12, sizeof(_doff),
					    data, hlen, &_doff);
		if (!doff)
572 573
			return poff;

574
		poff += max_t(u32, sizeof(struct tcphdr), (*doff & 0xF0) >> 2);
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
		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;
}

604 605 606 607 608 609
/**
 * 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
610 611 612 613 614 615 616
 * 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;

617
	if (!skb_flow_dissect_flow_keys(skb, &keys))
618 619 620 621
		return 0;

	return __skb_get_poff(skb, skb->data, &keys, skb_headlen(skb));
}
622 623

static const struct flow_dissector_key flow_keys_dissector_keys[] = {
624 625 626 627
	{
		.key_id = FLOW_DISSECTOR_KEY_CONTROL,
		.offset = offsetof(struct flow_keys, control),
	},
628 629 630 631 632 633
	{
		.key_id = FLOW_DISSECTOR_KEY_BASIC,
		.offset = offsetof(struct flow_keys, basic),
	},
	{
		.key_id = FLOW_DISSECTOR_KEY_IPV4_ADDRS,
634 635 636 637 638
		.offset = offsetof(struct flow_keys, addrs.v4addrs),
	},
	{
		.key_id = FLOW_DISSECTOR_KEY_IPV6_ADDRS,
		.offset = offsetof(struct flow_keys, addrs.v6addrs),
639
	},
T
Tom Herbert 已提交
640 641 642 643
	{
		.key_id = FLOW_DISSECTOR_KEY_TIPC_ADDRS,
		.offset = offsetof(struct flow_keys, addrs.tipcaddrs),
	},
644 645 646 647 648 649 650
	{
		.key_id = FLOW_DISSECTOR_KEY_PORTS,
		.offset = offsetof(struct flow_keys, ports),
	},
};

static const struct flow_dissector_key flow_keys_buf_dissector_keys[] = {
651 652 653 654
	{
		.key_id = FLOW_DISSECTOR_KEY_CONTROL,
		.offset = offsetof(struct flow_keys, control),
	},
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
	{
		.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);