pkt_cls.h 16.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4
#ifndef __NET_PKT_CLS_H
#define __NET_PKT_CLS_H

#include <linux/pkt_cls.h>
5
#include <linux/workqueue.h>
L
Linus Torvalds 已提交
6 7 8 9 10
#include <net/sch_generic.h>
#include <net/act_api.h>

/* Basic packet classifier frontend definitions. */

E
Eric Dumazet 已提交
11
struct tcf_walker {
L
Linus Torvalds 已提交
12 13 14
	int	stop;
	int	skip;
	int	count;
15
	int	(*fn)(struct tcf_proto *, void *node, struct tcf_walker *);
L
Linus Torvalds 已提交
16 17
};

18 19
int register_tcf_proto_ops(struct tcf_proto_ops *ops);
int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
L
Linus Torvalds 已提交
20

21 22
enum tcf_block_binder_type {
	TCF_BLOCK_BINDER_TYPE_UNSPEC,
23 24
	TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS,
	TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS,
25 26 27 28
};

struct tcf_block_ext_info {
	enum tcf_block_binder_type binder_type;
29 30
	tcf_chain_head_change_t *chain_head_change;
	void *chain_head_change_priv;
31 32
};

33
struct tcf_block_cb;
34
bool tcf_queue_work(struct work_struct *work);
35

36
#ifdef CONFIG_NET_CLS
37 38
struct tcf_chain *tcf_chain_get(struct tcf_block *block, u32 chain_index,
				bool create);
39
void tcf_chain_put(struct tcf_chain *chain);
40
int tcf_block_get(struct tcf_block **p_block,
41
		  struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q);
42
int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q,
43
		      struct tcf_block_ext_info *ei);
44
void tcf_block_put(struct tcf_block *block);
45
void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q,
46
		       struct tcf_block_ext_info *ei);
47 48 49 50 51 52 53 54 55 56 57

static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
{
	return block->q;
}

static inline struct net_device *tcf_block_dev(struct tcf_block *block)
{
	return tcf_block_q(block)->dev_queue->dev;
}

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
void *tcf_block_cb_priv(struct tcf_block_cb *block_cb);
struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block,
					 tc_setup_cb_t *cb, void *cb_ident);
void tcf_block_cb_incref(struct tcf_block_cb *block_cb);
unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb);
struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block,
					     tc_setup_cb_t *cb, void *cb_ident,
					     void *cb_priv);
int tcf_block_cb_register(struct tcf_block *block,
			  tc_setup_cb_t *cb, void *cb_ident,
			  void *cb_priv);
void __tcf_block_cb_unregister(struct tcf_block_cb *block_cb);
void tcf_block_cb_unregister(struct tcf_block *block,
			     tc_setup_cb_t *cb, void *cb_ident);

73 74 75
int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
		 struct tcf_result *res, bool compat_mode);

76
#else
77 78
static inline
int tcf_block_get(struct tcf_block **p_block,
79
		  struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q)
80 81 82 83
{
	return 0;
}

84
static inline
85
int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q,
86 87 88 89 90
		      struct tcf_block_ext_info *ei)
{
	return 0;
}

91
static inline void tcf_block_put(struct tcf_block *block)
92 93
{
}
94

95
static inline
96
void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q,
97 98 99 100
		       struct tcf_block_ext_info *ei)
{
}

101 102 103 104 105 106 107 108 109 110
static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
{
	return NULL;
}

static inline struct net_device *tcf_block_dev(struct tcf_block *block)
{
	return NULL;
}

111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
static inline
int tc_setup_cb_block_register(struct tcf_block *block, tc_setup_cb_t *cb,
			       void *cb_priv)
{
	return 0;
}

static inline
void tc_setup_cb_block_unregister(struct tcf_block *block, tc_setup_cb_t *cb,
				  void *cb_priv)
{
}

static inline
void *tcf_block_cb_priv(struct tcf_block_cb *block_cb)
{
	return NULL;
}

static inline
struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block,
					 tc_setup_cb_t *cb, void *cb_ident)
{
	return NULL;
}

static inline
void tcf_block_cb_incref(struct tcf_block_cb *block_cb)
{
}

static inline
unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb)
{
	return 0;
}

static inline
struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block,
					     tc_setup_cb_t *cb, void *cb_ident,
					     void *cb_priv)
{
	return NULL;
}

static inline
int tcf_block_cb_register(struct tcf_block *block,
			  tc_setup_cb_t *cb, void *cb_ident,
			  void *cb_priv)
{
	return 0;
}

static inline
void __tcf_block_cb_unregister(struct tcf_block_cb *block_cb)
{
}

static inline
void tcf_block_cb_unregister(struct tcf_block *block,
			     tc_setup_cb_t *cb, void *cb_ident)
{
}

175 176 177 178 179
static inline int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
			       struct tcf_result *res, bool compat_mode)
{
	return TC_ACT_UNSPEC;
}
180
#endif
181

L
Linus Torvalds 已提交
182 183 184
static inline unsigned long
__cls_set_class(unsigned long *clp, unsigned long cl)
{
185
	return xchg(clp, cl);
L
Linus Torvalds 已提交
186 187 188
}

static inline unsigned long
189
cls_set_class(struct Qdisc *q, unsigned long *clp, unsigned long cl)
L
Linus Torvalds 已提交
190 191
{
	unsigned long old_cl;
192 193

	sch_tree_lock(q);
L
Linus Torvalds 已提交
194
	old_cl = __cls_set_class(clp, cl);
195
	sch_tree_unlock(q);
L
Linus Torvalds 已提交
196 197 198 199 200 201
	return old_cl;
}

static inline void
tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base)
{
202
	struct Qdisc *q = tp->chain->block->q;
L
Linus Torvalds 已提交
203 204
	unsigned long cl;

205 206 207 208 209 210 211
	/* Check q as it is not set for shared blocks. In that case,
	 * setting class is not supported.
	 */
	if (!q)
		return;
	cl = q->ops->cl_ops->bind_tcf(q, base, r->classid);
	cl = cls_set_class(q, &r->class, cl);
L
Linus Torvalds 已提交
212
	if (cl)
213
		q->ops->cl_ops->unbind_tcf(q, cl);
L
Linus Torvalds 已提交
214 215 216 217 218
}

static inline void
tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r)
{
219
	struct Qdisc *q = tp->chain->block->q;
L
Linus Torvalds 已提交
220 221
	unsigned long cl;

222 223
	if (!q)
		return;
L
Linus Torvalds 已提交
224
	if ((cl = __cls_set_class(&r->class, 0)) != 0)
225
		q->ops->cl_ops->unbind_tcf(q, cl);
L
Linus Torvalds 已提交
226 227
}

E
Eric Dumazet 已提交
228
struct tcf_exts {
L
Linus Torvalds 已提交
229
#ifdef CONFIG_NET_CLS_ACT
230
	__u32	type; /* for backward compat(TCA_OLD_COMPAT) */
231 232
	int nr_actions;
	struct tc_action **actions;
L
Linus Torvalds 已提交
233
#endif
234 235 236
	/* Map to export classifier specific extension TLV types to the
	 * generic extensions API. Unsupported extensions must be set to 0.
	 */
L
Linus Torvalds 已提交
237 238 239 240
	int action;
	int police;
};

241
static inline int tcf_exts_init(struct tcf_exts *exts, int action, int police)
242 243
{
#ifdef CONFIG_NET_CLS_ACT
244
	exts->type = 0;
245 246 247
	exts->nr_actions = 0;
	exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *),
				GFP_KERNEL);
248 249
	if (!exts->actions)
		return -ENOMEM;
250
#endif
251 252
	exts->action = action;
	exts->police = police;
253
	return 0;
254 255
}

256 257 258 259 260 261 262 263 264
static inline void tcf_exts_to_list(const struct tcf_exts *exts,
				    struct list_head *actions)
{
#ifdef CONFIG_NET_CLS_ACT
	int i;

	for (i = 0; i < exts->nr_actions; i++) {
		struct tc_action *a = exts->actions[i];

265
		list_add_tail(&a->list, actions);
266 267 268 269
	}
#endif
}

270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
static inline void
tcf_exts_stats_update(const struct tcf_exts *exts,
		      u64 bytes, u64 packets, u64 lastuse)
{
#ifdef CONFIG_NET_CLS_ACT
	int i;

	preempt_disable();

	for (i = 0; i < exts->nr_actions; i++) {
		struct tc_action *a = exts->actions[i];

		tcf_action_stats_update(a, bytes, packets, lastuse);
	}

	preempt_enable();
#endif
}

289 290 291 292 293 294 295 296
/**
 * tcf_exts_has_actions - check if at least one action is present
 * @exts: tc filter extensions handle
 *
 * Returns true if at least one action is present.
 */
static inline bool tcf_exts_has_actions(struct tcf_exts *exts)
{
297
#ifdef CONFIG_NET_CLS_ACT
298 299 300 301 302
	return exts->nr_actions;
#else
	return false;
#endif
}
303

304 305 306 307 308 309 310 311 312 313 314 315 316 317
/**
 * tcf_exts_has_one_action - check if exactly one action is present
 * @exts: tc filter extensions handle
 *
 * Returns true if exactly one action is present.
 */
static inline bool tcf_exts_has_one_action(struct tcf_exts *exts)
{
#ifdef CONFIG_NET_CLS_ACT
	return exts->nr_actions == 1;
#else
	return false;
#endif
}
318

319 320 321 322 323 324
/**
 * tcf_exts_exec - execute tc filter extensions
 * @skb: socket buffer
 * @exts: tc filter extensions handle
 * @res: desired result
 *
325
 * Executes all configured extensions. Returns TC_ACT_OK on a normal execution,
326 327 328 329 330 331 332 333 334
 * a negative number if the filter must be considered unmatched or
 * a positive action code (TC_ACT_*) which must be returned to the
 * underlying layer.
 */
static inline int
tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts,
	      struct tcf_result *res)
{
#ifdef CONFIG_NET_CLS_ACT
335
	return tcf_action_exec(skb, exts->actions, exts->nr_actions, res);
336
#endif
337
	return TC_ACT_OK;
338 339
}

340 341
int tcf_exts_validate(struct net *net, struct tcf_proto *tp,
		      struct nlattr **tb, struct nlattr *rate_tlv,
342
		      struct tcf_exts *exts, bool ovr);
343
void tcf_exts_destroy(struct tcf_exts *exts);
344
void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src);
345 346
int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts);
int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts);
L
Linus Torvalds 已提交
347 348 349 350

/**
 * struct tcf_pkt_info - packet information
 */
E
Eric Dumazet 已提交
351
struct tcf_pkt_info {
L
Linus Torvalds 已提交
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
	unsigned char *		ptr;
	int			nexthdr;
};

#ifdef CONFIG_NET_EMATCH

struct tcf_ematch_ops;

/**
 * struct tcf_ematch - extended match (ematch)
 * 
 * @matchid: identifier to allow userspace to reidentify a match
 * @flags: flags specifying attributes and the relation to other matches
 * @ops: the operations lookup table of the corresponding ematch module
 * @datalen: length of the ematch specific configuration data
 * @data: ematch specific data
 */
E
Eric Dumazet 已提交
369
struct tcf_ematch {
L
Linus Torvalds 已提交
370 371 372 373 374
	struct tcf_ematch_ops * ops;
	unsigned long		data;
	unsigned int		datalen;
	u16			matchid;
	u16			flags;
375
	struct net		*net;
L
Linus Torvalds 已提交
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
};

static inline int tcf_em_is_container(struct tcf_ematch *em)
{
	return !em->ops;
}

static inline int tcf_em_is_simple(struct tcf_ematch *em)
{
	return em->flags & TCF_EM_SIMPLE;
}

static inline int tcf_em_is_inverted(struct tcf_ematch *em)
{
	return em->flags & TCF_EM_INVERT;
}

static inline int tcf_em_last_match(struct tcf_ematch *em)
{
	return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END;
}

static inline int tcf_em_early_end(struct tcf_ematch *em, int result)
{
	if (tcf_em_last_match(em))
		return 1;

	if (result == 0 && em->flags & TCF_EM_REL_AND)
		return 1;

	if (result != 0 && em->flags & TCF_EM_REL_OR)
		return 1;

	return 0;
}
	
/**
 * struct tcf_ematch_tree - ematch tree handle
 *
 * @hdr: ematch tree header supplied by userspace
 * @matches: array of ematches
 */
E
Eric Dumazet 已提交
418
struct tcf_ematch_tree {
L
Linus Torvalds 已提交
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
	struct tcf_ematch_tree_hdr hdr;
	struct tcf_ematch *	matches;
	
};

/**
 * struct tcf_ematch_ops - ematch module operations
 * 
 * @kind: identifier (kind) of this ematch module
 * @datalen: length of expected configuration data (optional)
 * @change: called during validation (optional)
 * @match: called during ematch tree evaluation, must return 1/0
 * @destroy: called during destroyage (optional)
 * @dump: called during dumping process (optional)
 * @owner: owner, must be set to THIS_MODULE
 * @link: link to previous/next ematch module (internal use)
 */
E
Eric Dumazet 已提交
436
struct tcf_ematch_ops {
L
Linus Torvalds 已提交
437 438
	int			kind;
	int			datalen;
439
	int			(*change)(struct net *net, void *,
L
Linus Torvalds 已提交
440 441 442
					  int, struct tcf_ematch *);
	int			(*match)(struct sk_buff *, struct tcf_ematch *,
					 struct tcf_pkt_info *);
443
	void			(*destroy)(struct tcf_ematch *);
L
Linus Torvalds 已提交
444 445 446 447 448
	int			(*dump)(struct sk_buff *, struct tcf_ematch *);
	struct module		*owner;
	struct list_head	link;
};

449 450 451 452
int tcf_em_register(struct tcf_ematch_ops *);
void tcf_em_unregister(struct tcf_ematch_ops *);
int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *,
			 struct tcf_ematch_tree *);
453
void tcf_em_tree_destroy(struct tcf_ematch_tree *);
454 455 456
int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int);
int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *,
			struct tcf_pkt_info *);
L
Linus Torvalds 已提交
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481

/**
 * tcf_em_tree_match - evaulate an ematch tree
 *
 * @skb: socket buffer of the packet in question
 * @tree: ematch tree to be used for evaluation
 * @info: packet information examined by classifier
 *
 * This function matches @skb against the ematch tree in @tree by going
 * through all ematches respecting their logic relations returning
 * as soon as the result is obvious.
 *
 * Returns 1 if the ematch tree as-one matches, no ematches are configured
 * or ematch is not enabled in the kernel, otherwise 0 is returned.
 */
static inline int tcf_em_tree_match(struct sk_buff *skb,
				    struct tcf_ematch_tree *tree,
				    struct tcf_pkt_info *info)
{
	if (tree->hdr.nmatches)
		return __tcf_em_tree_match(skb, tree, info);
	else
		return 1;
}

482 483
#define MODULE_ALIAS_TCF_EMATCH(kind)	MODULE_ALIAS("ematch-kind-" __stringify(kind))

L
Linus Torvalds 已提交
484 485
#else /* CONFIG_NET_EMATCH */

E
Eric Dumazet 已提交
486
struct tcf_ematch_tree {
L
Linus Torvalds 已提交
487 488 489
};

#define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0)
490
#define tcf_em_tree_destroy(t) do { (void)(t); } while(0)
L
Linus Torvalds 已提交
491 492 493 494 495 496 497 498 499 500 501
#define tcf_em_tree_dump(skb, t, tlv) (0)
#define tcf_em_tree_match(skb, t, info) ((void)(info), 1)

#endif /* CONFIG_NET_EMATCH */

static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer)
{
	switch (layer) {
		case TCF_LAYER_LINK:
			return skb->data;
		case TCF_LAYER_NETWORK:
502
			return skb_network_header(skb);
L
Linus Torvalds 已提交
503
		case TCF_LAYER_TRANSPORT:
504
			return skb_transport_header(skb);
L
Linus Torvalds 已提交
505 506 507 508 509
	}

	return NULL;
}

510 511
static inline int tcf_valid_offset(const struct sk_buff *skb,
				   const unsigned char *ptr, const int len)
L
Linus Torvalds 已提交
512
{
513 514 515
	return likely((ptr + len) <= skb_tail_pointer(skb) &&
		      ptr >= skb->head &&
		      (ptr <= (ptr + len)));
L
Linus Torvalds 已提交
516 517 518
}

#ifdef CONFIG_NET_CLS_IND
519 520
#include <net/net_namespace.h>

L
Linus Torvalds 已提交
521
static inline int
522
tcf_change_indev(struct net *net, struct nlattr *indev_tlv)
L
Linus Torvalds 已提交
523
{
524 525 526
	char indev[IFNAMSIZ];
	struct net_device *dev;

527
	if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ)
L
Linus Torvalds 已提交
528
		return -EINVAL;
529 530 531 532
	dev = __dev_get_by_name(net, indev);
	if (!dev)
		return -ENODEV;
	return dev->ifindex;
L
Linus Torvalds 已提交
533 534
}

535 536
static inline bool
tcf_match_indev(struct sk_buff *skb, int ifindex)
L
Linus Torvalds 已提交
537
{
538 539 540 541 542
	if (!ifindex)
		return true;
	if  (!skb->skb_iif)
		return false;
	return ifindex == skb->skb_iif;
L
Linus Torvalds 已提交
543 544 545
}
#endif /* CONFIG_NET_CLS_IND */

546 547
int tc_setup_cb_call(struct tcf_block *block, struct tcf_exts *exts,
		     enum tc_setup_type type, void *type_data, bool err_stop);
548

549 550 551 552 553 554 555 556 557 558 559
enum tc_block_command {
	TC_BLOCK_BIND,
	TC_BLOCK_UNBIND,
};

struct tc_block_offload {
	enum tc_block_command command;
	enum tcf_block_binder_type binder_type;
	struct tcf_block *block;
};

560 561 562
struct tc_cls_common_offload {
	u32 chain_index;
	__be16 protocol;
563
	u32 prio;
564 565 566 567 568 569 570 571
};

static inline void
tc_cls_common_offload_init(struct tc_cls_common_offload *cls_common,
			   const struct tcf_proto *tp)
{
	cls_common->chain_index = tp->chain->index;
	cls_common->protocol = tp->protocol;
572
	cls_common->prio = tp->prio;
573 574
}

575 576
struct tc_cls_u32_knode {
	struct tcf_exts *exts;
577
	struct tc_u32_sel *sel;
578 579 580 581
	u32 handle;
	u32 val;
	u32 mask;
	u32 link_handle;
582
	u8 fshift;
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
};

struct tc_cls_u32_hnode {
	u32 handle;
	u32 prio;
	unsigned int divisor;
};

enum tc_clsu32_command {
	TC_CLSU32_NEW_KNODE,
	TC_CLSU32_REPLACE_KNODE,
	TC_CLSU32_DELETE_KNODE,
	TC_CLSU32_NEW_HNODE,
	TC_CLSU32_REPLACE_HNODE,
	TC_CLSU32_DELETE_HNODE,
};

struct tc_cls_u32_offload {
601
	struct tc_cls_common_offload common;
602 603 604 605 606 607 608 609
	/* knode values */
	enum tc_clsu32_command command;
	union {
		struct tc_cls_u32_knode knode;
		struct tc_cls_u32_hnode hnode;
	};
};

610
static inline bool tc_can_offload(const struct net_device *dev)
611
{
612
	return dev->features & NETIF_F_HW_TC;
613 614
}

615 616 617 618 619
static inline bool tc_skip_hw(u32 flags)
{
	return (flags & TCA_CLS_FLAGS_SKIP_HW) ? true : false;
}

620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
static inline bool tc_skip_sw(u32 flags)
{
	return (flags & TCA_CLS_FLAGS_SKIP_SW) ? true : false;
}

/* SKIP_HW and SKIP_SW are mutually exclusive flags. */
static inline bool tc_flags_valid(u32 flags)
{
	if (flags & ~(TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW))
		return false;

	if (!(flags ^ (TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW)))
		return false;

	return true;
}

637 638 639 640 641
static inline bool tc_in_hw(u32 flags)
{
	return (flags & TCA_CLS_FLAGS_IN_HW) ? true : false;
}

642 643 644
enum tc_fl_command {
	TC_CLSFLOWER_REPLACE,
	TC_CLSFLOWER_DESTROY,
645
	TC_CLSFLOWER_STATS,
646 647 648
};

struct tc_cls_flower_offload {
649
	struct tc_cls_common_offload common;
650
	enum tc_fl_command command;
A
Amir Vadai 已提交
651
	unsigned long cookie;
652 653 654 655
	struct flow_dissector *dissector;
	struct fl_flow_key *mask;
	struct fl_flow_key *key;
	struct tcf_exts *exts;
656
	u32 classid;
657 658
};

659 660 661 662 663 664
enum tc_matchall_command {
	TC_CLSMATCHALL_REPLACE,
	TC_CLSMATCHALL_DESTROY,
};

struct tc_cls_matchall_offload {
665
	struct tc_cls_common_offload common;
666 667 668 669 670
	enum tc_matchall_command command;
	struct tcf_exts *exts;
	unsigned long cookie;
};

671 672 673 674
enum tc_clsbpf_command {
	TC_CLSBPF_ADD,
	TC_CLSBPF_REPLACE,
	TC_CLSBPF_DESTROY,
675
	TC_CLSBPF_STATS,
676 677 678
};

struct tc_cls_bpf_offload {
679
	struct tc_cls_common_offload common;
680 681 682 683 684
	enum tc_clsbpf_command command;
	struct tcf_exts *exts;
	struct bpf_prog *prog;
	const char *name;
	bool exts_integrated;
685
	u32 gen_flags;
686 687
};

688 689 690 691 692 693 694 695 696
struct tc_mqprio_qopt_offload {
	/* struct tc_mqprio_qopt must always be the first element */
	struct tc_mqprio_qopt qopt;
	u16 mode;
	u16 shaper;
	u32 flags;
	u64 min_rate[TC_QOPT_MAX_QUEUE];
	u64 max_rate[TC_QOPT_MAX_QUEUE];
};
697 698 699 700 701 702 703 704

/* This structure holds cookie structure that is passed from user
 * to the kernel for actions and classifiers
 */
struct tc_cookie {
	u8  *data;
	u32 len;
};
L
Linus Torvalds 已提交
705
#endif