sch_api.c 41.0 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 22 23 24 25 26 27 28
/*
 * net/sched/sch_api.c	Packet scheduler 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>
 *
 * Fixes:
 *
 * Rani Assaf <rani@magic.metawire.com> :980802: JIFFIES and CPU clock sources are repaired.
 * Eduardo J. Blanco <ejbs@netlabs.com.uy> :990222: kmod support
 * Jamal Hadi Salim <hadi@nortelnetworks.com>: 990601: ingress support
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/kmod.h>
#include <linux/list.h>
29
#include <linux/hrtimer.h>
30
#include <linux/lockdep.h>
31
#include <linux/slab.h>
L
Linus Torvalds 已提交
32

33
#include <net/net_namespace.h>
34
#include <net/sock.h>
35
#include <net/netlink.h>
L
Linus Torvalds 已提交
36 37
#include <net/pkt_sched.h>

38 39
static int qdisc_notify(struct net *net, struct sk_buff *oskb,
			struct nlmsghdr *n, u32 clid,
L
Linus Torvalds 已提交
40
			struct Qdisc *old, struct Qdisc *new);
41 42 43
static int tclass_notify(struct net *net, struct sk_buff *oskb,
			 struct nlmsghdr *n, struct Qdisc *q,
			 unsigned long cl, int event);
L
Linus Torvalds 已提交
44 45 46 47 48 49 50 51 52 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 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102

/*

   Short review.
   -------------

   This file consists of two interrelated parts:

   1. queueing disciplines manager frontend.
   2. traffic classes manager frontend.

   Generally, queueing discipline ("qdisc") is a black box,
   which is able to enqueue packets and to dequeue them (when
   device is ready to send something) in order and at times
   determined by algorithm hidden in it.

   qdisc's are divided to two categories:
   - "queues", which have no internal structure visible from outside.
   - "schedulers", which split all the packets to "traffic classes",
     using "packet classifiers" (look at cls_api.c)

   In turn, classes may have child qdiscs (as rule, queues)
   attached to them etc. etc. etc.

   The goal of the routines in this file is to translate
   information supplied by user in the form of handles
   to more intelligible for kernel form, to make some sanity
   checks and part of work, which is common to all qdiscs
   and to provide rtnetlink notifications.

   All real intelligent work is done inside qdisc modules.



   Every discipline has two major routines: enqueue and dequeue.

   ---dequeue

   dequeue usually returns a skb to send. It is allowed to return NULL,
   but it does not mean that queue is empty, it just means that
   discipline does not want to send anything this time.
   Queue is really empty if q->q.qlen == 0.
   For complicated disciplines with multiple queues q->q is not
   real packet queue, but however q->q.qlen must be valid.

   ---enqueue

   enqueue returns 0, if packet was enqueued successfully.
   If packet (this one or another one) was dropped, it returns
   not zero error code.
   NET_XMIT_DROP 	- this packet dropped
     Expected action: do not backoff, but wait until queue will clear.
   NET_XMIT_CN	 	- probably this packet enqueued, but another one dropped.
     Expected action: backoff or ignore
   NET_XMIT_POLICED	- dropped by police.
     Expected action: backoff or error to real-time apps.

   Auxiliary routines:

103 104 105 106
   ---peek

   like dequeue but without removing a packet from the queue

L
Linus Torvalds 已提交
107 108 109 110 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
   ---reset

   returns qdisc to initial state: purge all buffers, clear all
   timers, counters (except for statistics) etc.

   ---init

   initializes newly created qdisc.

   ---destroy

   destroys resources allocated by init and during lifetime of qdisc.

   ---change

   changes qdisc parameters.
 */

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


/************************************************
 *	Queueing disciplines manipulation.	*
 ************************************************/


/* The list of all installed queueing disciplines. */

static struct Qdisc_ops *qdisc_base;

/* Register/uregister queueing discipline */

int register_qdisc(struct Qdisc_ops *qops)
{
	struct Qdisc_ops *q, **qp;
	int rc = -EEXIST;

	write_lock(&qdisc_mod_lock);
	for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
		if (!strcmp(qops->id, q->id))
			goto out;

	if (qops->enqueue == NULL)
		qops->enqueue = noop_qdisc_ops.enqueue;
152
	if (qops->peek == NULL) {
153
		if (qops->dequeue == NULL)
154
			qops->peek = noop_qdisc_ops.peek;
155 156
		else
			goto out_einval;
157
	}
L
Linus Torvalds 已提交
158 159 160
	if (qops->dequeue == NULL)
		qops->dequeue = noop_qdisc_ops.dequeue;

161 162 163
	if (qops->cl_ops) {
		const struct Qdisc_class_ops *cops = qops->cl_ops;

164
		if (!(cops->get && cops->put && cops->walk && cops->leaf))
165 166 167 168 169 170
			goto out_einval;

		if (cops->tcf_chain && !(cops->bind_tcf && cops->unbind_tcf))
			goto out_einval;
	}

L
Linus Torvalds 已提交
171 172 173 174 175 176
	qops->next = NULL;
	*qp = qops;
	rc = 0;
out:
	write_unlock(&qdisc_mod_lock);
	return rc;
177 178 179 180

out_einval:
	rc = -EINVAL;
	goto out;
L
Linus Torvalds 已提交
181
}
182
EXPORT_SYMBOL(register_qdisc);
L
Linus Torvalds 已提交
183 184 185 186 187 188 189

int unregister_qdisc(struct Qdisc_ops *qops)
{
	struct Qdisc_ops *q, **qp;
	int err = -ENOENT;

	write_lock(&qdisc_mod_lock);
E
Eric Dumazet 已提交
190
	for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
L
Linus Torvalds 已提交
191 192 193 194 195 196 197 198 199 200
		if (q == qops)
			break;
	if (q) {
		*qp = q->next;
		q->next = NULL;
		err = 0;
	}
	write_unlock(&qdisc_mod_lock);
	return err;
}
201
EXPORT_SYMBOL(unregister_qdisc);
L
Linus Torvalds 已提交
202 203 204 205 206

/* We know handle. Find qdisc among all qdisc's attached to device
   (root qdisc, all its children, children of children etc.)
 */

H
Hannes Eder 已提交
207
static struct Qdisc *qdisc_match_from_root(struct Qdisc *root, u32 handle)
208 209 210 211 212 213 214 215 216 217 218 219 220 221
{
	struct Qdisc *q;

	if (!(root->flags & TCQ_F_BUILTIN) &&
	    root->handle == handle)
		return root;

	list_for_each_entry(q, &root->list, list) {
		if (q->handle == handle)
			return q;
	}
	return NULL;
}

222 223
static void qdisc_list_add(struct Qdisc *q)
{
224
	if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS))
225
		list_add_tail(&q->list, &qdisc_dev(q)->qdisc->list);
226 227 228 229
}

void qdisc_list_del(struct Qdisc *q)
{
230
	if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS))
231 232 233 234
		list_del(&q->list);
}
EXPORT_SYMBOL(qdisc_list_del);

235
struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle)
L
Linus Torvalds 已提交
236
{
237 238
	struct Qdisc *q;

239 240 241
	q = qdisc_match_from_root(dev->qdisc, handle);
	if (q)
		goto out;
242

243 244 245 246
	if (dev_ingress_queue(dev))
		q = qdisc_match_from_root(
			dev_ingress_queue(dev)->qdisc_sleeping,
			handle);
247
out:
248
	return q;
L
Linus Torvalds 已提交
249 250 251 252 253 254
}

static struct Qdisc *qdisc_leaf(struct Qdisc *p, u32 classid)
{
	unsigned long cl;
	struct Qdisc *leaf;
255
	const struct Qdisc_class_ops *cops = p->ops->cl_ops;
L
Linus Torvalds 已提交
256 257 258 259 260 261 262 263 264 265 266 267 268 269

	if (cops == NULL)
		return NULL;
	cl = cops->get(p, classid);

	if (cl == 0)
		return NULL;
	leaf = cops->leaf(p, cl);
	cops->put(p, cl);
	return leaf;
}

/* Find queueing discipline by name */

270
static struct Qdisc_ops *qdisc_lookup_ops(struct nlattr *kind)
L
Linus Torvalds 已提交
271 272 273 274 275 276
{
	struct Qdisc_ops *q = NULL;

	if (kind) {
		read_lock(&qdisc_mod_lock);
		for (q = qdisc_base; q; q = q->next) {
277
			if (nla_strcmp(kind, q->id) == 0) {
L
Linus Torvalds 已提交
278 279 280 281 282 283 284 285 286 287 288 289
				if (!try_module_get(q->owner))
					q = NULL;
				break;
			}
		}
		read_unlock(&qdisc_mod_lock);
	}
	return q;
}

static struct qdisc_rate_table *qdisc_rtab_list;

290
struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct nlattr *tab)
L
Linus Torvalds 已提交
291 292 293 294 295 296 297 298 299 300
{
	struct qdisc_rate_table *rtab;

	for (rtab = qdisc_rtab_list; rtab; rtab = rtab->next) {
		if (memcmp(&rtab->rate, r, sizeof(struct tc_ratespec)) == 0) {
			rtab->refcnt++;
			return rtab;
		}
	}

301 302
	if (tab == NULL || r->rate == 0 || r->cell_log == 0 ||
	    nla_len(tab) != TC_RTAB_SIZE)
L
Linus Torvalds 已提交
303 304 305 306 307 308
		return NULL;

	rtab = kmalloc(sizeof(*rtab), GFP_KERNEL);
	if (rtab) {
		rtab->rate = *r;
		rtab->refcnt = 1;
309
		memcpy(rtab->data, nla_data(tab), 1024);
L
Linus Torvalds 已提交
310 311 312 313 314
		rtab->next = qdisc_rtab_list;
		qdisc_rtab_list = rtab;
	}
	return rtab;
}
315
EXPORT_SYMBOL(qdisc_get_rtab);
L
Linus Torvalds 已提交
316 317 318 319 320 321 322 323

void qdisc_put_rtab(struct qdisc_rate_table *tab)
{
	struct qdisc_rate_table *rtab, **rtabp;

	if (!tab || --tab->refcnt)
		return;

E
Eric Dumazet 已提交
324 325 326
	for (rtabp = &qdisc_rtab_list;
	     (rtab = *rtabp) != NULL;
	     rtabp = &rtab->next) {
L
Linus Torvalds 已提交
327 328 329 330 331 332 333
		if (rtab == tab) {
			*rtabp = rtab->next;
			kfree(rtab);
			return;
		}
	}
}
334
EXPORT_SYMBOL(qdisc_put_rtab);
L
Linus Torvalds 已提交
335

336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
static LIST_HEAD(qdisc_stab_list);
static DEFINE_SPINLOCK(qdisc_stab_lock);

static const struct nla_policy stab_policy[TCA_STAB_MAX + 1] = {
	[TCA_STAB_BASE]	= { .len = sizeof(struct tc_sizespec) },
	[TCA_STAB_DATA] = { .type = NLA_BINARY },
};

static struct qdisc_size_table *qdisc_get_stab(struct nlattr *opt)
{
	struct nlattr *tb[TCA_STAB_MAX + 1];
	struct qdisc_size_table *stab;
	struct tc_sizespec *s;
	unsigned int tsize = 0;
	u16 *tab = NULL;
	int err;

	err = nla_parse_nested(tb, TCA_STAB_MAX, opt, stab_policy);
	if (err < 0)
		return ERR_PTR(err);
	if (!tb[TCA_STAB_BASE])
		return ERR_PTR(-EINVAL);

	s = nla_data(tb[TCA_STAB_BASE]);

	if (s->tsize > 0) {
		if (!tb[TCA_STAB_DATA])
			return ERR_PTR(-EINVAL);
		tab = nla_data(tb[TCA_STAB_DATA]);
		tsize = nla_len(tb[TCA_STAB_DATA]) / sizeof(u16);
	}

368
	if (tsize != s->tsize || (!tab && tsize > 0))
369 370
		return ERR_PTR(-EINVAL);

371
	spin_lock(&qdisc_stab_lock);
372 373 374 375 376 377 378

	list_for_each_entry(stab, &qdisc_stab_list, list) {
		if (memcmp(&stab->szopts, s, sizeof(*s)))
			continue;
		if (tsize > 0 && memcmp(stab->data, tab, tsize * sizeof(u16)))
			continue;
		stab->refcnt++;
379
		spin_unlock(&qdisc_stab_lock);
380 381 382
		return stab;
	}

383
	spin_unlock(&qdisc_stab_lock);
384 385 386 387 388 389 390 391 392 393

	stab = kmalloc(sizeof(*stab) + tsize * sizeof(u16), GFP_KERNEL);
	if (!stab)
		return ERR_PTR(-ENOMEM);

	stab->refcnt = 1;
	stab->szopts = *s;
	if (tsize > 0)
		memcpy(stab->data, tab, tsize * sizeof(u16));

394
	spin_lock(&qdisc_stab_lock);
395
	list_add_tail(&stab->list, &qdisc_stab_list);
396
	spin_unlock(&qdisc_stab_lock);
397 398 399 400

	return stab;
}

E
Eric Dumazet 已提交
401 402 403 404 405
static void stab_kfree_rcu(struct rcu_head *head)
{
	kfree(container_of(head, struct qdisc_size_table, rcu));
}

406 407 408 409 410
void qdisc_put_stab(struct qdisc_size_table *tab)
{
	if (!tab)
		return;

411
	spin_lock(&qdisc_stab_lock);
412 413 414

	if (--tab->refcnt == 0) {
		list_del(&tab->list);
E
Eric Dumazet 已提交
415
		call_rcu_bh(&tab->rcu, stab_kfree_rcu);
416 417
	}

418
	spin_unlock(&qdisc_stab_lock);
419 420 421 422 423 424 425 426
}
EXPORT_SYMBOL(qdisc_put_stab);

static int qdisc_dump_stab(struct sk_buff *skb, struct qdisc_size_table *stab)
{
	struct nlattr *nest;

	nest = nla_nest_start(skb, TCA_STAB);
427 428
	if (nest == NULL)
		goto nla_put_failure;
429 430 431 432 433 434 435 436 437
	NLA_PUT(skb, TCA_STAB_BASE, sizeof(stab->szopts), &stab->szopts);
	nla_nest_end(skb, nest);

	return skb->len;

nla_put_failure:
	return -1;
}

E
Eric Dumazet 已提交
438
void __qdisc_calculate_pkt_len(struct sk_buff *skb, const struct qdisc_size_table *stab)
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
{
	int pkt_len, slot;

	pkt_len = skb->len + stab->szopts.overhead;
	if (unlikely(!stab->szopts.tsize))
		goto out;

	slot = pkt_len + stab->szopts.cell_align;
	if (unlikely(slot < 0))
		slot = 0;

	slot >>= stab->szopts.cell_log;
	if (likely(slot < stab->szopts.tsize))
		pkt_len = stab->data[slot];
	else
		pkt_len = stab->data[stab->szopts.tsize - 1] *
				(slot / stab->szopts.tsize) +
				stab->data[slot % stab->szopts.tsize];

	pkt_len <<= stab->szopts.size_log;
out:
	if (unlikely(pkt_len < 1))
		pkt_len = 1;
	qdisc_skb_cb(skb)->pkt_len = pkt_len;
}
E
Eric Dumazet 已提交
464
EXPORT_SYMBOL(__qdisc_calculate_pkt_len);
465

466 467 468
void qdisc_warn_nonwc(char *txt, struct Qdisc *qdisc)
{
	if (!(qdisc->flags & TCQ_F_WARN_NONWC)) {
E
Eric Dumazet 已提交
469 470
		pr_warn("%s: %s qdisc %X: is non-work-conserving?\n",
			txt, qdisc->ops->id, qdisc->handle >> 16);
471 472 473 474 475
		qdisc->flags |= TCQ_F_WARN_NONWC;
	}
}
EXPORT_SYMBOL(qdisc_warn_nonwc);

476 477 478
static enum hrtimer_restart qdisc_watchdog(struct hrtimer *timer)
{
	struct qdisc_watchdog *wd = container_of(timer, struct qdisc_watchdog,
479
						 timer);
480

481
	qdisc_unthrottled(wd->qdisc);
482
	__netif_schedule(qdisc_root(wd->qdisc));
483

484 485 486 487 488
	return HRTIMER_NORESTART;
}

void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc)
{
489 490
	hrtimer_init(&wd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
	wd->timer.function = qdisc_watchdog;
491 492 493 494 495 496 497 498
	wd->qdisc = qdisc;
}
EXPORT_SYMBOL(qdisc_watchdog_init);

void qdisc_watchdog_schedule(struct qdisc_watchdog *wd, psched_time_t expires)
{
	ktime_t time;

499 500 501 502
	if (test_bit(__QDISC_STATE_DEACTIVATED,
		     &qdisc_root_sleeping(wd->qdisc)->state))
		return;

503
	qdisc_throttled(wd->qdisc);
504
	time = ktime_set(0, 0);
505
	time = ktime_add_ns(time, PSCHED_TICKS2NS(expires));
506
	hrtimer_start(&wd->timer, time, HRTIMER_MODE_ABS);
507 508 509 510 511
}
EXPORT_SYMBOL(qdisc_watchdog_schedule);

void qdisc_watchdog_cancel(struct qdisc_watchdog *wd)
{
512
	hrtimer_cancel(&wd->timer);
513
	qdisc_unthrottled(wd->qdisc);
514 515
}
EXPORT_SYMBOL(qdisc_watchdog_cancel);
L
Linus Torvalds 已提交
516

517
static struct hlist_head *qdisc_class_hash_alloc(unsigned int n)
518 519 520 521 522 523 524 525 526 527 528 529 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
{
	unsigned int size = n * sizeof(struct hlist_head), i;
	struct hlist_head *h;

	if (size <= PAGE_SIZE)
		h = kmalloc(size, GFP_KERNEL);
	else
		h = (struct hlist_head *)
			__get_free_pages(GFP_KERNEL, get_order(size));

	if (h != NULL) {
		for (i = 0; i < n; i++)
			INIT_HLIST_HEAD(&h[i]);
	}
	return h;
}

static void qdisc_class_hash_free(struct hlist_head *h, unsigned int n)
{
	unsigned int size = n * sizeof(struct hlist_head);

	if (size <= PAGE_SIZE)
		kfree(h);
	else
		free_pages((unsigned long)h, get_order(size));
}

void qdisc_class_hash_grow(struct Qdisc *sch, struct Qdisc_class_hash *clhash)
{
	struct Qdisc_class_common *cl;
	struct hlist_node *n, *next;
	struct hlist_head *nhash, *ohash;
	unsigned int nsize, nmask, osize;
	unsigned int i, h;

	/* Rehash when load factor exceeds 0.75 */
	if (clhash->hashelems * 4 <= clhash->hashsize * 3)
		return;
	nsize = clhash->hashsize * 2;
	nmask = nsize - 1;
	nhash = qdisc_class_hash_alloc(nsize);
	if (nhash == NULL)
		return;

	ohash = clhash->hash;
	osize = clhash->hashsize;

	sch_tree_lock(sch);
	for (i = 0; i < osize; i++) {
		hlist_for_each_entry_safe(cl, n, next, &ohash[i], hnode) {
			h = qdisc_class_hash(cl->classid, nmask);
			hlist_add_head(&cl->hnode, &nhash[h]);
		}
	}
	clhash->hash     = nhash;
	clhash->hashsize = nsize;
	clhash->hashmask = nmask;
	sch_tree_unlock(sch);

	qdisc_class_hash_free(ohash, osize);
}
EXPORT_SYMBOL(qdisc_class_hash_grow);

int qdisc_class_hash_init(struct Qdisc_class_hash *clhash)
{
	unsigned int size = 4;

	clhash->hash = qdisc_class_hash_alloc(size);
	if (clhash->hash == NULL)
		return -ENOMEM;
	clhash->hashsize  = size;
	clhash->hashmask  = size - 1;
	clhash->hashelems = 0;
	return 0;
}
EXPORT_SYMBOL(qdisc_class_hash_init);

void qdisc_class_hash_destroy(struct Qdisc_class_hash *clhash)
{
	qdisc_class_hash_free(clhash->hash, clhash->hashsize);
}
EXPORT_SYMBOL(qdisc_class_hash_destroy);

void qdisc_class_hash_insert(struct Qdisc_class_hash *clhash,
			     struct Qdisc_class_common *cl)
{
	unsigned int h;

	INIT_HLIST_NODE(&cl->hnode);
	h = qdisc_class_hash(cl->classid, clhash->hashmask);
	hlist_add_head(&cl->hnode, &clhash->hash[h]);
	clhash->hashelems++;
}
EXPORT_SYMBOL(qdisc_class_hash_insert);

void qdisc_class_hash_remove(struct Qdisc_class_hash *clhash,
			     struct Qdisc_class_common *cl)
{
	hlist_del(&cl->hnode);
	clhash->hashelems--;
}
EXPORT_SYMBOL(qdisc_class_hash_remove);

L
Linus Torvalds 已提交
621 622 623 624 625 626 627 628 629 630 631 632 633
/* Allocate an unique handle from space managed by kernel */

static u32 qdisc_alloc_handle(struct net_device *dev)
{
	int i = 0x10000;
	static u32 autohandle = TC_H_MAKE(0x80000000U, 0);

	do {
		autohandle += TC_H_MAKE(0x10000U, 0);
		if (autohandle == TC_H_MAKE(TC_H_ROOT, 0))
			autohandle = TC_H_MAKE(0x80000000U, 0);
	} while	(qdisc_lookup(dev, autohandle) && --i > 0);

E
Eric Dumazet 已提交
634
	return i > 0 ? autohandle : 0;
L
Linus Torvalds 已提交
635 636
}

637 638
void qdisc_tree_decrease_qlen(struct Qdisc *sch, unsigned int n)
{
639
	const struct Qdisc_class_ops *cops;
640 641 642 643 644 645
	unsigned long cl;
	u32 parentid;

	if (n == 0)
		return;
	while ((parentid = sch->parent)) {
646 647 648
		if (TC_H_MAJ(parentid) == TC_H_MAJ(TC_H_INGRESS))
			return;

649
		sch = qdisc_lookup(qdisc_dev(sch), TC_H_MAJ(parentid));
650 651 652 653
		if (sch == NULL) {
			WARN_ON(parentid != TC_H_ROOT);
			return;
		}
654 655 656 657 658 659 660 661 662 663
		cops = sch->ops->cl_ops;
		if (cops->qlen_notify) {
			cl = cops->get(sch, parentid);
			cops->qlen_notify(sch, cl);
			cops->put(sch, cl);
		}
		sch->q.qlen -= n;
	}
}
EXPORT_SYMBOL(qdisc_tree_decrease_qlen);
L
Linus Torvalds 已提交
664

665 666
static void notify_and_destroy(struct net *net, struct sk_buff *skb,
			       struct nlmsghdr *n, u32 clid,
667 668 669
			       struct Qdisc *old, struct Qdisc *new)
{
	if (new || old)
670
		qdisc_notify(net, skb, n, clid, old, new);
L
Linus Torvalds 已提交
671

672
	if (old)
673 674 675 676 677 678 679 680 681 682
		qdisc_destroy(old);
}

/* Graft qdisc "new" to class "classid" of qdisc "parent" or
 * to device "dev".
 *
 * When appropriate send a netlink notification using 'skb'
 * and "n".
 *
 * On success, destroy old qdisc.
L
Linus Torvalds 已提交
683 684 685
 */

static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
686 687
		       struct sk_buff *skb, struct nlmsghdr *n, u32 classid,
		       struct Qdisc *new, struct Qdisc *old)
L
Linus Torvalds 已提交
688
{
689
	struct Qdisc *q = old;
690
	struct net *net = dev_net(dev);
L
Linus Torvalds 已提交
691 692
	int err = 0;

693
	if (parent == NULL) {
694 695 696 697
		unsigned int i, num_q, ingress;

		ingress = 0;
		num_q = dev->num_tx_queues;
698 699
		if ((q && q->flags & TCQ_F_INGRESS) ||
		    (new && new->flags & TCQ_F_INGRESS)) {
700 701
			num_q = 1;
			ingress = 1;
702 703
			if (!dev_ingress_queue(dev))
				return -ENOENT;
704 705 706 707 708
		}

		if (dev->flags & IFF_UP)
			dev_deactivate(dev);

709 710 711 712 713
		if (new && new->ops->attach) {
			new->ops->attach(new);
			num_q = 0;
		}

714
		for (i = 0; i < num_q; i++) {
715
			struct netdev_queue *dev_queue = dev_ingress_queue(dev);
716 717 718 719

			if (!ingress)
				dev_queue = netdev_get_tx_queue(dev, i);

720 721 722 723
			old = dev_graft_qdisc(dev_queue, new);
			if (new && i > 0)
				atomic_inc(&new->refcnt);

724 725
			if (!ingress)
				qdisc_destroy(old);
L
Linus Torvalds 已提交
726
		}
727

728
		if (!ingress) {
729 730
			notify_and_destroy(net, skb, n, classid,
					   dev->qdisc, new);
731 732 733 734
			if (new && !new->ops->attach)
				atomic_inc(&new->refcnt);
			dev->qdisc = new ? : &noop_qdisc;
		} else {
735
			notify_and_destroy(net, skb, n, classid, old, new);
736
		}
737

738 739
		if (dev->flags & IFF_UP)
			dev_activate(dev);
L
Linus Torvalds 已提交
740
	} else {
741
		const struct Qdisc_class_ops *cops = parent->ops->cl_ops;
L
Linus Torvalds 已提交
742

743 744
		err = -EOPNOTSUPP;
		if (cops && cops->graft) {
L
Linus Torvalds 已提交
745 746
			unsigned long cl = cops->get(parent, classid);
			if (cl) {
747
				err = cops->graft(parent, cl, new, &old);
L
Linus Torvalds 已提交
748
				cops->put(parent, cl);
749 750
			} else
				err = -ENOENT;
L
Linus Torvalds 已提交
751
		}
752
		if (!err)
753
			notify_and_destroy(net, skb, n, classid, old, new);
L
Linus Torvalds 已提交
754 755 756 757
	}
	return err;
}

758 759 760 761
/* lockdep annotation is needed for ingress; egress gets it only for name */
static struct lock_class_key qdisc_tx_lock;
static struct lock_class_key qdisc_rx_lock;

L
Linus Torvalds 已提交
762 763 764 765 766 767 768
/*
   Allocate and initialize new qdisc.

   Parameters are passed via opt.
 */

static struct Qdisc *
769
qdisc_create(struct net_device *dev, struct netdev_queue *dev_queue,
770 771
	     struct Qdisc *p, u32 parent, u32 handle,
	     struct nlattr **tca, int *errp)
L
Linus Torvalds 已提交
772 773
{
	int err;
774
	struct nlattr *kind = tca[TCA_KIND];
L
Linus Torvalds 已提交
775 776
	struct Qdisc *sch;
	struct Qdisc_ops *ops;
777
	struct qdisc_size_table *stab;
L
Linus Torvalds 已提交
778 779

	ops = qdisc_lookup_ops(kind);
780
#ifdef CONFIG_MODULES
L
Linus Torvalds 已提交
781 782
	if (ops == NULL && kind != NULL) {
		char name[IFNAMSIZ];
783
		if (nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) {
L
Linus Torvalds 已提交
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807
			/* We dropped the RTNL semaphore in order to
			 * perform the module load.  So, even if we
			 * succeeded in loading the module we have to
			 * tell the caller to replay the request.  We
			 * indicate this using -EAGAIN.
			 * We replay the request because the device may
			 * go away in the mean time.
			 */
			rtnl_unlock();
			request_module("sch_%s", name);
			rtnl_lock();
			ops = qdisc_lookup_ops(kind);
			if (ops != NULL) {
				/* We will try again qdisc_lookup_ops,
				 * so don't keep a reference.
				 */
				module_put(ops->owner);
				err = -EAGAIN;
				goto err_out;
			}
		}
	}
#endif

808
	err = -ENOENT;
L
Linus Torvalds 已提交
809 810 811
	if (ops == NULL)
		goto err_out;

812
	sch = qdisc_alloc(dev_queue, ops);
813 814
	if (IS_ERR(sch)) {
		err = PTR_ERR(sch);
L
Linus Torvalds 已提交
815
		goto err_out2;
816
	}
L
Linus Torvalds 已提交
817

818 819
	sch->parent = parent;

820
	if (handle == TC_H_INGRESS) {
L
Linus Torvalds 已提交
821
		sch->flags |= TCQ_F_INGRESS;
822
		handle = TC_H_MAKE(TC_H_INGRESS, 0);
823
		lockdep_set_class(qdisc_lock(sch), &qdisc_rx_lock);
824 825 826 827 828 829 830
	} else {
		if (handle == 0) {
			handle = qdisc_alloc_handle(dev);
			err = -ENOMEM;
			if (handle == 0)
				goto err_out3;
		}
831
		lockdep_set_class(qdisc_lock(sch), &qdisc_tx_lock);
L
Linus Torvalds 已提交
832 833
	}

834
	sch->handle = handle;
L
Linus Torvalds 已提交
835

836
	if (!ops->init || (err = ops->init(sch, tca[TCA_OPTIONS])) == 0) {
837 838 839 840
		if (tca[TCA_STAB]) {
			stab = qdisc_get_stab(tca[TCA_STAB]);
			if (IS_ERR(stab)) {
				err = PTR_ERR(stab);
841
				goto err_out4;
842
			}
E
Eric Dumazet 已提交
843
			rcu_assign_pointer(sch->stab, stab);
844
		}
845
		if (tca[TCA_RATE]) {
846 847
			spinlock_t *root_lock;

848 849 850 851
			err = -EOPNOTSUPP;
			if (sch->flags & TCQ_F_MQROOT)
				goto err_out4;

852
			if ((sch->parent != TC_H_ROOT) &&
853 854
			    !(sch->flags & TCQ_F_INGRESS) &&
			    (!p || !(p->flags & TCQ_F_MQROOT)))
855 856 857 858
				root_lock = qdisc_root_sleeping_lock(sch);
			else
				root_lock = qdisc_lock(sch);

859
			err = gen_new_estimator(&sch->bstats, &sch->rate_est,
860
						root_lock, tca[TCA_RATE]);
861 862
			if (err)
				goto err_out4;
863
		}
864 865

		qdisc_list_add(sch);
L
Linus Torvalds 已提交
866 867 868 869 870

		return sch;
	}
err_out3:
	dev_put(dev);
871
	kfree((char *) sch - sch->padded);
L
Linus Torvalds 已提交
872 873 874 875 876
err_out2:
	module_put(ops->owner);
err_out:
	*errp = err;
	return NULL;
877 878 879 880 881 882

err_out4:
	/*
	 * Any broken qdiscs that would require a ops->reset() here?
	 * The qdisc was never in action so it shouldn't be necessary.
	 */
E
Eric Dumazet 已提交
883
	qdisc_put_stab(rtnl_dereference(sch->stab));
884 885 886
	if (ops->destroy)
		ops->destroy(sch);
	goto err_out3;
L
Linus Torvalds 已提交
887 888
}

889
static int qdisc_change(struct Qdisc *sch, struct nlattr **tca)
L
Linus Torvalds 已提交
890
{
E
Eric Dumazet 已提交
891
	struct qdisc_size_table *ostab, *stab = NULL;
892
	int err = 0;
L
Linus Torvalds 已提交
893

894
	if (tca[TCA_OPTIONS]) {
L
Linus Torvalds 已提交
895 896
		if (sch->ops->change == NULL)
			return -EINVAL;
897
		err = sch->ops->change(sch, tca[TCA_OPTIONS]);
L
Linus Torvalds 已提交
898 899 900
		if (err)
			return err;
	}
901 902 903 904 905 906 907

	if (tca[TCA_STAB]) {
		stab = qdisc_get_stab(tca[TCA_STAB]);
		if (IS_ERR(stab))
			return PTR_ERR(stab);
	}

E
Eric Dumazet 已提交
908 909 910
	ostab = rtnl_dereference(sch->stab);
	rcu_assign_pointer(sch->stab, stab);
	qdisc_put_stab(ostab);
911

912
	if (tca[TCA_RATE]) {
913 914
		/* NB: ignores errors from replace_estimator
		   because change can't be undone. */
915 916
		if (sch->flags & TCQ_F_MQROOT)
			goto out;
L
Linus Torvalds 已提交
917
		gen_replace_estimator(&sch->bstats, &sch->rate_est,
918 919
					    qdisc_root_sleeping_lock(sch),
					    tca[TCA_RATE]);
920 921
	}
out:
L
Linus Torvalds 已提交
922 923 924
	return 0;
}

E
Eric Dumazet 已提交
925 926
struct check_loop_arg {
	struct qdisc_walker	w;
L
Linus Torvalds 已提交
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
	struct Qdisc		*p;
	int			depth;
};

static int check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w);

static int check_loop(struct Qdisc *q, struct Qdisc *p, int depth)
{
	struct check_loop_arg	arg;

	if (q->ops->cl_ops == NULL)
		return 0;

	arg.w.stop = arg.w.skip = arg.w.count = 0;
	arg.w.fn = check_loop_fn;
	arg.depth = depth;
	arg.p = p;
	q->ops->cl_ops->walk(q, &arg.w);
	return arg.w.stop ? -ELOOP : 0;
}

static int
check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w)
{
	struct Qdisc *leaf;
952
	const struct Qdisc_class_ops *cops = q->ops->cl_ops;
L
Linus Torvalds 已提交
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
	struct check_loop_arg *arg = (struct check_loop_arg *)w;

	leaf = cops->leaf(q, cl);
	if (leaf) {
		if (leaf == arg->p || arg->depth > 7)
			return -ELOOP;
		return check_loop(leaf, arg->p, arg->depth + 1);
	}
	return 0;
}

/*
 * Delete/get qdisc.
 */

static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
{
970
	struct net *net = sock_net(skb->sk);
L
Linus Torvalds 已提交
971
	struct tcmsg *tcm = NLMSG_DATA(n);
972
	struct nlattr *tca[TCA_MAX + 1];
L
Linus Torvalds 已提交
973 974 975 976 977 978
	struct net_device *dev;
	u32 clid = tcm->tcm_parent;
	struct Qdisc *q = NULL;
	struct Qdisc *p = NULL;
	int err;

E
Eric Dumazet 已提交
979 980
	dev = __dev_get_by_index(net, tcm->tcm_ifindex);
	if (!dev)
L
Linus Torvalds 已提交
981 982
		return -ENODEV;

983 984 985 986
	err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
	if (err < 0)
		return err;

L
Linus Torvalds 已提交
987 988 989
	if (clid) {
		if (clid != TC_H_ROOT) {
			if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) {
E
Eric Dumazet 已提交
990 991
				p = qdisc_lookup(dev, TC_H_MAJ(clid));
				if (!p)
L
Linus Torvalds 已提交
992 993
					return -ENOENT;
				q = qdisc_leaf(p, clid);
E
Eric Dumazet 已提交
994 995
			} else if (dev_ingress_queue(dev)) {
				q = dev_ingress_queue(dev)->qdisc_sleeping;
996
			}
L
Linus Torvalds 已提交
997
		} else {
998
			q = dev->qdisc;
L
Linus Torvalds 已提交
999 1000 1001 1002 1003 1004 1005
		}
		if (!q)
			return -ENOENT;

		if (tcm->tcm_handle && q->handle != tcm->tcm_handle)
			return -EINVAL;
	} else {
E
Eric Dumazet 已提交
1006 1007
		q = qdisc_lookup(dev, tcm->tcm_handle);
		if (!q)
L
Linus Torvalds 已提交
1008 1009 1010
			return -ENOENT;
	}

1011
	if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
L
Linus Torvalds 已提交
1012 1013 1014 1015 1016 1017 1018
		return -EINVAL;

	if (n->nlmsg_type == RTM_DELQDISC) {
		if (!clid)
			return -EINVAL;
		if (q->handle == 0)
			return -ENOENT;
E
Eric Dumazet 已提交
1019 1020
		err = qdisc_graft(dev, p, skb, n, clid, NULL, q);
		if (err != 0)
L
Linus Torvalds 已提交
1021 1022
			return err;
	} else {
1023
		qdisc_notify(net, skb, n, clid, NULL, q);
L
Linus Torvalds 已提交
1024 1025 1026 1027 1028
	}
	return 0;
}

/*
E
Eric Dumazet 已提交
1029
 * Create/change qdisc.
L
Linus Torvalds 已提交
1030 1031 1032 1033
 */

static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
{
1034
	struct net *net = sock_net(skb->sk);
L
Linus Torvalds 已提交
1035
	struct tcmsg *tcm;
1036
	struct nlattr *tca[TCA_MAX + 1];
L
Linus Torvalds 已提交
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
	struct net_device *dev;
	u32 clid;
	struct Qdisc *q, *p;
	int err;

replay:
	/* Reinit, just in case something touches this. */
	tcm = NLMSG_DATA(n);
	clid = tcm->tcm_parent;
	q = p = NULL;

E
Eric Dumazet 已提交
1048 1049
	dev = __dev_get_by_index(net, tcm->tcm_ifindex);
	if (!dev)
L
Linus Torvalds 已提交
1050 1051
		return -ENODEV;

1052 1053 1054 1055
	err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
	if (err < 0)
		return err;

L
Linus Torvalds 已提交
1056 1057 1058
	if (clid) {
		if (clid != TC_H_ROOT) {
			if (clid != TC_H_INGRESS) {
E
Eric Dumazet 已提交
1059 1060
				p = qdisc_lookup(dev, TC_H_MAJ(clid));
				if (!p)
L
Linus Torvalds 已提交
1061 1062
					return -ENOENT;
				q = qdisc_leaf(p, clid);
E
Eric Dumazet 已提交
1063 1064
			} else if (dev_ingress_queue_create(dev)) {
				q = dev_ingress_queue(dev)->qdisc_sleeping;
L
Linus Torvalds 已提交
1065 1066
			}
		} else {
1067
			q = dev->qdisc;
L
Linus Torvalds 已提交
1068 1069 1070 1071 1072 1073 1074 1075
		}

		/* It may be default qdisc, ignore it */
		if (q && q->handle == 0)
			q = NULL;

		if (!q || !tcm->tcm_handle || q->handle != tcm->tcm_handle) {
			if (tcm->tcm_handle) {
E
Eric Dumazet 已提交
1076
				if (q && !(n->nlmsg_flags & NLM_F_REPLACE))
L
Linus Torvalds 已提交
1077 1078 1079
					return -EEXIST;
				if (TC_H_MIN(tcm->tcm_handle))
					return -EINVAL;
E
Eric Dumazet 已提交
1080 1081
				q = qdisc_lookup(dev, tcm->tcm_handle);
				if (!q)
L
Linus Torvalds 已提交
1082
					goto create_n_graft;
E
Eric Dumazet 已提交
1083
				if (n->nlmsg_flags & NLM_F_EXCL)
L
Linus Torvalds 已提交
1084
					return -EEXIST;
1085
				if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
L
Linus Torvalds 已提交
1086 1087 1088 1089 1090 1091 1092
					return -EINVAL;
				if (q == p ||
				    (p && check_loop(q, p, 0)))
					return -ELOOP;
				atomic_inc(&q->refcnt);
				goto graft;
			} else {
E
Eric Dumazet 已提交
1093
				if (!q)
L
Linus Torvalds 已提交
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
					goto create_n_graft;

				/* This magic test requires explanation.
				 *
				 *   We know, that some child q is already
				 *   attached to this parent and have choice:
				 *   either to change it or to create/graft new one.
				 *
				 *   1. We are allowed to create/graft only
				 *   if CREATE and REPLACE flags are set.
				 *
				 *   2. If EXCL is set, requestor wanted to say,
				 *   that qdisc tcm_handle is not expected
				 *   to exist, so that we choose create/graft too.
				 *
				 *   3. The last case is when no flags are set.
				 *   Alas, it is sort of hole in API, we
				 *   cannot decide what to do unambiguously.
				 *   For now we select create/graft, if
				 *   user gave KIND, which does not match existing.
				 */
E
Eric Dumazet 已提交
1115 1116 1117
				if ((n->nlmsg_flags & NLM_F_CREATE) &&
				    (n->nlmsg_flags & NLM_F_REPLACE) &&
				    ((n->nlmsg_flags & NLM_F_EXCL) ||
1118 1119
				     (tca[TCA_KIND] &&
				      nla_strcmp(tca[TCA_KIND], q->ops->id))))
L
Linus Torvalds 已提交
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
					goto create_n_graft;
			}
		}
	} else {
		if (!tcm->tcm_handle)
			return -EINVAL;
		q = qdisc_lookup(dev, tcm->tcm_handle);
	}

	/* Change qdisc parameters */
	if (q == NULL)
		return -ENOENT;
E
Eric Dumazet 已提交
1132
	if (n->nlmsg_flags & NLM_F_EXCL)
L
Linus Torvalds 已提交
1133
		return -EEXIST;
1134
	if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
L
Linus Torvalds 已提交
1135 1136 1137
		return -EINVAL;
	err = qdisc_change(q, tca);
	if (err == 0)
1138
		qdisc_notify(net, skb, n, clid, NULL, q);
L
Linus Torvalds 已提交
1139 1140 1141
	return err;

create_n_graft:
E
Eric Dumazet 已提交
1142
	if (!(n->nlmsg_flags & NLM_F_CREATE))
L
Linus Torvalds 已提交
1143
		return -ENOENT;
1144 1145 1146 1147 1148 1149 1150 1151
	if (clid == TC_H_INGRESS) {
		if (dev_ingress_queue(dev))
			q = qdisc_create(dev, dev_ingress_queue(dev), p,
					 tcm->tcm_parent, tcm->tcm_parent,
					 tca, &err);
		else
			err = -ENOENT;
	} else {
1152
		struct netdev_queue *dev_queue;
1153 1154

		if (p && p->ops->cl_ops && p->ops->cl_ops->select_queue)
1155 1156 1157 1158 1159
			dev_queue = p->ops->cl_ops->select_queue(p, tcm);
		else if (p)
			dev_queue = p->dev_queue;
		else
			dev_queue = netdev_get_tx_queue(dev, 0);
1160

1161
		q = qdisc_create(dev, dev_queue, p,
1162
				 tcm->tcm_parent, tcm->tcm_handle,
1163
				 tca, &err);
1164
	}
L
Linus Torvalds 已提交
1165 1166 1167 1168 1169 1170 1171
	if (q == NULL) {
		if (err == -EAGAIN)
			goto replay;
		return err;
	}

graft:
1172 1173 1174 1175 1176
	err = qdisc_graft(dev, p, skb, n, clid, q, NULL);
	if (err) {
		if (q)
			qdisc_destroy(q);
		return err;
L
Linus Torvalds 已提交
1177
	}
1178

L
Linus Torvalds 已提交
1179 1180 1181 1182
	return 0;
}

static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,
J
Jamal Hadi Salim 已提交
1183
			 u32 pid, u32 seq, u16 flags, int event)
L
Linus Torvalds 已提交
1184 1185 1186
{
	struct tcmsg *tcm;
	struct nlmsghdr  *nlh;
1187
	unsigned char *b = skb_tail_pointer(skb);
L
Linus Torvalds 已提交
1188
	struct gnet_dump d;
E
Eric Dumazet 已提交
1189
	struct qdisc_size_table *stab;
L
Linus Torvalds 已提交
1190

J
Jamal Hadi Salim 已提交
1191
	nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags);
L
Linus Torvalds 已提交
1192 1193
	tcm = NLMSG_DATA(nlh);
	tcm->tcm_family = AF_UNSPEC;
1194 1195
	tcm->tcm__pad1 = 0;
	tcm->tcm__pad2 = 0;
1196
	tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
L
Linus Torvalds 已提交
1197 1198 1199
	tcm->tcm_parent = clid;
	tcm->tcm_handle = q->handle;
	tcm->tcm_info = atomic_read(&q->refcnt);
1200
	NLA_PUT_STRING(skb, TCA_KIND, q->ops->id);
L
Linus Torvalds 已提交
1201
	if (q->ops->dump && q->ops->dump(q, skb) < 0)
1202
		goto nla_put_failure;
L
Linus Torvalds 已提交
1203 1204
	q->qstats.qlen = q->q.qlen;

E
Eric Dumazet 已提交
1205 1206
	stab = rtnl_dereference(q->stab);
	if (stab && qdisc_dump_stab(skb, stab) < 0)
1207 1208
		goto nla_put_failure;

1209 1210
	if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
					 qdisc_root_sleeping_lock(q), &d) < 0)
1211
		goto nla_put_failure;
L
Linus Torvalds 已提交
1212 1213

	if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)
1214
		goto nla_put_failure;
L
Linus Torvalds 已提交
1215 1216

	if (gnet_stats_copy_basic(&d, &q->bstats) < 0 ||
1217
	    gnet_stats_copy_rate_est(&d, &q->bstats, &q->rate_est) < 0 ||
L
Linus Torvalds 已提交
1218
	    gnet_stats_copy_queue(&d, &q->qstats) < 0)
1219
		goto nla_put_failure;
1220

L
Linus Torvalds 已提交
1221
	if (gnet_stats_finish_copy(&d) < 0)
1222
		goto nla_put_failure;
1223

1224
	nlh->nlmsg_len = skb_tail_pointer(skb) - b;
L
Linus Torvalds 已提交
1225 1226 1227
	return skb->len;

nlmsg_failure:
1228
nla_put_failure:
1229
	nlmsg_trim(skb, b);
L
Linus Torvalds 已提交
1230 1231 1232
	return -1;
}

E
Eric Dumazet 已提交
1233 1234 1235 1236 1237
static bool tc_qdisc_dump_ignore(struct Qdisc *q)
{
	return (q->flags & TCQ_F_BUILTIN) ? true : false;
}

1238 1239 1240
static int qdisc_notify(struct net *net, struct sk_buff *oskb,
			struct nlmsghdr *n, u32 clid,
			struct Qdisc *old, struct Qdisc *new)
L
Linus Torvalds 已提交
1241 1242 1243 1244 1245 1246 1247 1248
{
	struct sk_buff *skb;
	u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;

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

E
Eric Dumazet 已提交
1249
	if (old && !tc_qdisc_dump_ignore(old)) {
E
Eric Dumazet 已提交
1250 1251
		if (tc_fill_qdisc(skb, old, clid, pid, n->nlmsg_seq,
				  0, RTM_DELQDISC) < 0)
L
Linus Torvalds 已提交
1252 1253
			goto err_out;
	}
E
Eric Dumazet 已提交
1254
	if (new && !tc_qdisc_dump_ignore(new)) {
E
Eric Dumazet 已提交
1255 1256
		if (tc_fill_qdisc(skb, new, clid, pid, n->nlmsg_seq,
				  old ? NLM_F_REPLACE : 0, RTM_NEWQDISC) < 0)
L
Linus Torvalds 已提交
1257 1258 1259 1260
			goto err_out;
	}

	if (skb->len)
E
Eric Dumazet 已提交
1261 1262
		return rtnetlink_send(skb, net, pid, RTNLGRP_TC,
				      n->nlmsg_flags & NLM_F_ECHO);
L
Linus Torvalds 已提交
1263 1264 1265 1266 1267 1268

err_out:
	kfree_skb(skb);
	return -EINVAL;
}

1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
static int tc_dump_qdisc_root(struct Qdisc *root, struct sk_buff *skb,
			      struct netlink_callback *cb,
			      int *q_idx_p, int s_q_idx)
{
	int ret = 0, q_idx = *q_idx_p;
	struct Qdisc *q;

	if (!root)
		return 0;

	q = root;
	if (q_idx < s_q_idx) {
		q_idx++;
	} else {
		if (!tc_qdisc_dump_ignore(q) &&
		    tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).pid,
				  cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0)
			goto done;
		q_idx++;
	}
	list_for_each_entry(q, &root->list, list) {
		if (q_idx < s_q_idx) {
			q_idx++;
			continue;
		}
E
Eric Dumazet 已提交
1294
		if (!tc_qdisc_dump_ignore(q) &&
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
		    tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).pid,
				  cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0)
			goto done;
		q_idx++;
	}

out:
	*q_idx_p = q_idx;
	return ret;
done:
	ret = -1;
	goto out;
}

L
Linus Torvalds 已提交
1309 1310
static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
{
1311
	struct net *net = sock_net(skb->sk);
L
Linus Torvalds 已提交
1312 1313 1314 1315 1316 1317
	int idx, q_idx;
	int s_idx, s_q_idx;
	struct net_device *dev;

	s_idx = cb->args[0];
	s_q_idx = q_idx = cb->args[1];
1318 1319

	rcu_read_lock();
1320
	idx = 0;
1321
	for_each_netdev_rcu(net, dev) {
1322 1323
		struct netdev_queue *dev_queue;

L
Linus Torvalds 已提交
1324
		if (idx < s_idx)
1325
			goto cont;
L
Linus Torvalds 已提交
1326 1327 1328
		if (idx > s_idx)
			s_q_idx = 0;
		q_idx = 0;
1329

1330
		if (tc_dump_qdisc_root(dev->qdisc, skb, cb, &q_idx, s_q_idx) < 0)
1331 1332
			goto done;

1333 1334 1335 1336
		dev_queue = dev_ingress_queue(dev);
		if (dev_queue &&
		    tc_dump_qdisc_root(dev_queue->qdisc_sleeping, skb, cb,
				       &q_idx, s_q_idx) < 0)
1337 1338
			goto done;

1339 1340
cont:
		idx++;
L
Linus Torvalds 已提交
1341 1342 1343
	}

done:
1344
	rcu_read_unlock();
L
Linus Torvalds 已提交
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361

	cb->args[0] = idx;
	cb->args[1] = q_idx;

	return skb->len;
}



/************************************************
 *	Traffic classes manipulation.		*
 ************************************************/



static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
{
1362
	struct net *net = sock_net(skb->sk);
L
Linus Torvalds 已提交
1363
	struct tcmsg *tcm = NLMSG_DATA(n);
1364
	struct nlattr *tca[TCA_MAX + 1];
L
Linus Torvalds 已提交
1365 1366
	struct net_device *dev;
	struct Qdisc *q = NULL;
1367
	const struct Qdisc_class_ops *cops;
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373 1374
	unsigned long cl = 0;
	unsigned long new_cl;
	u32 pid = tcm->tcm_parent;
	u32 clid = tcm->tcm_handle;
	u32 qid = TC_H_MAJ(clid);
	int err;

E
Eric Dumazet 已提交
1375 1376
	dev = __dev_get_by_index(net, tcm->tcm_ifindex);
	if (!dev)
L
Linus Torvalds 已提交
1377 1378
		return -ENODEV;

1379 1380 1381 1382
	err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
	if (err < 0)
		return err;

L
Linus Torvalds 已提交
1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
	/*
	   parent == TC_H_UNSPEC - unspecified parent.
	   parent == TC_H_ROOT   - class is root, which has no parent.
	   parent == X:0	 - parent is root class.
	   parent == X:Y	 - parent is a node in hierarchy.
	   parent == 0:Y	 - parent is X:Y, where X:0 is qdisc.

	   handle == 0:0	 - generate handle from kernel pool.
	   handle == 0:Y	 - class is X:Y, where X:0 is qdisc.
	   handle == X:Y	 - clear.
	   handle == X:0	 - root class.
	 */

	/* Step 1. Determine qdisc handle X:0 */

	if (pid != TC_H_ROOT) {
		u32 qid1 = TC_H_MAJ(pid);

		if (qid && qid1) {
			/* If both majors are known, they must be identical. */
			if (qid != qid1)
				return -EINVAL;
		} else if (qid1) {
			qid = qid1;
		} else if (qid == 0)
1408
			qid = dev->qdisc->handle;
L
Linus Torvalds 已提交
1409 1410

		/* Now qid is genuine qdisc handle consistent
E
Eric Dumazet 已提交
1411 1412 1413
		 * both with parent and child.
		 *
		 * TC_H_MAJ(pid) still may be unspecified, complete it now.
L
Linus Torvalds 已提交
1414 1415 1416 1417 1418
		 */
		if (pid)
			pid = TC_H_MAKE(qid, pid);
	} else {
		if (qid == 0)
1419
			qid = dev->qdisc->handle;
L
Linus Torvalds 已提交
1420 1421 1422
	}

	/* OK. Locate qdisc */
E
Eric Dumazet 已提交
1423 1424
	q = qdisc_lookup(dev, qid);
	if (!q)
L
Linus Torvalds 已提交
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443
		return -ENOENT;

	/* An check that it supports classes */
	cops = q->ops->cl_ops;
	if (cops == NULL)
		return -EINVAL;

	/* Now try to get class */
	if (clid == 0) {
		if (pid == TC_H_ROOT)
			clid = qid;
	} else
		clid = TC_H_MAKE(qid, clid);

	if (clid)
		cl = cops->get(q, clid);

	if (cl == 0) {
		err = -ENOENT;
E
Eric Dumazet 已提交
1444 1445
		if (n->nlmsg_type != RTM_NEWTCLASS ||
		    !(n->nlmsg_flags & NLM_F_CREATE))
L
Linus Torvalds 已提交
1446 1447 1448
			goto out;
	} else {
		switch (n->nlmsg_type) {
1449
		case RTM_NEWTCLASS:
L
Linus Torvalds 已提交
1450
			err = -EEXIST;
E
Eric Dumazet 已提交
1451
			if (n->nlmsg_flags & NLM_F_EXCL)
L
Linus Torvalds 已提交
1452 1453 1454
				goto out;
			break;
		case RTM_DELTCLASS:
1455 1456 1457
			err = -EOPNOTSUPP;
			if (cops->delete)
				err = cops->delete(q, cl);
L
Linus Torvalds 已提交
1458
			if (err == 0)
1459
				tclass_notify(net, skb, n, q, cl, RTM_DELTCLASS);
L
Linus Torvalds 已提交
1460 1461
			goto out;
		case RTM_GETTCLASS:
1462
			err = tclass_notify(net, skb, n, q, cl, RTM_NEWTCLASS);
L
Linus Torvalds 已提交
1463 1464 1465 1466 1467 1468 1469 1470
			goto out;
		default:
			err = -EINVAL;
			goto out;
		}
	}

	new_cl = cl;
1471 1472 1473
	err = -EOPNOTSUPP;
	if (cops->change)
		err = cops->change(q, clid, pid, tca, &new_cl);
L
Linus Torvalds 已提交
1474
	if (err == 0)
1475
		tclass_notify(net, skb, n, q, new_cl, RTM_NEWTCLASS);
L
Linus Torvalds 已提交
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486

out:
	if (cl)
		cops->put(q, cl);

	return err;
}


static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,
			  unsigned long cl,
J
Jamal Hadi Salim 已提交
1487
			  u32 pid, u32 seq, u16 flags, int event)
L
Linus Torvalds 已提交
1488 1489 1490
{
	struct tcmsg *tcm;
	struct nlmsghdr  *nlh;
1491
	unsigned char *b = skb_tail_pointer(skb);
L
Linus Torvalds 已提交
1492
	struct gnet_dump d;
1493
	const struct Qdisc_class_ops *cl_ops = q->ops->cl_ops;
L
Linus Torvalds 已提交
1494

J
Jamal Hadi Salim 已提交
1495
	nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags);
L
Linus Torvalds 已提交
1496 1497
	tcm = NLMSG_DATA(nlh);
	tcm->tcm_family = AF_UNSPEC;
1498 1499
	tcm->tcm__pad1 = 0;
	tcm->tcm__pad2 = 0;
1500
	tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
L
Linus Torvalds 已提交
1501 1502 1503
	tcm->tcm_parent = q->handle;
	tcm->tcm_handle = q->handle;
	tcm->tcm_info = 0;
1504
	NLA_PUT_STRING(skb, TCA_KIND, q->ops->id);
L
Linus Torvalds 已提交
1505
	if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)
1506
		goto nla_put_failure;
L
Linus Torvalds 已提交
1507

1508 1509
	if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
					 qdisc_root_sleeping_lock(q), &d) < 0)
1510
		goto nla_put_failure;
L
Linus Torvalds 已提交
1511 1512

	if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)
1513
		goto nla_put_failure;
L
Linus Torvalds 已提交
1514 1515

	if (gnet_stats_finish_copy(&d) < 0)
1516
		goto nla_put_failure;
L
Linus Torvalds 已提交
1517

1518
	nlh->nlmsg_len = skb_tail_pointer(skb) - b;
L
Linus Torvalds 已提交
1519 1520 1521
	return skb->len;

nlmsg_failure:
1522
nla_put_failure:
1523
	nlmsg_trim(skb, b);
L
Linus Torvalds 已提交
1524 1525 1526
	return -1;
}

1527 1528 1529
static int tclass_notify(struct net *net, struct sk_buff *oskb,
			 struct nlmsghdr *n, struct Qdisc *q,
			 unsigned long cl, int event)
L
Linus Torvalds 已提交
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
{
	struct sk_buff *skb;
	u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;

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

	if (tc_fill_tclass(skb, q, cl, pid, n->nlmsg_seq, 0, event) < 0) {
		kfree_skb(skb);
		return -EINVAL;
	}

E
Eric Dumazet 已提交
1543 1544
	return rtnetlink_send(skb, net, pid, RTNLGRP_TC,
			      n->nlmsg_flags & NLM_F_ECHO);
L
Linus Torvalds 已提交
1545 1546
}

E
Eric Dumazet 已提交
1547 1548 1549 1550
struct qdisc_dump_args {
	struct qdisc_walker	w;
	struct sk_buff		*skb;
	struct netlink_callback	*cb;
L
Linus Torvalds 已提交
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
};

static int qdisc_class_dump(struct Qdisc *q, unsigned long cl, struct qdisc_walker *arg)
{
	struct qdisc_dump_args *a = (struct qdisc_dump_args *)arg;

	return tc_fill_tclass(a->skb, q, cl, NETLINK_CB(a->cb->skb).pid,
			      a->cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWTCLASS);
}

1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
static int tc_dump_tclass_qdisc(struct Qdisc *q, struct sk_buff *skb,
				struct tcmsg *tcm, struct netlink_callback *cb,
				int *t_p, int s_t)
{
	struct qdisc_dump_args arg;

	if (tc_qdisc_dump_ignore(q) ||
	    *t_p < s_t || !q->ops->cl_ops ||
	    (tcm->tcm_parent &&
	     TC_H_MAJ(tcm->tcm_parent) != q->handle)) {
		(*t_p)++;
		return 0;
	}
	if (*t_p > s_t)
		memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
	arg.w.fn = qdisc_class_dump;
	arg.skb = skb;
	arg.cb = cb;
	arg.w.stop  = 0;
	arg.w.skip = cb->args[1];
	arg.w.count = 0;
	q->ops->cl_ops->walk(q, &arg.w);
	cb->args[1] = arg.w.count;
	if (arg.w.stop)
		return -1;
	(*t_p)++;
	return 0;
}

static int tc_dump_tclass_root(struct Qdisc *root, struct sk_buff *skb,
			       struct tcmsg *tcm, struct netlink_callback *cb,
			       int *t_p, int s_t)
{
	struct Qdisc *q;

	if (!root)
		return 0;

	if (tc_dump_tclass_qdisc(root, skb, tcm, cb, t_p, s_t) < 0)
		return -1;

	list_for_each_entry(q, &root->list, list) {
		if (tc_dump_tclass_qdisc(q, skb, tcm, cb, t_p, s_t) < 0)
			return -1;
	}

	return 0;
}

L
Linus Torvalds 已提交
1610 1611
static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
{
E
Eric Dumazet 已提交
1612
	struct tcmsg *tcm = (struct tcmsg *)NLMSG_DATA(cb->nlh);
1613
	struct net *net = sock_net(skb->sk);
1614
	struct netdev_queue *dev_queue;
L
Linus Torvalds 已提交
1615
	struct net_device *dev;
1616
	int t, s_t;
L
Linus Torvalds 已提交
1617 1618 1619

	if (cb->nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*tcm)))
		return 0;
E
Eric Dumazet 已提交
1620 1621
	dev = dev_get_by_index(net, tcm->tcm_ifindex);
	if (!dev)
L
Linus Torvalds 已提交
1622 1623 1624 1625 1626
		return 0;

	s_t = cb->args[0];
	t = 0;

1627
	if (tc_dump_tclass_root(dev->qdisc, skb, tcm, cb, &t, s_t) < 0)
1628 1629
		goto done;

1630 1631 1632 1633
	dev_queue = dev_ingress_queue(dev);
	if (dev_queue &&
	    tc_dump_tclass_root(dev_queue->qdisc_sleeping, skb, tcm, cb,
				&t, s_t) < 0)
1634
		goto done;
L
Linus Torvalds 已提交
1635

1636
done:
L
Linus Torvalds 已提交
1637 1638 1639 1640 1641 1642 1643
	cb->args[0] = t;

	dev_put(dev);
	return skb->len;
}

/* Main classifier routine: scans classifier chain attached
E
Eric Dumazet 已提交
1644 1645
 * to this qdisc, (optionally) tests for protocol and asks
 * specific classifiers.
L
Linus Torvalds 已提交
1646
 */
1647
int tc_classify_compat(struct sk_buff *skb, const struct tcf_proto *tp,
1648 1649 1650
		       struct tcf_result *res)
{
	__be16 protocol = skb->protocol;
E
Eric Dumazet 已提交
1651
	int err;
1652 1653

	for (; tp; tp = tp->next) {
E
Eric Dumazet 已提交
1654 1655 1656 1657 1658 1659
		if (tp->protocol != protocol &&
		    tp->protocol != htons(ETH_P_ALL))
			continue;
		err = tp->classify(skb, tp, res);

		if (err >= 0) {
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
#ifdef CONFIG_NET_CLS_ACT
			if (err != TC_ACT_RECLASSIFY && skb->tc_verd)
				skb->tc_verd = SET_TC_VERD(skb->tc_verd, 0);
#endif
			return err;
		}
	}
	return -1;
}
EXPORT_SYMBOL(tc_classify_compat);

1671
int tc_classify(struct sk_buff *skb, const struct tcf_proto *tp,
1672
		struct tcf_result *res)
L
Linus Torvalds 已提交
1673 1674 1675
{
	int err = 0;
#ifdef CONFIG_NET_CLS_ACT
1676
	const struct tcf_proto *otp = tp;
L
Linus Torvalds 已提交
1677
reclassify:
1678
#endif
L
Linus Torvalds 已提交
1679

1680
	err = tc_classify_compat(skb, tp, res);
L
Linus Torvalds 已提交
1681
#ifdef CONFIG_NET_CLS_ACT
1682 1683 1684 1685 1686
	if (err == TC_ACT_RECLASSIFY) {
		u32 verd = G_TC_VERD(skb->tc_verd);
		tp = otp;

		if (verd++ >= MAX_REC_LOOP) {
1687
			if (net_ratelimit())
E
Eric Dumazet 已提交
1688
				pr_notice("%s: packet reclassify loop"
1689
					  " rule prio %u protocol %02x\n",
E
Eric Dumazet 已提交
1690 1691 1692
					  tp->q->ops->id,
					  tp->prio & 0xffff,
					  ntohs(tp->protocol));
1693
			return TC_ACT_SHOT;
L
Linus Torvalds 已提交
1694
		}
1695 1696
		skb->tc_verd = SET_TC_VERD(skb->tc_verd, verd);
		goto reclassify;
L
Linus Torvalds 已提交
1697
	}
1698 1699
#endif
	return err;
L
Linus Torvalds 已提交
1700
}
1701
EXPORT_SYMBOL(tc_classify);
L
Linus Torvalds 已提交
1702

1703 1704 1705 1706 1707 1708 1709
void tcf_destroy(struct tcf_proto *tp)
{
	tp->ops->destroy(tp);
	module_put(tp->ops->owner);
	kfree(tp);
}

1710
void tcf_destroy_chain(struct tcf_proto **fl)
1711 1712 1713
{
	struct tcf_proto *tp;

1714 1715
	while ((tp = *fl) != NULL) {
		*fl = tp->next;
1716 1717 1718 1719 1720
		tcf_destroy(tp);
	}
}
EXPORT_SYMBOL(tcf_destroy_chain);

L
Linus Torvalds 已提交
1721 1722 1723
#ifdef CONFIG_PROC_FS
static int psched_show(struct seq_file *seq, void *v)
{
1724 1725 1726
	struct timespec ts;

	hrtimer_get_res(CLOCK_MONOTONIC, &ts);
L
Linus Torvalds 已提交
1727
	seq_printf(seq, "%08x %08x %08x %08x\n",
1728
		   (u32)NSEC_PER_USEC, (u32)PSCHED_TICKS2NS(1),
P
Patrick McHardy 已提交
1729
		   1000000,
1730
		   (u32)NSEC_PER_SEC/(u32)ktime_to_ns(timespec_to_ktime(ts)));
L
Linus Torvalds 已提交
1731 1732 1733 1734 1735 1736

	return 0;
}

static int psched_open(struct inode *inode, struct file *file)
{
1737
	return single_open(file, psched_show, NULL);
L
Linus Torvalds 已提交
1738 1739
}

1740
static const struct file_operations psched_fops = {
L
Linus Torvalds 已提交
1741 1742 1743 1744 1745
	.owner = THIS_MODULE,
	.open = psched_open,
	.read  = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
1746
};
1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771

static int __net_init psched_net_init(struct net *net)
{
	struct proc_dir_entry *e;

	e = proc_net_fops_create(net, "psched", 0, &psched_fops);
	if (e == NULL)
		return -ENOMEM;

	return 0;
}

static void __net_exit psched_net_exit(struct net *net)
{
	proc_net_remove(net, "psched");
}
#else
static int __net_init psched_net_init(struct net *net)
{
	return 0;
}

static void __net_exit psched_net_exit(struct net *net)
{
}
L
Linus Torvalds 已提交
1772 1773
#endif

1774 1775 1776 1777 1778
static struct pernet_operations psched_net_ops = {
	.init = psched_net_init,
	.exit = psched_net_exit,
};

L
Linus Torvalds 已提交
1779 1780
static int __init pktsched_init(void)
{
1781 1782 1783 1784
	int err;

	err = register_pernet_subsys(&psched_net_ops);
	if (err) {
E
Eric Dumazet 已提交
1785
		pr_err("pktsched_init: "
1786 1787 1788 1789
		       "cannot initialize per netns operations\n");
		return err;
	}

L
Linus Torvalds 已提交
1790 1791
	register_qdisc(&pfifo_qdisc_ops);
	register_qdisc(&bfifo_qdisc_ops);
1792
	register_qdisc(&pfifo_head_drop_qdisc_ops);
1793
	register_qdisc(&mq_qdisc_ops);
L
Linus Torvalds 已提交
1794

1795 1796 1797 1798 1799 1800
	rtnl_register(PF_UNSPEC, RTM_NEWQDISC, tc_modify_qdisc, NULL, NULL);
	rtnl_register(PF_UNSPEC, RTM_DELQDISC, tc_get_qdisc, NULL, NULL);
	rtnl_register(PF_UNSPEC, RTM_GETQDISC, tc_get_qdisc, tc_dump_qdisc, NULL);
	rtnl_register(PF_UNSPEC, RTM_NEWTCLASS, tc_ctl_tclass, NULL, NULL);
	rtnl_register(PF_UNSPEC, RTM_DELTCLASS, tc_ctl_tclass, NULL, NULL);
	rtnl_register(PF_UNSPEC, RTM_GETTCLASS, tc_ctl_tclass, tc_dump_tclass, NULL);
1801

L
Linus Torvalds 已提交
1802 1803 1804 1805
	return 0;
}

subsys_initcall(pktsched_init);