cls_api.c 33.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * net/sched/cls_api.c	Packet classifier API.
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 * Changes:
 *
 * Eduardo J. Blanco <ejbs@netlabs.com.uy> :990222: kmod support
 *
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
22
#include <linux/err.h>
L
Linus Torvalds 已提交
23 24 25
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/kmod.h>
26
#include <linux/slab.h>
27
#include <linux/idr.h>
28 29
#include <net/net_namespace.h>
#include <net/sock.h>
30
#include <net/netlink.h>
L
Linus Torvalds 已提交
31 32 33 34
#include <net/pkt_sched.h>
#include <net/pkt_cls.h>

/* The list of all installed classifier types */
35
static LIST_HEAD(tcf_proto_base);
L
Linus Torvalds 已提交
36 37 38 39 40 41

/* Protects list of registered TC modules. It is pure SMP lock. */
static DEFINE_RWLOCK(cls_mod_lock);

/* Find classifier type by string name */

42
static const struct tcf_proto_ops *tcf_proto_lookup_ops(const char *kind)
L
Linus Torvalds 已提交
43
{
44
	const struct tcf_proto_ops *t, *res = NULL;
L
Linus Torvalds 已提交
45 46 47

	if (kind) {
		read_lock(&cls_mod_lock);
48
		list_for_each_entry(t, &tcf_proto_base, head) {
49
			if (strcmp(kind, t->kind) == 0) {
50 51
				if (try_module_get(t->owner))
					res = t;
L
Linus Torvalds 已提交
52 53 54 55 56
				break;
			}
		}
		read_unlock(&cls_mod_lock);
	}
57
	return res;
L
Linus Torvalds 已提交
58 59 60 61 62 63
}

/* Register(unregister) new classifier type */

int register_tcf_proto_ops(struct tcf_proto_ops *ops)
{
64
	struct tcf_proto_ops *t;
L
Linus Torvalds 已提交
65 66 67
	int rc = -EEXIST;

	write_lock(&cls_mod_lock);
68
	list_for_each_entry(t, &tcf_proto_base, head)
L
Linus Torvalds 已提交
69 70 71
		if (!strcmp(ops->kind, t->kind))
			goto out;

72
	list_add_tail(&ops->head, &tcf_proto_base);
L
Linus Torvalds 已提交
73 74 75 76 77
	rc = 0;
out:
	write_unlock(&cls_mod_lock);
	return rc;
}
78
EXPORT_SYMBOL(register_tcf_proto_ops);
L
Linus Torvalds 已提交
79

80 81
static struct workqueue_struct *tc_filter_wq;

L
Linus Torvalds 已提交
82 83
int unregister_tcf_proto_ops(struct tcf_proto_ops *ops)
{
84
	struct tcf_proto_ops *t;
L
Linus Torvalds 已提交
85 86
	int rc = -ENOENT;

87 88 89 90
	/* Wait for outstanding call_rcu()s, if any, from a
	 * tcf_proto_ops's destroy() handler.
	 */
	rcu_barrier();
91
	flush_workqueue(tc_filter_wq);
92

L
Linus Torvalds 已提交
93
	write_lock(&cls_mod_lock);
94 95 96 97
	list_for_each_entry(t, &tcf_proto_base, head) {
		if (t == ops) {
			list_del(&t->head);
			rc = 0;
L
Linus Torvalds 已提交
98
			break;
99 100
		}
	}
L
Linus Torvalds 已提交
101 102 103
	write_unlock(&cls_mod_lock);
	return rc;
}
104
EXPORT_SYMBOL(unregister_tcf_proto_ops);
L
Linus Torvalds 已提交
105

106 107 108 109 110 111
bool tcf_queue_work(struct work_struct *work)
{
	return queue_work(tc_filter_wq, work);
}
EXPORT_SYMBOL(tcf_queue_work);

L
Linus Torvalds 已提交
112 113
/* Select new prio value from the range, managed by kernel. */

114
static inline u32 tcf_auto_prio(struct tcf_proto *tp)
L
Linus Torvalds 已提交
115
{
116
	u32 first = TC_H_MAKE(0xC0000000U, 0U);
L
Linus Torvalds 已提交
117 118

	if (tp)
E
Eric Dumazet 已提交
119
		first = tp->prio - 1;
L
Linus Torvalds 已提交
120

121
	return TC_H_MAJ(first);
L
Linus Torvalds 已提交
122 123
}

124
static struct tcf_proto *tcf_proto_create(const char *kind, u32 protocol,
125
					  u32 prio, u32 parent, struct Qdisc *q,
126
					  struct tcf_chain *chain)
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
{
	struct tcf_proto *tp;
	int err;

	tp = kzalloc(sizeof(*tp), GFP_KERNEL);
	if (!tp)
		return ERR_PTR(-ENOBUFS);

	err = -ENOENT;
	tp->ops = tcf_proto_lookup_ops(kind);
	if (!tp->ops) {
#ifdef CONFIG_MODULES
		rtnl_unlock();
		request_module("cls_%s", kind);
		rtnl_lock();
		tp->ops = tcf_proto_lookup_ops(kind);
		/* We dropped the RTNL semaphore in order to perform
		 * the module load. So, even if we succeeded in loading
		 * the module we have to replay the request. We indicate
		 * this using -EAGAIN.
		 */
		if (tp->ops) {
			module_put(tp->ops->owner);
			err = -EAGAIN;
		} else {
			err = -ENOENT;
		}
		goto errout;
#endif
	}
	tp->classify = tp->ops->classify;
	tp->protocol = protocol;
	tp->prio = prio;
	tp->classid = parent;
	tp->q = q;
162
	tp->chain = chain;
163 164 165 166 167 168 169 170 171 172 173 174 175

	err = tp->ops->init(tp);
	if (err) {
		module_put(tp->ops->owner);
		goto errout;
	}
	return tp;

errout:
	kfree(tp);
	return ERR_PTR(err);
}

176
static void tcf_proto_destroy(struct tcf_proto *tp)
177
{
178 179 180
	tp->ops->destroy(tp);
	module_put(tp->ops->owner);
	kfree_rcu(tp, rcu);
181 182
}

183 184 185 186 187 188
struct tcf_filter_chain_list_item {
	struct list_head list;
	tcf_chain_head_change_t *chain_head_change;
	void *chain_head_change_priv;
};

189 190
static struct tcf_chain *tcf_chain_create(struct tcf_block *block,
					  u32 chain_index)
191
{
192 193 194 195 196
	struct tcf_chain *chain;

	chain = kzalloc(sizeof(*chain), GFP_KERNEL);
	if (!chain)
		return NULL;
197
	INIT_LIST_HEAD(&chain->filter_chain_list);
198 199 200
	list_add_tail(&chain->list, &block->chain_list);
	chain->block = block;
	chain->index = chain_index;
201
	chain->refcnt = 1;
202
	return chain;
203 204
}

205 206 207 208 209 210
static void tcf_chain_head_change_item(struct tcf_filter_chain_list_item *item,
				       struct tcf_proto *tp_head)
{
	if (item->chain_head_change)
		item->chain_head_change(tp_head, item->chain_head_change_priv);
}
211 212 213
static void tcf_chain_head_change(struct tcf_chain *chain,
				  struct tcf_proto *tp_head)
{
214 215 216 217
	struct tcf_filter_chain_list_item *item;

	list_for_each_entry(item, &chain->filter_chain_list, list)
		tcf_chain_head_change_item(item, tp_head);
218 219
}

J
Jiri Pirko 已提交
220
static void tcf_chain_flush(struct tcf_chain *chain)
221
{
222
	struct tcf_proto *tp = rtnl_dereference(chain->filter_chain);
223

224
	tcf_chain_head_change(chain, NULL);
225
	while (tp) {
226
		RCU_INIT_POINTER(chain->filter_chain, tp->next);
227
		tcf_proto_destroy(tp);
228 229
		tp = rtnl_dereference(chain->filter_chain);
		tcf_chain_put(chain);
230
	}
J
Jiri Pirko 已提交
231 232 233 234
}

static void tcf_chain_destroy(struct tcf_chain *chain)
{
235 236
	struct tcf_block *block = chain->block;

237 238
	list_del(&chain->list);
	kfree(chain);
239 240
	if (list_empty(&block->chain_list))
		kfree(block);
241
}
242

243 244 245
static void tcf_chain_hold(struct tcf_chain *chain)
{
	++chain->refcnt;
246 247
}

248 249
struct tcf_chain *tcf_chain_get(struct tcf_block *block, u32 chain_index,
				bool create)
250 251 252 253
{
	struct tcf_chain *chain;

	list_for_each_entry(chain, &block->chain_list, list) {
254 255 256 257
		if (chain->index == chain_index) {
			tcf_chain_hold(chain);
			return chain;
		}
258
	}
259

260
	return create ? tcf_chain_create(block, chain_index) : NULL;
261 262 263 264 265
}
EXPORT_SYMBOL(tcf_chain_get);

void tcf_chain_put(struct tcf_chain *chain)
{
266
	if (--chain->refcnt == 0)
267 268 269 270
		tcf_chain_destroy(chain);
}
EXPORT_SYMBOL(tcf_chain_put);

271 272 273 274 275 276 277
static void tcf_block_offload_cmd(struct tcf_block *block, struct Qdisc *q,
				  struct tcf_block_ext_info *ei,
				  enum tc_block_command command)
{
	struct net_device *dev = q->dev_queue->dev;
	struct tc_block_offload bo = {};

278
	if (!dev->netdev_ops->ndo_setup_tc)
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
		return;
	bo.command = command;
	bo.binder_type = ei->binder_type;
	bo.block = block;
	dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_BLOCK, &bo);
}

static void tcf_block_offload_bind(struct tcf_block *block, struct Qdisc *q,
				   struct tcf_block_ext_info *ei)
{
	tcf_block_offload_cmd(block, q, ei, TC_BLOCK_BIND);
}

static void tcf_block_offload_unbind(struct tcf_block *block, struct Qdisc *q,
				     struct tcf_block_ext_info *ei)
{
	tcf_block_offload_cmd(block, q, ei, TC_BLOCK_UNBIND);
}

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
static int
tcf_chain_head_change_cb_add(struct tcf_chain *chain,
			     struct tcf_block_ext_info *ei,
			     struct netlink_ext_ack *extack)
{
	struct tcf_filter_chain_list_item *item;

	item = kmalloc(sizeof(*item), GFP_KERNEL);
	if (!item) {
		NL_SET_ERR_MSG(extack, "Memory allocation for head change callback item failed");
		return -ENOMEM;
	}
	item->chain_head_change = ei->chain_head_change;
	item->chain_head_change_priv = ei->chain_head_change_priv;
	if (chain->filter_chain)
		tcf_chain_head_change_item(item, chain->filter_chain);
	list_add(&item->list, &chain->filter_chain_list);
	return 0;
}

static void
tcf_chain_head_change_cb_del(struct tcf_chain *chain,
			     struct tcf_block_ext_info *ei)
{
	struct tcf_filter_chain_list_item *item;

	list_for_each_entry(item, &chain->filter_chain_list, list) {
		if ((!ei->chain_head_change && !ei->chain_head_change_priv) ||
		    (item->chain_head_change == ei->chain_head_change &&
		     item->chain_head_change_priv == ei->chain_head_change_priv)) {
			tcf_chain_head_change_item(item, NULL);
			list_del(&item->list);
			kfree(item);
			return;
		}
	}
	WARN_ON(1);
}

337 338 339 340 341 342 343 344
struct tcf_net {
	struct idr idr;
};

static unsigned int tcf_net_id;

static int tcf_block_insert(struct tcf_block *block, struct net *net,
			    u32 block_index, struct netlink_ext_ack *extack)
345
{
346 347 348 349 350 351 352 353 354
	struct tcf_net *tn = net_generic(net, tcf_net_id);
	int err;

	err = idr_alloc_ext(&tn->idr, block, NULL, block_index,
			    block_index + 1, GFP_KERNEL);
	if (err)
		return err;
	block->index = block_index;
	return 0;
355 356
}

357 358 359 360 361 362 363 364 365
static void tcf_block_remove(struct tcf_block *block, struct net *net)
{
	struct tcf_net *tn = net_generic(net, tcf_net_id);

	idr_remove_ext(&tn->idr, block->index);
}

static struct tcf_block *tcf_block_create(struct net *net, struct Qdisc *q,
					  struct netlink_ext_ack *extack)
366
{
367
	struct tcf_block *block;
368
	struct tcf_chain *chain;
369
	int err;
370

371
	block = kzalloc(sizeof(*block), GFP_KERNEL);
372 373
	if (!block) {
		NL_SET_ERR_MSG(extack, "Memory allocation for block failed");
374
		return ERR_PTR(-ENOMEM);
375
	}
376
	INIT_LIST_HEAD(&block->chain_list);
377 378
	INIT_LIST_HEAD(&block->cb_list);

379 380 381
	/* Create chain 0 by default, it has to be always present. */
	chain = tcf_chain_create(block, 0);
	if (!chain) {
382
		NL_SET_ERR_MSG(extack, "Failed to create new tcf chain");
383 384 385
		err = -ENOMEM;
		goto err_chain_create;
	}
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 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
	block->net = qdisc_net(q);
	block->refcnt = 1;
	block->net = net;
	block->q = q;
	return block;

err_chain_create:
	kfree(block);
	return ERR_PTR(err);
}

static struct tcf_block *tcf_block_lookup(struct net *net, u32 block_index)
{
	struct tcf_net *tn = net_generic(net, tcf_net_id);

	return idr_find_ext(&tn->idr, block_index);
}

static struct tcf_chain *tcf_block_chain_zero(struct tcf_block *block)
{
	return list_first_entry(&block->chain_list, struct tcf_chain, list);
}

int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q,
		      struct tcf_block_ext_info *ei,
		      struct netlink_ext_ack *extack)
{
	struct net *net = qdisc_net(q);
	struct tcf_block *block = NULL;
	bool created = false;
	int err;

	if (ei->block_index) {
		/* block_index not 0 means the shared block is requested */
		block = tcf_block_lookup(net, ei->block_index);
		if (block)
			block->refcnt++;
	}

	if (!block) {
		block = tcf_block_create(net, q, extack);
		if (IS_ERR(block))
			return PTR_ERR(block);
		created = true;
		if (ei->block_index) {
			err = tcf_block_insert(block, net,
					       ei->block_index, extack);
			if (err)
				goto err_block_insert;
		}
	}

438 439 440 441
	err = tcf_chain_head_change_cb_add(tcf_block_chain_zero(block),
					   ei, extack);
	if (err)
		goto err_chain_head_change_cb_add;
442
	tcf_block_offload_bind(block, q, ei);
443 444
	*p_block = block;
	return 0;
445

446
err_chain_head_change_cb_add:
447 448 449 450 451 452 453 454 455
	if (created) {
		if (tcf_block_shared(block))
			tcf_block_remove(block, net);
err_block_insert:
		kfree(tcf_block_chain_zero(block));
		kfree(block);
	} else {
		block->refcnt--;
	}
456
	return err;
457
}
458 459
EXPORT_SYMBOL(tcf_block_get_ext);

460 461 462 463 464 465 466
static void tcf_chain_head_change_dflt(struct tcf_proto *tp_head, void *priv)
{
	struct tcf_proto __rcu **p_filter_chain = priv;

	rcu_assign_pointer(*p_filter_chain, tp_head);
}

467
int tcf_block_get(struct tcf_block **p_block,
468 469
		  struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q,
		  struct netlink_ext_ack *extack)
470
{
471 472 473 474
	struct tcf_block_ext_info ei = {
		.chain_head_change = tcf_chain_head_change_dflt,
		.chain_head_change_priv = p_filter_chain,
	};
475

476
	WARN_ON(!p_filter_chain);
477
	return tcf_block_get_ext(p_block, q, &ei, extack);
478
}
479 480
EXPORT_SYMBOL(tcf_block_get);

481
/* XXX: Standalone actions are not allowed to jump to any chain, and bound
482
 * actions should be all removed after flushing.
483
 */
484
void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q,
485
		       struct tcf_block_ext_info *ei)
486
{
487
	struct tcf_chain *chain, *tmp;
488

489 490
	if (!block)
		return;
491
	tcf_chain_head_change_cb_del(tcf_block_chain_zero(block), ei);
492

493 494 495 496 497 498 499 500 501 502 503 504 505
	if (--block->refcnt == 0) {
		if (tcf_block_shared(block))
			tcf_block_remove(block, block->net);

		/* Hold a refcnt for all chains, so that they don't disappear
		 * while we are iterating.
		 */
		list_for_each_entry(chain, &block->chain_list, list)
			tcf_chain_hold(chain);

		list_for_each_entry(chain, &block->chain_list, list)
			tcf_chain_flush(chain);
	}
506

507 508
	tcf_block_offload_unbind(block, q, ei);

509 510 511 512
	if (block->refcnt == 0) {
		/* At this point, all the chains should have refcnt >= 1. */
		list_for_each_entry_safe(chain, tmp, &block->chain_list, list)
			tcf_chain_put(chain);
513

514 515 516
		/* Finally, put chain 0 and allow block to be freed. */
		tcf_chain_put(tcf_block_chain_zero(block));
	}
517
}
518 519 520 521 522 523
EXPORT_SYMBOL(tcf_block_put_ext);

void tcf_block_put(struct tcf_block *block)
{
	struct tcf_block_ext_info ei = {0, };

524 525
	if (!block)
		return;
526
	tcf_block_put_ext(block, block->q, &ei);
527
}
528

529
EXPORT_SYMBOL(tcf_block_put);
530

531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 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 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
struct tcf_block_cb {
	struct list_head list;
	tc_setup_cb_t *cb;
	void *cb_ident;
	void *cb_priv;
	unsigned int refcnt;
};

void *tcf_block_cb_priv(struct tcf_block_cb *block_cb)
{
	return block_cb->cb_priv;
}
EXPORT_SYMBOL(tcf_block_cb_priv);

struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block,
					 tc_setup_cb_t *cb, void *cb_ident)
{	struct tcf_block_cb *block_cb;

	list_for_each_entry(block_cb, &block->cb_list, list)
		if (block_cb->cb == cb && block_cb->cb_ident == cb_ident)
			return block_cb;
	return NULL;
}
EXPORT_SYMBOL(tcf_block_cb_lookup);

void tcf_block_cb_incref(struct tcf_block_cb *block_cb)
{
	block_cb->refcnt++;
}
EXPORT_SYMBOL(tcf_block_cb_incref);

unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb)
{
	return --block_cb->refcnt;
}
EXPORT_SYMBOL(tcf_block_cb_decref);

struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block,
					     tc_setup_cb_t *cb, void *cb_ident,
					     void *cb_priv)
{
	struct tcf_block_cb *block_cb;

	block_cb = kzalloc(sizeof(*block_cb), GFP_KERNEL);
	if (!block_cb)
		return NULL;
	block_cb->cb = cb;
	block_cb->cb_ident = cb_ident;
	block_cb->cb_priv = cb_priv;
	list_add(&block_cb->list, &block->cb_list);
	return block_cb;
}
EXPORT_SYMBOL(__tcf_block_cb_register);

int tcf_block_cb_register(struct tcf_block *block,
			  tc_setup_cb_t *cb, void *cb_ident,
			  void *cb_priv)
{
	struct tcf_block_cb *block_cb;

	block_cb = __tcf_block_cb_register(block, cb, cb_ident, cb_priv);
	return block_cb ? 0 : -ENOMEM;
}
EXPORT_SYMBOL(tcf_block_cb_register);

void __tcf_block_cb_unregister(struct tcf_block_cb *block_cb)
{
	list_del(&block_cb->list);
	kfree(block_cb);
}
EXPORT_SYMBOL(__tcf_block_cb_unregister);

void tcf_block_cb_unregister(struct tcf_block *block,
			     tc_setup_cb_t *cb, void *cb_ident)
{
	struct tcf_block_cb *block_cb;

	block_cb = tcf_block_cb_lookup(block, cb, cb_ident);
	if (!block_cb)
		return;
	__tcf_block_cb_unregister(block_cb);
}
EXPORT_SYMBOL(tcf_block_cb_unregister);

static int tcf_block_cb_call(struct tcf_block *block, enum tc_setup_type type,
			     void *type_data, bool err_stop)
{
	struct tcf_block_cb *block_cb;
	int ok_count = 0;
	int err;

	list_for_each_entry(block_cb, &block->cb_list, list) {
		err = block_cb->cb(type, type_data, block_cb->cb_priv);
		if (err) {
			if (err_stop)
				return err;
		} else {
			ok_count++;
		}
	}
	return ok_count;
}

634 635 636 637 638 639 640 641 642 643
/* Main classifier routine: scans classifier chain attached
 * to this qdisc, (optionally) tests for protocol and asks
 * specific classifiers.
 */
int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
		 struct tcf_result *res, bool compat_mode)
{
	__be16 protocol = tc_skb_protocol(skb);
#ifdef CONFIG_NET_CLS_ACT
	const int max_reclassify_loop = 4;
644 645
	const struct tcf_proto *orig_tp = tp;
	const struct tcf_proto *first_tp;
646 647 648 649 650 651 652 653 654 655 656 657 658
	int limit = 0;

reclassify:
#endif
	for (; tp; tp = rcu_dereference_bh(tp->next)) {
		int err;

		if (tp->protocol != protocol &&
		    tp->protocol != htons(ETH_P_ALL))
			continue;

		err = tp->classify(skb, tp, res);
#ifdef CONFIG_NET_CLS_ACT
659
		if (unlikely(err == TC_ACT_RECLASSIFY && !compat_mode)) {
660
			first_tp = orig_tp;
661
			goto reset;
662
		} else if (unlikely(TC_ACT_EXT_CMP(err, TC_ACT_GOTO_CHAIN))) {
663
			first_tp = res->goto_tp;
664 665
			goto reset;
		}
666 667 668 669 670 671 672 673 674
#endif
		if (err >= 0)
			return err;
	}

	return TC_ACT_UNSPEC; /* signal: continue lookup */
#ifdef CONFIG_NET_CLS_ACT
reset:
	if (unlikely(limit++ >= max_reclassify_loop)) {
675 676 677
		net_notice_ratelimited("%u: reclassify loop, rule prio %u, protocol %02x\n",
				       tp->chain->block->index,
				       tp->prio & 0xffff,
678 679 680 681
				       ntohs(tp->protocol));
		return TC_ACT_SHOT;
	}

682
	tp = first_tp;
683 684 685 686 687 688
	protocol = tc_skb_protocol(skb);
	goto reclassify;
#endif
}
EXPORT_SYMBOL(tcf_classify);

689 690 691 692 693 694 695 696 697 698 699 700 701 702
struct tcf_chain_info {
	struct tcf_proto __rcu **pprev;
	struct tcf_proto __rcu *next;
};

static struct tcf_proto *tcf_chain_tp_prev(struct tcf_chain_info *chain_info)
{
	return rtnl_dereference(*chain_info->pprev);
}

static void tcf_chain_tp_insert(struct tcf_chain *chain,
				struct tcf_chain_info *chain_info,
				struct tcf_proto *tp)
{
703 704
	if (*chain_info->pprev == chain->filter_chain)
		tcf_chain_head_change(chain, tp);
705 706
	RCU_INIT_POINTER(tp->next, tcf_chain_tp_prev(chain_info));
	rcu_assign_pointer(*chain_info->pprev, tp);
707
	tcf_chain_hold(chain);
708 709 710 711 712 713 714 715
}

static void tcf_chain_tp_remove(struct tcf_chain *chain,
				struct tcf_chain_info *chain_info,
				struct tcf_proto *tp)
{
	struct tcf_proto *next = rtnl_dereference(chain_info->next);

716 717
	if (tp == chain->filter_chain)
		tcf_chain_head_change(chain, next);
718
	RCU_INIT_POINTER(*chain_info->pprev, next);
719
	tcf_chain_put(chain);
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
}

static struct tcf_proto *tcf_chain_tp_find(struct tcf_chain *chain,
					   struct tcf_chain_info *chain_info,
					   u32 protocol, u32 prio,
					   bool prio_allocate)
{
	struct tcf_proto **pprev;
	struct tcf_proto *tp;

	/* Check the chain for existence of proto-tcf with this priority */
	for (pprev = &chain->filter_chain;
	     (tp = rtnl_dereference(*pprev)); pprev = &tp->next) {
		if (tp->prio >= prio) {
			if (tp->prio == prio) {
				if (prio_allocate ||
				    (tp->protocol != protocol && protocol))
					return ERR_PTR(-EINVAL);
			} else {
				tp = NULL;
			}
			break;
		}
	}
	chain_info->pprev = pprev;
	chain_info->next = tp ? tp->next : NULL;
	return tp;
}

749
static int tcf_fill_node(struct net *net, struct sk_buff *skb,
750 751
			 struct tcf_proto *tp, struct Qdisc *q, u32 parent,
			 void *fh, u32 portid, u32 seq, u16 flags, int event)
752 753 754 755 756 757 758 759 760 761 762 763
{
	struct tcmsg *tcm;
	struct nlmsghdr  *nlh;
	unsigned char *b = skb_tail_pointer(skb);

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
	if (!nlh)
		goto out_nlmsg_trim;
	tcm = nlmsg_data(nlh);
	tcm->tcm_family = AF_UNSPEC;
	tcm->tcm__pad1 = 0;
	tcm->tcm__pad2 = 0;
764 765
	tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
	tcm->tcm_parent = parent;
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
	tcm->tcm_info = TC_H_MAKE(tp->prio, tp->protocol);
	if (nla_put_string(skb, TCA_KIND, tp->ops->kind))
		goto nla_put_failure;
	if (nla_put_u32(skb, TCA_CHAIN, tp->chain->index))
		goto nla_put_failure;
	if (!fh) {
		tcm->tcm_handle = 0;
	} else {
		if (tp->ops->dump && tp->ops->dump(net, tp, fh, skb, tcm) < 0)
			goto nla_put_failure;
	}
	nlh->nlmsg_len = skb_tail_pointer(skb) - b;
	return skb->len;

out_nlmsg_trim:
nla_put_failure:
	nlmsg_trim(skb, b);
	return -1;
}

static int tfilter_notify(struct net *net, struct sk_buff *oskb,
			  struct nlmsghdr *n, struct tcf_proto *tp,
788
			  struct Qdisc *q, u32 parent,
789 790 791 792 793 794 795 796 797
			  void *fh, int event, bool unicast)
{
	struct sk_buff *skb;
	u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;

	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!skb)
		return -ENOBUFS;

798
	if (tcf_fill_node(net, skb, tp, q, parent, fh, portid, n->nlmsg_seq,
799 800 801 802 803 804 805 806 807 808 809 810 811 812
			  n->nlmsg_flags, event) <= 0) {
		kfree_skb(skb);
		return -EINVAL;
	}

	if (unicast)
		return netlink_unicast(net->rtnl, skb, portid, MSG_DONTWAIT);

	return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
			      n->nlmsg_flags & NLM_F_ECHO);
}

static int tfilter_del_notify(struct net *net, struct sk_buff *oskb,
			      struct nlmsghdr *n, struct tcf_proto *tp,
813
			      struct Qdisc *q, u32 parent,
814 815 816 817 818 819 820 821 822 823
			      void *fh, bool unicast, bool *last)
{
	struct sk_buff *skb;
	u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
	int err;

	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!skb)
		return -ENOBUFS;

824
	if (tcf_fill_node(net, skb, tp, q, parent, fh, portid, n->nlmsg_seq,
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
			  n->nlmsg_flags, RTM_DELTFILTER) <= 0) {
		kfree_skb(skb);
		return -EINVAL;
	}

	err = tp->ops->delete(tp, fh, last);
	if (err) {
		kfree_skb(skb);
		return err;
	}

	if (unicast)
		return netlink_unicast(net->rtnl, skb, portid, MSG_DONTWAIT);

	return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
			      n->nlmsg_flags & NLM_F_ECHO);
}

static void tfilter_notify_chain(struct net *net, struct sk_buff *oskb,
844
				 struct Qdisc *q, u32 parent,
845 846 847 848 849 850 851
				 struct nlmsghdr *n,
				 struct tcf_chain *chain, int event)
{
	struct tcf_proto *tp;

	for (tp = rtnl_dereference(chain->filter_chain);
	     tp; tp = rtnl_dereference(tp->next))
852
		tfilter_notify(net, oskb, n, tp, q, parent, 0, event, false);
853 854
}

L
Linus Torvalds 已提交
855 856
/* Add/change/delete/get a filter node */

857 858
static int tc_ctl_tfilter(struct sk_buff *skb, struct nlmsghdr *n,
			  struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
859
{
860
	struct net *net = sock_net(skb->sk);
861
	struct nlattr *tca[TCA_MAX + 1];
L
Linus Torvalds 已提交
862 863 864
	struct tcmsg *t;
	u32 protocol;
	u32 prio;
865
	bool prio_allocate;
L
Linus Torvalds 已提交
866
	u32 parent;
867
	u32 chain_index;
L
Linus Torvalds 已提交
868 869
	struct net_device *dev;
	struct Qdisc  *q;
870
	struct tcf_chain_info chain_info;
871
	struct tcf_chain *chain = NULL;
872
	struct tcf_block *block;
L
Linus Torvalds 已提交
873
	struct tcf_proto *tp;
874
	const struct Qdisc_class_ops *cops;
L
Linus Torvalds 已提交
875
	unsigned long cl;
876
	void *fh;
L
Linus Torvalds 已提交
877
	int err;
878
	int tp_created;
L
Linus Torvalds 已提交
879

880
	if ((n->nlmsg_type != RTM_GETTFILTER) &&
881
	    !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
882
		return -EPERM;
883

L
Linus Torvalds 已提交
884
replay:
885 886
	tp_created = 0;

887
	err = nlmsg_parse(n, sizeof(*t), tca, TCA_MAX, NULL, extack);
888 889 890
	if (err < 0)
		return err;

891
	t = nlmsg_data(n);
L
Linus Torvalds 已提交
892 893
	protocol = TC_H_MIN(t->tcm_info);
	prio = TC_H_MAJ(t->tcm_info);
894
	prio_allocate = false;
L
Linus Torvalds 已提交
895 896 897 898
	parent = t->tcm_parent;
	cl = 0;

	if (prio == 0) {
899 900
		switch (n->nlmsg_type) {
		case RTM_DELTFILTER:
901
			if (protocol || t->tcm_handle || tca[TCA_KIND])
902 903 904 905 906 907 908 909
				return -ENOENT;
			break;
		case RTM_NEWTFILTER:
			/* If no priority is provided by the user,
			 * we allocate one.
			 */
			if (n->nlmsg_flags & NLM_F_CREATE) {
				prio = TC_H_MAKE(0x80000000U, 0U);
910
				prio_allocate = true;
911 912 913 914
				break;
			}
			/* fall-through */
		default:
L
Linus Torvalds 已提交
915
			return -ENOENT;
916
		}
L
Linus Torvalds 已提交
917 918 919 920 921
	}

	/* Find head of filter chain. */

	/* Find link */
922
	dev = __dev_get_by_index(net, t->tcm_ifindex);
923
	if (dev == NULL)
L
Linus Torvalds 已提交
924 925 926 927
		return -ENODEV;

	/* Find qdisc */
	if (!parent) {
928
		q = dev->qdisc;
L
Linus Torvalds 已提交
929
		parent = q->handle;
930 931 932 933 934
	} else {
		q = qdisc_lookup(dev, TC_H_MAJ(t->tcm_parent));
		if (q == NULL)
			return -EINVAL;
	}
L
Linus Torvalds 已提交
935 936

	/* Is it classful? */
E
Eric Dumazet 已提交
937 938
	cops = q->ops->cl_ops;
	if (!cops)
L
Linus Torvalds 已提交
939 940
		return -EINVAL;

941
	if (!cops->tcf_block)
942 943
		return -EOPNOTSUPP;

L
Linus Torvalds 已提交
944 945
	/* Do we search for filter, attached to class? */
	if (TC_H_MIN(parent)) {
946
		cl = cops->find(q, parent);
L
Linus Torvalds 已提交
947 948 949 950 951
		if (cl == 0)
			return -ENOENT;
	}

	/* And the last stroke */
952
	block = cops->tcf_block(q, cl, extack);
953
	if (!block) {
954
		err = -EINVAL;
L
Linus Torvalds 已提交
955
		goto errout;
956
	}
957 958 959 960 961 962

	chain_index = tca[TCA_CHAIN] ? nla_get_u32(tca[TCA_CHAIN]) : 0;
	if (chain_index > TC_ACT_EXT_VAL_MASK) {
		err = -EINVAL;
		goto errout;
	}
963 964
	chain = tcf_chain_get(block, chain_index,
			      n->nlmsg_type == RTM_NEWTFILTER);
965
	if (!chain) {
966
		err = n->nlmsg_type == RTM_NEWTFILTER ? -ENOMEM : -EINVAL;
967 968
		goto errout;
	}
969

970
	if (n->nlmsg_type == RTM_DELTFILTER && prio == 0) {
971 972
		tfilter_notify_chain(net, skb, q, parent, n,
				     chain, RTM_DELTFILTER);
J
Jiri Pirko 已提交
973
		tcf_chain_flush(chain);
974 975 976
		err = 0;
		goto errout;
	}
L
Linus Torvalds 已提交
977

978 979 980 981 982
	tp = tcf_chain_tp_find(chain, &chain_info, protocol,
			       prio, prio_allocate);
	if (IS_ERR(tp)) {
		err = PTR_ERR(tp);
		goto errout;
L
Linus Torvalds 已提交
983 984 985 986 987
	}

	if (tp == NULL) {
		/* Proto-tcf does not exist, create new one */

988 989
		if (tca[TCA_KIND] == NULL || !protocol) {
			err = -EINVAL;
L
Linus Torvalds 已提交
990
			goto errout;
991
		}
L
Linus Torvalds 已提交
992

E
Eric Dumazet 已提交
993
		if (n->nlmsg_type != RTM_NEWTFILTER ||
994 995
		    !(n->nlmsg_flags & NLM_F_CREATE)) {
			err = -ENOENT;
L
Linus Torvalds 已提交
996
			goto errout;
997
		}
L
Linus Torvalds 已提交
998

999
		if (prio_allocate)
1000
			prio = tcf_auto_prio(tcf_chain_tp_prev(&chain_info));
L
Linus Torvalds 已提交
1001

1002
		tp = tcf_proto_create(nla_data(tca[TCA_KIND]),
1003
				      protocol, prio, parent, q, chain);
1004 1005
		if (IS_ERR(tp)) {
			err = PTR_ERR(tp);
L
Linus Torvalds 已提交
1006 1007
			goto errout;
		}
1008
		tp_created = 1;
1009 1010
	} else if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], tp->ops->kind)) {
		err = -EINVAL;
L
Linus Torvalds 已提交
1011
		goto errout;
1012
	}
L
Linus Torvalds 已提交
1013 1014 1015

	fh = tp->ops->get(tp, t->tcm_handle);

1016
	if (!fh) {
L
Linus Torvalds 已提交
1017
		if (n->nlmsg_type == RTM_DELTFILTER && t->tcm_handle == 0) {
1018
			tcf_chain_tp_remove(chain, &chain_info, tp);
1019
			tfilter_notify(net, skb, n, tp, q, parent, fh,
1020
				       RTM_DELTFILTER, false);
1021
			tcf_proto_destroy(tp);
L
Linus Torvalds 已提交
1022 1023 1024 1025
			err = 0;
			goto errout;
		}

1026
		if (n->nlmsg_type != RTM_NEWTFILTER ||
1027 1028
		    !(n->nlmsg_flags & NLM_F_CREATE)) {
			err = -ENOENT;
L
Linus Torvalds 已提交
1029
			goto errout;
1030
		}
L
Linus Torvalds 已提交
1031
	} else {
1032 1033
		bool last;

L
Linus Torvalds 已提交
1034
		switch (n->nlmsg_type) {
1035
		case RTM_NEWTFILTER:
1036 1037
			if (n->nlmsg_flags & NLM_F_EXCL) {
				if (tp_created)
1038
					tcf_proto_destroy(tp);
1039
				err = -EEXIST;
L
Linus Torvalds 已提交
1040
				goto errout;
1041
			}
L
Linus Torvalds 已提交
1042 1043
			break;
		case RTM_DELTFILTER:
1044 1045
			err = tfilter_del_notify(net, skb, n, tp, q, parent,
						 fh, false, &last);
1046 1047
			if (err)
				goto errout;
1048
			if (last) {
1049
				tcf_chain_tp_remove(chain, &chain_info, tp);
1050 1051
				tcf_proto_destroy(tp);
			}
1052
			goto errout;
L
Linus Torvalds 已提交
1053
		case RTM_GETTFILTER:
1054
			err = tfilter_notify(net, skb, n, tp, q, parent, fh,
1055
					     RTM_NEWTFILTER, true);
L
Linus Torvalds 已提交
1056 1057 1058 1059 1060 1061 1062
			goto errout;
		default:
			err = -EINVAL;
			goto errout;
		}
	}

1063 1064
	err = tp->ops->change(net, skb, tp, cl, t->tcm_handle, tca, &fh,
			      n->nlmsg_flags & NLM_F_CREATE ? TCA_ACT_NOREPLACE : TCA_ACT_REPLACE);
1065
	if (err == 0) {
1066 1067
		if (tp_created)
			tcf_chain_tp_insert(chain, &chain_info, tp);
1068 1069
		tfilter_notify(net, skb, n, tp, q, parent, fh,
			       RTM_NEWTFILTER, false);
1070 1071
	} else {
		if (tp_created)
1072
			tcf_proto_destroy(tp);
1073
	}
L
Linus Torvalds 已提交
1074 1075

errout:
1076 1077
	if (chain)
		tcf_chain_put(chain);
L
Linus Torvalds 已提交
1078 1079 1080 1081 1082 1083
	if (err == -EAGAIN)
		/* Replay the request. */
		goto replay;
	return err;
}

1084
struct tcf_dump_args {
L
Linus Torvalds 已提交
1085 1086 1087
	struct tcf_walker w;
	struct sk_buff *skb;
	struct netlink_callback *cb;
1088 1089
	struct Qdisc *q;
	u32 parent;
L
Linus Torvalds 已提交
1090 1091
};

1092
static int tcf_node_dump(struct tcf_proto *tp, void *n, struct tcf_walker *arg)
L
Linus Torvalds 已提交
1093
{
1094
	struct tcf_dump_args *a = (void *)arg;
1095
	struct net *net = sock_net(a->skb->sk);
L
Linus Torvalds 已提交
1096

1097 1098
	return tcf_fill_node(net, a->skb, tp, a->q, a->parent,
			     n, NETLINK_CB(a->cb->skb).portid,
J
Jamal Hadi Salim 已提交
1099 1100
			     a->cb->nlh->nlmsg_seq, NLM_F_MULTI,
			     RTM_NEWTFILTER);
L
Linus Torvalds 已提交
1101 1102
}

1103 1104
static bool tcf_chain_dump(struct tcf_chain *chain, struct Qdisc *q, u32 parent,
			   struct sk_buff *skb, struct netlink_callback *cb,
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
			   long index_start, long *p_index)
{
	struct net *net = sock_net(skb->sk);
	struct tcmsg *tcm = nlmsg_data(cb->nlh);
	struct tcf_dump_args arg;
	struct tcf_proto *tp;

	for (tp = rtnl_dereference(chain->filter_chain);
	     tp; tp = rtnl_dereference(tp->next), (*p_index)++) {
		if (*p_index < index_start)
			continue;
		if (TC_H_MAJ(tcm->tcm_info) &&
		    TC_H_MAJ(tcm->tcm_info) != tp->prio)
			continue;
		if (TC_H_MIN(tcm->tcm_info) &&
		    TC_H_MIN(tcm->tcm_info) != tp->protocol)
			continue;
		if (*p_index > index_start)
			memset(&cb->args[1], 0,
			       sizeof(cb->args) - sizeof(cb->args[0]));
		if (cb->args[1] == 0) {
1126
			if (tcf_fill_node(net, skb, tp, q, parent, 0,
1127 1128 1129
					  NETLINK_CB(cb->skb).portid,
					  cb->nlh->nlmsg_seq, NLM_F_MULTI,
					  RTM_NEWTFILTER) <= 0)
1130
				return false;
1131 1132 1133 1134 1135 1136 1137 1138

			cb->args[1] = 1;
		}
		if (!tp->ops->walk)
			continue;
		arg.w.fn = tcf_node_dump;
		arg.skb = skb;
		arg.cb = cb;
1139 1140
		arg.q = q;
		arg.parent = parent;
1141 1142 1143 1144 1145 1146
		arg.w.stop = 0;
		arg.w.skip = cb->args[1] - 1;
		arg.w.count = 0;
		tp->ops->walk(tp, &arg.w);
		cb->args[1] = arg.w.count + 1;
		if (arg.w.stop)
1147
			return false;
1148
	}
1149
	return true;
1150 1151
}

E
Eric Dumazet 已提交
1152
/* called with RTNL */
L
Linus Torvalds 已提交
1153 1154
static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
{
1155
	struct net *net = sock_net(skb->sk);
1156
	struct nlattr *tca[TCA_MAX + 1];
L
Linus Torvalds 已提交
1157 1158
	struct net_device *dev;
	struct Qdisc *q;
1159
	struct tcf_block *block;
1160
	struct tcf_chain *chain;
1161
	struct tcmsg *tcm = nlmsg_data(cb->nlh);
L
Linus Torvalds 已提交
1162
	unsigned long cl = 0;
1163
	const struct Qdisc_class_ops *cops;
1164 1165
	long index_start;
	long index;
1166
	u32 parent;
1167
	int err;
L
Linus Torvalds 已提交
1168

1169
	if (nlmsg_len(cb->nlh) < sizeof(*tcm))
L
Linus Torvalds 已提交
1170
		return skb->len;
1171 1172 1173 1174 1175

	err = nlmsg_parse(cb->nlh, sizeof(*tcm), tca, TCA_MAX, NULL, NULL);
	if (err)
		return err;

E
Eric Dumazet 已提交
1176 1177
	dev = __dev_get_by_index(net, tcm->tcm_ifindex);
	if (!dev)
L
Linus Torvalds 已提交
1178 1179
		return skb->len;

1180 1181
	parent = tcm->tcm_parent;
	if (!parent) {
1182
		q = dev->qdisc;
1183 1184
		parent = q->handle;
	} else {
L
Linus Torvalds 已提交
1185
		q = qdisc_lookup(dev, TC_H_MAJ(tcm->tcm_parent));
1186
	}
L
Linus Torvalds 已提交
1187 1188
	if (!q)
		goto out;
E
Eric Dumazet 已提交
1189 1190
	cops = q->ops->cl_ops;
	if (!cops)
1191
		goto out;
1192
	if (!cops->tcf_block)
1193
		goto out;
L
Linus Torvalds 已提交
1194
	if (TC_H_MIN(tcm->tcm_parent)) {
1195
		cl = cops->find(q, tcm->tcm_parent);
L
Linus Torvalds 已提交
1196
		if (cl == 0)
1197
			goto out;
L
Linus Torvalds 已提交
1198
	}
1199
	block = cops->tcf_block(q, cl, NULL);
1200
	if (!block)
1201
		goto out;
L
Linus Torvalds 已提交
1202

1203 1204
	index_start = cb->args[0];
	index = 0;
1205 1206 1207 1208 1209

	list_for_each_entry(chain, &block->chain_list, list) {
		if (tca[TCA_CHAIN] &&
		    nla_get_u32(tca[TCA_CHAIN]) != chain->index)
			continue;
1210 1211
		if (!tcf_chain_dump(chain, q, parent, skb, cb,
				    index_start, &index))
1212 1213 1214
			break;
	}

1215
	cb->args[0] = index;
L
Linus Torvalds 已提交
1216 1217 1218 1219 1220

out:
	return skb->len;
}

1221
void tcf_exts_destroy(struct tcf_exts *exts)
L
Linus Torvalds 已提交
1222 1223
{
#ifdef CONFIG_NET_CLS_ACT
1224 1225
	LIST_HEAD(actions);

1226
	ASSERT_RTNL();
1227 1228 1229 1230
	tcf_exts_to_list(exts, &actions);
	tcf_action_destroy(&actions, TCA_ACT_UNBIND);
	kfree(exts->actions);
	exts->nr_actions = 0;
L
Linus Torvalds 已提交
1231 1232
#endif
}
1233
EXPORT_SYMBOL(tcf_exts_destroy);
L
Linus Torvalds 已提交
1234

1235
int tcf_exts_validate(struct net *net, struct tcf_proto *tp, struct nlattr **tb,
J
Jamal Hadi Salim 已提交
1236
		      struct nlattr *rate_tlv, struct tcf_exts *exts, bool ovr)
L
Linus Torvalds 已提交
1237 1238 1239 1240 1241
{
#ifdef CONFIG_NET_CLS_ACT
	{
		struct tc_action *act;

1242
		if (exts->police && tb[exts->police]) {
1243 1244 1245
			act = tcf_action_init_1(net, tp, tb[exts->police],
						rate_tlv, "police", ovr,
						TCA_ACT_BIND);
1246 1247
			if (IS_ERR(act))
				return PTR_ERR(act);
L
Linus Torvalds 已提交
1248

1249
			act->type = exts->type = TCA_OLD_COMPAT;
1250 1251
			exts->actions[0] = act;
			exts->nr_actions = 1;
1252
		} else if (exts->action && tb[exts->action]) {
1253 1254 1255
			LIST_HEAD(actions);
			int err, i = 0;

1256 1257
			err = tcf_action_init(net, tp, tb[exts->action],
					      rate_tlv, NULL, ovr, TCA_ACT_BIND,
J
Jamal Hadi Salim 已提交
1258
					      &actions);
1259 1260
			if (err)
				return err;
1261 1262 1263
			list_for_each_entry(act, &actions, list)
				exts->actions[i++] = act;
			exts->nr_actions = i;
L
Linus Torvalds 已提交
1264
		}
1265
		exts->net = net;
L
Linus Torvalds 已提交
1266 1267
	}
#else
1268 1269
	if ((exts->action && tb[exts->action]) ||
	    (exts->police && tb[exts->police]))
L
Linus Torvalds 已提交
1270 1271 1272 1273 1274
		return -EOPNOTSUPP;
#endif

	return 0;
}
1275
EXPORT_SYMBOL(tcf_exts_validate);
L
Linus Torvalds 已提交
1276

1277
void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src)
L
Linus Torvalds 已提交
1278 1279
{
#ifdef CONFIG_NET_CLS_ACT
1280 1281
	struct tcf_exts old = *dst;

1282
	*dst = *src;
1283
	tcf_exts_destroy(&old);
L
Linus Torvalds 已提交
1284 1285
#endif
}
1286
EXPORT_SYMBOL(tcf_exts_change);
L
Linus Torvalds 已提交
1287

1288 1289 1290 1291 1292 1293 1294 1295 1296
#ifdef CONFIG_NET_CLS_ACT
static struct tc_action *tcf_exts_first_act(struct tcf_exts *exts)
{
	if (exts->nr_actions == 0)
		return NULL;
	else
		return exts->actions[0];
}
#endif
1297

1298
int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts)
L
Linus Torvalds 已提交
1299 1300
{
#ifdef CONFIG_NET_CLS_ACT
1301 1302
	struct nlattr *nest;

1303
	if (exts->action && tcf_exts_has_actions(exts)) {
L
Linus Torvalds 已提交
1304 1305 1306 1307 1308
		/*
		 * again for backward compatible mode - we want
		 * to work with both old and new modes of entering
		 * tc data even if iproute2  was newer - jhs
		 */
1309
		if (exts->type != TCA_OLD_COMPAT) {
1310 1311
			LIST_HEAD(actions);

1312
			nest = nla_nest_start(skb, exts->action);
1313 1314
			if (nest == NULL)
				goto nla_put_failure;
1315 1316 1317

			tcf_exts_to_list(exts, &actions);
			if (tcf_action_dump(skb, &actions, 0, 0) < 0)
1318
				goto nla_put_failure;
1319
			nla_nest_end(skb, nest);
1320
		} else if (exts->police) {
1321
			struct tc_action *act = tcf_exts_first_act(exts);
1322
			nest = nla_nest_start(skb, exts->police);
1323
			if (nest == NULL || !act)
1324
				goto nla_put_failure;
1325
			if (tcf_action_dump_old(skb, act, 0, 0) < 0)
1326
				goto nla_put_failure;
1327
			nla_nest_end(skb, nest);
L
Linus Torvalds 已提交
1328 1329 1330
		}
	}
	return 0;
1331 1332 1333

nla_put_failure:
	nla_nest_cancel(skb, nest);
L
Linus Torvalds 已提交
1334
	return -1;
1335 1336 1337
#else
	return 0;
#endif
L
Linus Torvalds 已提交
1338
}
1339
EXPORT_SYMBOL(tcf_exts_dump);
L
Linus Torvalds 已提交
1340

1341

1342
int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts)
L
Linus Torvalds 已提交
1343 1344
{
#ifdef CONFIG_NET_CLS_ACT
1345
	struct tc_action *a = tcf_exts_first_act(exts);
1346
	if (a != NULL && tcf_action_copy_stats(skb, a, 1) < 0)
1347
		return -1;
L
Linus Torvalds 已提交
1348 1349 1350
#endif
	return 0;
}
1351
EXPORT_SYMBOL(tcf_exts_dump_stats);
L
Linus Torvalds 已提交
1352

1353 1354 1355
static int tc_exts_setup_cb_egdev_call(struct tcf_exts *exts,
				       enum tc_setup_type type,
				       void *type_data, bool err_stop)
1356 1357 1358 1359 1360
{
	int ok_count = 0;
#ifdef CONFIG_NET_CLS_ACT
	const struct tc_action *a;
	struct net_device *dev;
1361
	int i, ret;
1362 1363 1364 1365

	if (!tcf_exts_has_actions(exts))
		return 0;

1366 1367
	for (i = 0; i < exts->nr_actions; i++) {
		a = exts->actions[i];
1368 1369 1370
		if (!a->ops->get_dev)
			continue;
		dev = a->ops->get_dev(a);
1371
		if (!dev)
1372 1373 1374 1375 1376 1377 1378 1379 1380
			continue;
		ret = tc_setup_cb_egdev_call(dev, type, type_data, err_stop);
		if (ret < 0)
			return ret;
		ok_count += ret;
	}
#endif
	return ok_count;
}
1381

1382 1383
int tc_setup_cb_call(struct tcf_block *block, struct tcf_exts *exts,
		     enum tc_setup_type type, void *type_data, bool err_stop)
1384
{
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
	int ok_count;
	int ret;

	ret = tcf_block_cb_call(block, type, type_data, err_stop);
	if (ret < 0)
		return ret;
	ok_count = ret;

	if (!exts)
		return ok_count;
	ret = tc_exts_setup_cb_egdev_call(exts, type, type_data, err_stop);
	if (ret < 0)
		return ret;
	ok_count += ret;

	return ok_count;
1401 1402
}
EXPORT_SYMBOL(tc_setup_cb_call);
1403

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
static __net_init int tcf_net_init(struct net *net)
{
	struct tcf_net *tn = net_generic(net, tcf_net_id);

	idr_init(&tn->idr);
	return 0;
}

static void __net_exit tcf_net_exit(struct net *net)
{
	struct tcf_net *tn = net_generic(net, tcf_net_id);

	idr_destroy(&tn->idr);
}

static struct pernet_operations tcf_net_ops = {
	.init = tcf_net_init,
	.exit = tcf_net_exit,
	.id   = &tcf_net_id,
	.size = sizeof(struct tcf_net),
};

L
Linus Torvalds 已提交
1426 1427
static int __init tc_filter_init(void)
{
1428 1429
	int err;

1430 1431 1432 1433
	tc_filter_wq = alloc_ordered_workqueue("tc_filter_workqueue", 0);
	if (!tc_filter_wq)
		return -ENOMEM;

1434 1435 1436 1437
	err = register_pernet_subsys(&tcf_net_ops);
	if (err)
		goto err_register_pernet_subsys;

1438 1439
	rtnl_register(PF_UNSPEC, RTM_NEWTFILTER, tc_ctl_tfilter, NULL, 0);
	rtnl_register(PF_UNSPEC, RTM_DELTFILTER, tc_ctl_tfilter, NULL, 0);
1440
	rtnl_register(PF_UNSPEC, RTM_GETTFILTER, tc_ctl_tfilter,
1441
		      tc_dump_tfilter, 0);
L
Linus Torvalds 已提交
1442 1443

	return 0;
1444 1445 1446 1447

err_register_pernet_subsys:
	destroy_workqueue(tc_filter_wq);
	return err;
L
Linus Torvalds 已提交
1448 1449 1450
}

subsys_initcall(tc_filter_init);