pkt_cls.h 13.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
#ifndef __NET_PKT_CLS_H
#define __NET_PKT_CLS_H

#include <linux/pkt_cls.h>
#include <net/sch_generic.h>
#include <net/act_api.h>

/* Basic packet classifier frontend definitions. */

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

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

20
#ifdef CONFIG_NET_CLS
21 22
struct tcf_chain *tcf_chain_get(struct tcf_block *block, u32 chain_index,
				bool create);
23
void tcf_chain_put(struct tcf_chain *chain);
24 25 26
int tcf_block_get(struct tcf_block **p_block,
		  struct tcf_proto __rcu **p_filter_chain);
void tcf_block_put(struct tcf_block *block);
27 28 29
int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
		 struct tcf_result *res, bool compat_mode);

30
#else
31 32 33 34 35 36 37 38
static inline
int tcf_block_get(struct tcf_block **p_block,
		  struct tcf_proto __rcu **p_filter_chain)
{
	return 0;
}

static inline void tcf_block_put(struct tcf_block *block)
39 40
{
}
41 42 43 44 45 46

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;
}
47
#endif
48

L
Linus Torvalds 已提交
49 50 51
static inline unsigned long
__cls_set_class(unsigned long *clp, unsigned long cl)
{
52
	return xchg(clp, cl);
L
Linus Torvalds 已提交
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
}

static inline unsigned long
cls_set_class(struct tcf_proto *tp, unsigned long *clp, 
	unsigned long cl)
{
	unsigned long old_cl;
	
	tcf_tree_lock(tp);
	old_cl = __cls_set_class(clp, cl);
	tcf_tree_unlock(tp);
 
	return old_cl;
}

static inline void
tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base)
{
	unsigned long cl;

	cl = tp->q->ops->cl_ops->bind_tcf(tp->q, base, r->classid);
	cl = cls_set_class(tp, &r->class, cl);
	if (cl)
		tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);
}

static inline void
tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r)
{
	unsigned long cl;

	if ((cl = __cls_set_class(&r->class, 0)) != 0)
		tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);
}

E
Eric Dumazet 已提交
88
struct tcf_exts {
L
Linus Torvalds 已提交
89
#ifdef CONFIG_NET_CLS_ACT
90
	__u32	type; /* for backward compat(TCA_OLD_COMPAT) */
91 92
	int nr_actions;
	struct tc_action **actions;
L
Linus Torvalds 已提交
93
#endif
94 95 96
	/* Map to export classifier specific extension TLV types to the
	 * generic extensions API. Unsupported extensions must be set to 0.
	 */
L
Linus Torvalds 已提交
97 98 99 100
	int action;
	int police;
};

101
static inline int tcf_exts_init(struct tcf_exts *exts, int action, int police)
102 103
{
#ifdef CONFIG_NET_CLS_ACT
104
	exts->type = 0;
105 106 107
	exts->nr_actions = 0;
	exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *),
				GFP_KERNEL);
108 109
	if (!exts->actions)
		return -ENOMEM;
110
#endif
111 112
	exts->action = action;
	exts->police = police;
113
	return 0;
114 115
}

116 117 118 119 120 121 122 123 124
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];

125
		list_add_tail(&a->list, actions);
126 127 128 129
	}
#endif
}

130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
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
}

149 150 151 152 153 154 155 156
/**
 * 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)
{
157
#ifdef CONFIG_NET_CLS_ACT
158 159 160 161 162
	return exts->nr_actions;
#else
	return false;
#endif
}
163

164 165 166 167 168 169 170 171 172 173 174 175 176 177
/**
 * 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
}
178

179 180 181 182 183 184
/**
 * tcf_exts_exec - execute tc filter extensions
 * @skb: socket buffer
 * @exts: tc filter extensions handle
 * @res: desired result
 *
185
 * Executes all configured extensions. Returns TC_ACT_OK on a normal execution,
186 187 188 189 190 191 192 193 194
 * 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
195
	return tcf_action_exec(skb, exts->actions, exts->nr_actions, res);
196
#endif
197
	return TC_ACT_OK;
198 199
}

200 201
int tcf_exts_validate(struct net *net, struct tcf_proto *tp,
		      struct nlattr **tb, struct nlattr *rate_tlv,
202
		      struct tcf_exts *exts, bool ovr);
203
void tcf_exts_destroy(struct tcf_exts *exts);
204
void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src);
205 206
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);
207 208
int tcf_exts_get_dev(struct net_device *dev, struct tcf_exts *exts,
		     struct net_device **hw_dev);
L
Linus Torvalds 已提交
209 210 211 212

/**
 * struct tcf_pkt_info - packet information
 */
E
Eric Dumazet 已提交
213
struct tcf_pkt_info {
L
Linus Torvalds 已提交
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
	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 已提交
231
struct tcf_ematch {
L
Linus Torvalds 已提交
232 233 234 235 236
	struct tcf_ematch_ops * ops;
	unsigned long		data;
	unsigned int		datalen;
	u16			matchid;
	u16			flags;
237
	struct net		*net;
L
Linus Torvalds 已提交
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
};

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 已提交
280
struct tcf_ematch_tree {
L
Linus Torvalds 已提交
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
	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 已提交
298
struct tcf_ematch_ops {
L
Linus Torvalds 已提交
299 300
	int			kind;
	int			datalen;
301
	int			(*change)(struct net *net, void *,
L
Linus Torvalds 已提交
302 303 304
					  int, struct tcf_ematch *);
	int			(*match)(struct sk_buff *, struct tcf_ematch *,
					 struct tcf_pkt_info *);
305
	void			(*destroy)(struct tcf_ematch *);
L
Linus Torvalds 已提交
306 307 308 309 310
	int			(*dump)(struct sk_buff *, struct tcf_ematch *);
	struct module		*owner;
	struct list_head	link;
};

311 312 313 314
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 *);
315
void tcf_em_tree_destroy(struct tcf_ematch_tree *);
316 317 318
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 已提交
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343

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

344 345
#define MODULE_ALIAS_TCF_EMATCH(kind)	MODULE_ALIAS("ematch-kind-" __stringify(kind))

L
Linus Torvalds 已提交
346 347
#else /* CONFIG_NET_EMATCH */

E
Eric Dumazet 已提交
348
struct tcf_ematch_tree {
L
Linus Torvalds 已提交
349 350 351
};

#define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0)
352
#define tcf_em_tree_destroy(t) do { (void)(t); } while(0)
L
Linus Torvalds 已提交
353 354 355 356 357 358 359 360 361 362 363
#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:
364
			return skb_network_header(skb);
L
Linus Torvalds 已提交
365
		case TCF_LAYER_TRANSPORT:
366
			return skb_transport_header(skb);
L
Linus Torvalds 已提交
367 368 369 370 371
	}

	return NULL;
}

372 373
static inline int tcf_valid_offset(const struct sk_buff *skb,
				   const unsigned char *ptr, const int len)
L
Linus Torvalds 已提交
374
{
375 376 377
	return likely((ptr + len) <= skb_tail_pointer(skb) &&
		      ptr >= skb->head &&
		      (ptr <= (ptr + len)));
L
Linus Torvalds 已提交
378 379 380
}

#ifdef CONFIG_NET_CLS_IND
381 382
#include <net/net_namespace.h>

L
Linus Torvalds 已提交
383
static inline int
384
tcf_change_indev(struct net *net, struct nlattr *indev_tlv)
L
Linus Torvalds 已提交
385
{
386 387 388
	char indev[IFNAMSIZ];
	struct net_device *dev;

389
	if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ)
L
Linus Torvalds 已提交
390
		return -EINVAL;
391 392 393 394
	dev = __dev_get_by_name(net, indev);
	if (!dev)
		return -ENODEV;
	return dev->ifindex;
L
Linus Torvalds 已提交
395 396
}

397 398
static inline bool
tcf_match_indev(struct sk_buff *skb, int ifindex)
L
Linus Torvalds 已提交
399
{
400 401 402 403 404
	if (!ifindex)
		return true;
	if  (!skb->skb_iif)
		return false;
	return ifindex == skb->skb_iif;
L
Linus Torvalds 已提交
405 406 407
}
#endif /* CONFIG_NET_CLS_IND */

408 409 410 411
struct tc_cls_common_offload {
	u32 handle;
	u32 chain_index;
	__be16 protocol;
412
	u32 prio;
413 414 415 416 417 418 419 420 421
};

static inline void
tc_cls_common_offload_init(struct tc_cls_common_offload *cls_common,
			   const struct tcf_proto *tp)
{
	cls_common->handle = tp->q->handle;
	cls_common->chain_index = tp->chain->index;
	cls_common->protocol = tp->protocol;
422
	cls_common->prio = tp->prio;
423 424
}

425 426
struct tc_cls_u32_knode {
	struct tcf_exts *exts;
427
	struct tc_u32_sel *sel;
428 429 430 431
	u32 handle;
	u32 val;
	u32 mask;
	u32 link_handle;
432
	u8 fshift;
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
};

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 {
451
	struct tc_cls_common_offload common;
452 453 454 455 456 457 458 459
	/* knode values */
	enum tc_clsu32_command command;
	union {
		struct tc_cls_u32_knode knode;
		struct tc_cls_u32_hnode hnode;
	};
};

460 461
static inline bool tc_can_offload(const struct net_device *dev,
				  const struct tcf_proto *tp)
462
{
463 464 465
	const struct Qdisc *sch = tp->q;
	const struct Qdisc_class_ops *cops = sch->ops->cl_ops;

466 467
	if (!(dev->features & NETIF_F_HW_TC))
		return false;
468 469
	if (!dev->netdev_ops->ndo_setup_tc)
		return false;
470 471
	if (cops && cops->tcf_cl_offload)
		return cops->tcf_cl_offload(tp->classid);
472 473

	return true;
474 475
}

476 477 478 479 480 481 482 483 484 485 486 487 488
static inline bool tc_skip_hw(u32 flags)
{
	return (flags & TCA_CLS_FLAGS_SKIP_HW) ? true : false;
}

static inline bool tc_should_offload(const struct net_device *dev,
				     const struct tcf_proto *tp, u32 flags)
{
	if (tc_skip_hw(flags))
		return false;
	return tc_can_offload(dev, tp);
}

489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
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;
}

506 507 508 509 510
static inline bool tc_in_hw(u32 flags)
{
	return (flags & TCA_CLS_FLAGS_IN_HW) ? true : false;
}

511 512 513
enum tc_fl_command {
	TC_CLSFLOWER_REPLACE,
	TC_CLSFLOWER_DESTROY,
514
	TC_CLSFLOWER_STATS,
515 516 517
};

struct tc_cls_flower_offload {
518
	struct tc_cls_common_offload common;
519
	enum tc_fl_command command;
A
Amir Vadai 已提交
520
	unsigned long cookie;
521 522 523 524
	struct flow_dissector *dissector;
	struct fl_flow_key *mask;
	struct fl_flow_key *key;
	struct tcf_exts *exts;
525
	bool egress_dev;
526 527
};

528 529 530 531 532 533
enum tc_matchall_command {
	TC_CLSMATCHALL_REPLACE,
	TC_CLSMATCHALL_DESTROY,
};

struct tc_cls_matchall_offload {
534
	struct tc_cls_common_offload common;
535 536 537 538 539
	enum tc_matchall_command command;
	struct tcf_exts *exts;
	unsigned long cookie;
};

540 541 542 543
enum tc_clsbpf_command {
	TC_CLSBPF_ADD,
	TC_CLSBPF_REPLACE,
	TC_CLSBPF_DESTROY,
544
	TC_CLSBPF_STATS,
545 546 547
};

struct tc_cls_bpf_offload {
548
	struct tc_cls_common_offload common;
549 550 551 552 553
	enum tc_clsbpf_command command;
	struct tcf_exts *exts;
	struct bpf_prog *prog;
	const char *name;
	bool exts_integrated;
554
	u32 gen_flags;
555 556
};

557 558 559 560 561 562 563 564

/* 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 已提交
565
#endif