pkt_cls.h 17.2 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0 */
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5
#ifndef __NET_PKT_CLS_H
#define __NET_PKT_CLS_H

#include <linux/pkt_cls.h>
6
#include <linux/workqueue.h>
Linus Torvalds's avatar
Linus Torvalds committed
7 8 9 10 11
#include <net/sch_generic.h>
#include <net/act_api.h>

/* Basic packet classifier frontend definitions. */

Eric Dumazet's avatar
Eric Dumazet committed
12
struct tcf_walker {
Linus Torvalds's avatar
Linus Torvalds committed
13 14 15
	int	stop;
	int	skip;
	int	count;
16
	int	(*fn)(struct tcf_proto *, void *node, struct tcf_walker *);
Linus Torvalds's avatar
Linus Torvalds committed
17 18
};

19 20
int register_tcf_proto_ops(struct tcf_proto_ops *ops);
int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
Linus Torvalds's avatar
Linus Torvalds committed
21

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

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

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

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

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

59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
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);

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

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

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

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

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

102 103 104 105 106 107 108 109 110 111
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;
}

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 175
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)
{
}

176 177 178 179 180
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;
}
181
#endif
182

Linus Torvalds's avatar
Linus Torvalds committed
183 184 185
static inline unsigned long
__cls_set_class(unsigned long *clp, unsigned long cl)
{
186
	return xchg(clp, cl);
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189
}

static inline unsigned long
190
cls_set_class(struct Qdisc *q, unsigned long *clp, unsigned long cl)
Linus Torvalds's avatar
Linus Torvalds committed
191 192
{
	unsigned long old_cl;
193 194

	sch_tree_lock(q);
Linus Torvalds's avatar
Linus Torvalds committed
195
	old_cl = __cls_set_class(clp, cl);
196
	sch_tree_unlock(q);
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202
	return old_cl;
}

static inline void
tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base)
{
203
	struct Qdisc *q = tp->chain->block->q;
Linus Torvalds's avatar
Linus Torvalds committed
204 205
	unsigned long cl;

206 207 208 209 210 211 212
	/* 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);
Linus Torvalds's avatar
Linus Torvalds committed
213
	if (cl)
214
		q->ops->cl_ops->unbind_tcf(q, cl);
Linus Torvalds's avatar
Linus Torvalds committed
215 216 217 218 219
}

static inline void
tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r)
{
220
	struct Qdisc *q = tp->chain->block->q;
Linus Torvalds's avatar
Linus Torvalds committed
221 222
	unsigned long cl;

223 224
	if (!q)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
225
	if ((cl = __cls_set_class(&r->class, 0)) != 0)
226
		q->ops->cl_ops->unbind_tcf(q, cl);
Linus Torvalds's avatar
Linus Torvalds committed
227 228
}

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

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

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
/* Return false if the netns is being destroyed in cleanup_net(). Callers
 * need to do cleanup synchronously in this case, otherwise may race with
 * tc_action_net_exit(). Return true for other cases.
 */
static inline bool tcf_exts_get_net(struct tcf_exts *exts)
{
#ifdef CONFIG_NET_CLS_ACT
	exts->net = maybe_get_net(exts->net);
	return exts->net != NULL;
#else
	return true;
#endif
}

static inline void tcf_exts_put_net(struct tcf_exts *exts)
{
#ifdef CONFIG_NET_CLS_ACT
	if (exts->net)
		put_net(exts->net);
#endif
}

281 282 283 284 285 286 287 288 289
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];

290
		list_add_tail(&a->list, actions);
291 292 293 294
	}
#endif
}

295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
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
}

314 315 316 317 318 319 320 321
/**
 * 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)
{
322
#ifdef CONFIG_NET_CLS_ACT
323 324 325 326 327
	return exts->nr_actions;
#else
	return false;
#endif
}
328

329 330 331 332 333 334 335 336 337 338 339 340 341 342
/**
 * 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
}
343

344 345 346 347 348 349
/**
 * tcf_exts_exec - execute tc filter extensions
 * @skb: socket buffer
 * @exts: tc filter extensions handle
 * @res: desired result
 *
350
 * Executes all configured extensions. Returns TC_ACT_OK on a normal execution,
351 352 353 354 355 356 357 358 359
 * 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
360
	return tcf_action_exec(skb, exts->actions, exts->nr_actions, res);
361
#endif
362
	return TC_ACT_OK;
363 364
}

365 366
int tcf_exts_validate(struct net *net, struct tcf_proto *tp,
		      struct nlattr **tb, struct nlattr *rate_tlv,
367
		      struct tcf_exts *exts, bool ovr);
368
void tcf_exts_destroy(struct tcf_exts *exts);
369
void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src);
370 371
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);
Linus Torvalds's avatar
Linus Torvalds committed
372 373 374 375

/**
 * struct tcf_pkt_info - packet information
 */
Eric Dumazet's avatar
Eric Dumazet committed
376
struct tcf_pkt_info {
Linus Torvalds's avatar
Linus Torvalds committed
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
	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
 */
Eric Dumazet's avatar
Eric Dumazet committed
394
struct tcf_ematch {
Linus Torvalds's avatar
Linus Torvalds committed
395 396 397 398 399
	struct tcf_ematch_ops * ops;
	unsigned long		data;
	unsigned int		datalen;
	u16			matchid;
	u16			flags;
400
	struct net		*net;
Linus Torvalds's avatar
Linus Torvalds committed
401 402 403 404 405 406 407 408 409 410 411 412 413 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
};

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
 */
Eric Dumazet's avatar
Eric Dumazet committed
443
struct tcf_ematch_tree {
Linus Torvalds's avatar
Linus Torvalds committed
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
	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)
 */
Eric Dumazet's avatar
Eric Dumazet committed
461
struct tcf_ematch_ops {
Linus Torvalds's avatar
Linus Torvalds committed
462 463
	int			kind;
	int			datalen;
464
	int			(*change)(struct net *net, void *,
Linus Torvalds's avatar
Linus Torvalds committed
465 466 467
					  int, struct tcf_ematch *);
	int			(*match)(struct sk_buff *, struct tcf_ematch *,
					 struct tcf_pkt_info *);
468
	void			(*destroy)(struct tcf_ematch *);
Linus Torvalds's avatar
Linus Torvalds committed
469 470 471 472 473
	int			(*dump)(struct sk_buff *, struct tcf_ematch *);
	struct module		*owner;
	struct list_head	link;
};

474 475 476 477
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 *);
478
void tcf_em_tree_destroy(struct tcf_ematch_tree *);
479 480 481
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 *);
Linus Torvalds's avatar
Linus Torvalds committed
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506

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

507 508
#define MODULE_ALIAS_TCF_EMATCH(kind)	MODULE_ALIAS("ematch-kind-" __stringify(kind))

Linus Torvalds's avatar
Linus Torvalds committed
509 510
#else /* CONFIG_NET_EMATCH */

Eric Dumazet's avatar
Eric Dumazet committed
511
struct tcf_ematch_tree {
Linus Torvalds's avatar
Linus Torvalds committed
512 513 514
};

#define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0)
515
#define tcf_em_tree_destroy(t) do { (void)(t); } while(0)
Linus Torvalds's avatar
Linus Torvalds committed
516 517 518 519 520 521 522 523 524
#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:
525
			return skb_mac_header(skb);
Linus Torvalds's avatar
Linus Torvalds committed
526
		case TCF_LAYER_NETWORK:
527
			return skb_network_header(skb);
Linus Torvalds's avatar
Linus Torvalds committed
528
		case TCF_LAYER_TRANSPORT:
529
			return skb_transport_header(skb);
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532 533 534
	}

	return NULL;
}

535 536
static inline int tcf_valid_offset(const struct sk_buff *skb,
				   const unsigned char *ptr, const int len)
Linus Torvalds's avatar
Linus Torvalds committed
537
{
538 539 540
	return likely((ptr + len) <= skb_tail_pointer(skb) &&
		      ptr >= skb->head &&
		      (ptr <= (ptr + len)));
Linus Torvalds's avatar
Linus Torvalds committed
541 542 543
}

#ifdef CONFIG_NET_CLS_IND
544 545
#include <net/net_namespace.h>

Linus Torvalds's avatar
Linus Torvalds committed
546
static inline int
547
tcf_change_indev(struct net *net, struct nlattr *indev_tlv)
Linus Torvalds's avatar
Linus Torvalds committed
548
{
549 550 551
	char indev[IFNAMSIZ];
	struct net_device *dev;

552
	if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ)
Linus Torvalds's avatar
Linus Torvalds committed
553
		return -EINVAL;
554 555 556 557
	dev = __dev_get_by_name(net, indev);
	if (!dev)
		return -ENODEV;
	return dev->ifindex;
Linus Torvalds's avatar
Linus Torvalds committed
558 559
}

560 561
static inline bool
tcf_match_indev(struct sk_buff *skb, int ifindex)
Linus Torvalds's avatar
Linus Torvalds committed
562
{
563 564 565 566 567
	if (!ifindex)
		return true;
	if  (!skb->skb_iif)
		return false;
	return ifindex == skb->skb_iif;
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570
}
#endif /* CONFIG_NET_CLS_IND */

571 572
int tc_setup_cb_call(struct tcf_block *block, struct tcf_exts *exts,
		     enum tc_setup_type type, void *type_data, bool err_stop);
573

574 575 576 577 578 579 580 581 582 583 584
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;
};

585 586 587
struct tc_cls_common_offload {
	u32 chain_index;
	__be16 protocol;
588
	u32 prio;
589 590 591 592 593 594 595 596
};

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;
597
	cls_common->prio = tp->prio;
598 599
}

600 601
struct tc_cls_u32_knode {
	struct tcf_exts *exts;
602
	struct tc_u32_sel *sel;
603 604 605 606
	u32 handle;
	u32 val;
	u32 mask;
	u32 link_handle;
607
	u8 fshift;
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
};

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 {
626
	struct tc_cls_common_offload common;
627 628 629 630 631 632 633 634
	/* knode values */
	enum tc_clsu32_command command;
	union {
		struct tc_cls_u32_knode knode;
		struct tc_cls_u32_hnode hnode;
	};
};

635
static inline bool tc_can_offload(const struct net_device *dev)
636
{
637
	return dev->features & NETIF_F_HW_TC;
638 639
}

640 641 642 643 644
static inline bool tc_skip_hw(u32 flags)
{
	return (flags & TCA_CLS_FLAGS_SKIP_HW) ? true : false;
}

645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
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;
}

662 663 664 665 666
static inline bool tc_in_hw(u32 flags)
{
	return (flags & TCA_CLS_FLAGS_IN_HW) ? true : false;
}

667 668 669
enum tc_fl_command {
	TC_CLSFLOWER_REPLACE,
	TC_CLSFLOWER_DESTROY,
670
	TC_CLSFLOWER_STATS,
671 672 673
};

struct tc_cls_flower_offload {
674
	struct tc_cls_common_offload common;
675
	enum tc_fl_command command;
Amir Vadai's avatar
Amir Vadai committed
676
	unsigned long cookie;
677 678 679 680
	struct flow_dissector *dissector;
	struct fl_flow_key *mask;
	struct fl_flow_key *key;
	struct tcf_exts *exts;
681
	u32 classid;
682 683
};

684 685 686 687 688 689
enum tc_matchall_command {
	TC_CLSMATCHALL_REPLACE,
	TC_CLSMATCHALL_DESTROY,
};

struct tc_cls_matchall_offload {
690
	struct tc_cls_common_offload common;
691 692 693 694 695
	enum tc_matchall_command command;
	struct tcf_exts *exts;
	unsigned long cookie;
};

696
enum tc_clsbpf_command {
697
	TC_CLSBPF_OFFLOAD,
698
	TC_CLSBPF_STATS,
699 700 701
};

struct tc_cls_bpf_offload {
702
	struct tc_cls_common_offload common;
703 704 705
	enum tc_clsbpf_command command;
	struct tcf_exts *exts;
	struct bpf_prog *prog;
706
	struct bpf_prog *oldprog;
707 708
	const char *name;
	bool exts_integrated;
709
	u32 gen_flags;
710 711
};

712 713 714 715 716 717 718 719 720
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];
};
721 722 723 724 725 726 727 728

/* This structure holds cookie structure that is passed from user
 * to the kernel for actions and classifiers
 */
struct tc_cookie {
	u8  *data;
	u32 len;
};
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758

enum tc_red_command {
	TC_RED_REPLACE,
	TC_RED_DESTROY,
	TC_RED_STATS,
	TC_RED_XSTATS,
};

struct tc_red_qopt_offload_params {
	u32 min;
	u32 max;
	u32 probability;
	bool is_ecn;
};
struct tc_red_qopt_offload_stats {
	struct gnet_stats_basic_packed *bstats;
	struct gnet_stats_queue *qstats;
};

struct tc_red_qopt_offload {
	enum tc_red_command command;
	u32 handle;
	u32 parent;
	union {
		struct tc_red_qopt_offload_params set;
		struct tc_red_qopt_offload_stats stats;
		struct red_stats *xstats;
	};
};

Linus Torvalds's avatar
Linus Torvalds committed
759
#endif