sch_atm.c 19.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/* net/sched/sch_atm.c - ATM VC selection "queueing discipline" */

/* Written 1998-2000 by Werner Almesberger, EPFL ICA */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
#include <linux/atmdev.h>
#include <linux/atmclip.h>
#include <linux/rtnetlink.h>
P
Patrick McHardy 已提交
13
#include <linux/file.h>		/* for fput */
14
#include <net/netlink.h>
L
Linus Torvalds 已提交
15 16
#include <net/pkt_sched.h>

P
Patrick McHardy 已提交
17
extern struct socket *sockfd_lookup(int fd, int *err);	/* @@@ fix this */
L
Linus Torvalds 已提交
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

/*
 * The ATM queuing discipline provides a framework for invoking classifiers
 * (aka "filters"), which in turn select classes of this queuing discipline.
 * Each class maps the flow(s) it is handling to a given VC. Multiple classes
 * may share the same VC.
 *
 * When creating a class, VCs are specified by passing the number of the open
 * socket descriptor by which the calling process references the VC. The kernel
 * keeps the VC open at least until all classes using it are removed.
 *
 * In this file, most functions are named atm_tc_* to avoid confusion with all
 * the atm_* in net/atm. This naming convention differs from what's used in the
 * rest of net/sched.
 *
 * Known bugs:
 *  - sometimes messes up the IP stack
 *  - any manipulations besides the few operations described in the README, are
 *    untested and likely to crash the system
 *  - should lock the flow while there is data in the queue (?)
 */

#define VCC2FLOW(vcc) ((struct atm_flow_data *) ((vcc)->user_back))

struct atm_flow_data {
P
Patrick McHardy 已提交
43
	struct Qdisc		*q;	/* FIFO, TBF, etc. */
L
Linus Torvalds 已提交
44
	struct tcf_proto	*filter_list;
P
Patrick McHardy 已提交
45 46
	struct atm_vcc		*vcc;	/* VCC; NULL if VCC is closed */
	void			(*old_pop)(struct atm_vcc *vcc,
47
					   struct sk_buff *skb); /* chaining */
L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
	struct atm_qdisc_data	*parent;	/* parent qdisc */
	struct socket		*sock;		/* for closing */
	u32			classid;	/* x:y type ID */
	int			ref;		/* reference count */
	struct gnet_stats_basic	bstats;
	struct gnet_stats_queue	qstats;
	struct atm_flow_data	*next;
	struct atm_flow_data	*excess;	/* flow for excess traffic;
						   NULL to set CLP instead */
	int			hdr_len;
	unsigned char		hdr[0];		/* header data; MUST BE LAST */
};

struct atm_qdisc_data {
	struct atm_flow_data	link;		/* unclassified skbs go here */
	struct atm_flow_data	*flows;		/* NB: "link" is also on this
						   list */
	struct tasklet_struct	task;		/* requeue tasklet */
};

/* ------------------------- Class/flow operations ------------------------- */

P
Patrick McHardy 已提交
70
static int find_flow(struct atm_qdisc_data *qdisc, struct atm_flow_data *flow)
L
Linus Torvalds 已提交
71 72 73
{
	struct atm_flow_data *walk;

74
	pr_debug("find_flow(qdisc %p,flow %p)\n", qdisc, flow);
L
Linus Torvalds 已提交
75
	for (walk = qdisc->flows; walk; walk = walk->next)
P
Patrick McHardy 已提交
76 77
		if (walk == flow)
			return 1;
78
	pr_debug("find_flow: not found\n");
L
Linus Torvalds 已提交
79 80 81
	return 0;
}

P
Patrick McHardy 已提交
82
static inline struct atm_flow_data *lookup_flow(struct Qdisc *sch, u32 classid)
L
Linus Torvalds 已提交
83
{
84
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
85 86
	struct atm_flow_data *flow;

87
	for (flow = p->flows; flow; flow = flow->next)
P
Patrick McHardy 已提交
88 89
		if (flow->classid == classid)
			break;
L
Linus Torvalds 已提交
90 91 92
	return flow;
}

P
Patrick McHardy 已提交
93 94
static int atm_tc_graft(struct Qdisc *sch, unsigned long arg,
			struct Qdisc *new, struct Qdisc **old)
L
Linus Torvalds 已提交
95
{
96
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
97 98
	struct atm_flow_data *flow = (struct atm_flow_data *)arg;

99
	pr_debug("atm_tc_graft(sch %p,[qdisc %p],flow %p,new %p,old %p)\n",
P
Patrick McHardy 已提交
100 101 102 103 104 105 106 107
		sch, p, flow, new, old);
	if (!find_flow(p, flow))
		return -EINVAL;
	if (!new)
		new = &noop_qdisc;
	*old = xchg(&flow->q, new);
	if (*old)
		qdisc_reset(*old);
108
	return 0;
L
Linus Torvalds 已提交
109 110
}

P
Patrick McHardy 已提交
111
static struct Qdisc *atm_tc_leaf(struct Qdisc *sch, unsigned long cl)
L
Linus Torvalds 已提交
112
{
P
Patrick McHardy 已提交
113
	struct atm_flow_data *flow = (struct atm_flow_data *)cl;
L
Linus Torvalds 已提交
114

115
	pr_debug("atm_tc_leaf(sch %p,flow %p)\n", sch, flow);
L
Linus Torvalds 已提交
116 117 118
	return flow ? flow->q : NULL;
}

P
Patrick McHardy 已提交
119
static unsigned long atm_tc_get(struct Qdisc *sch, u32 classid)
L
Linus Torvalds 已提交
120
{
121
	struct atm_qdisc_data *p __maybe_unused = qdisc_priv(sch);
L
Linus Torvalds 已提交
122 123
	struct atm_flow_data *flow;

124
	pr_debug("atm_tc_get(sch %p,[qdisc %p],classid %x)\n", sch, p, classid);
P
Patrick McHardy 已提交
125 126 127
	flow = lookup_flow(sch, classid);
	if (flow)
		flow->ref++;
128
	pr_debug("atm_tc_get: flow %p\n", flow);
P
Patrick McHardy 已提交
129
	return (unsigned long)flow;
L
Linus Torvalds 已提交
130 131 132
}

static unsigned long atm_tc_bind_filter(struct Qdisc *sch,
P
Patrick McHardy 已提交
133
					unsigned long parent, u32 classid)
L
Linus Torvalds 已提交
134
{
P
Patrick McHardy 已提交
135
	return atm_tc_get(sch, classid);
L
Linus Torvalds 已提交
136 137 138 139 140 141 142 143 144
}

/*
 * atm_tc_put handles all destructions, including the ones that are explicitly
 * requested (atm_tc_destroy, etc.). The assumption here is that we never drop
 * anything that still seems to be in use.
 */
static void atm_tc_put(struct Qdisc *sch, unsigned long cl)
{
145
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
146
	struct atm_flow_data *flow = (struct atm_flow_data *)cl;
L
Linus Torvalds 已提交
147 148
	struct atm_flow_data **prev;

149
	pr_debug("atm_tc_put(sch %p,[qdisc %p],flow %p)\n", sch, p, flow);
P
Patrick McHardy 已提交
150 151
	if (--flow->ref)
		return;
152
	pr_debug("atm_tc_put: destroying\n");
L
Linus Torvalds 已提交
153
	for (prev = &p->flows; *prev; prev = &(*prev)->next)
P
Patrick McHardy 已提交
154 155
		if (*prev == flow)
			break;
L
Linus Torvalds 已提交
156
	if (!*prev) {
P
Patrick McHardy 已提交
157
		printk(KERN_CRIT "atm_tc_put: class %p not found\n", flow);
L
Linus Torvalds 已提交
158 159 160
		return;
	}
	*prev = flow->next;
161
	pr_debug("atm_tc_put: qdisc %p\n", flow->q);
L
Linus Torvalds 已提交
162
	qdisc_destroy(flow->q);
163
	tcf_destroy_chain(flow->filter_list);
L
Linus Torvalds 已提交
164
	if (flow->sock) {
165
		pr_debug("atm_tc_put: f_count %d\n",
P
Patrick McHardy 已提交
166
			file_count(flow->sock->file));
L
Linus Torvalds 已提交
167 168 169
		flow->vcc->pop = flow->old_pop;
		sockfd_put(flow->sock);
	}
P
Patrick McHardy 已提交
170 171 172 173
	if (flow->excess)
		atm_tc_put(sch, (unsigned long)flow->excess);
	if (flow != &p->link)
		kfree(flow);
L
Linus Torvalds 已提交
174 175 176 177 178 179
	/*
	 * If flow == &p->link, the qdisc no longer works at this point and
	 * needs to be removed. (By the caller of atm_tc_put.)
	 */
}

P
Patrick McHardy 已提交
180
static void sch_atm_pop(struct atm_vcc *vcc, struct sk_buff *skb)
L
Linus Torvalds 已提交
181 182 183
{
	struct atm_qdisc_data *p = VCC2FLOW(vcc)->parent;

184
	pr_debug("sch_atm_pop(vcc %p,skb %p,[qdisc %p])\n", vcc, skb, p);
P
Patrick McHardy 已提交
185
	VCC2FLOW(vcc)->old_pop(vcc, skb);
L
Linus Torvalds 已提交
186 187 188 189
	tasklet_schedule(&p->task);
}

static const u8 llc_oui_ip[] = {
P
Patrick McHardy 已提交
190 191 192 193
	0xaa,			/* DSAP: non-ISO */
	0xaa,			/* SSAP: non-ISO */
	0x03,			/* Ctrl: Unnumbered Information Command PDU */
	0x00,			/* OUI: EtherType */
L
Linus Torvalds 已提交
194
	0x00, 0x00,
P
Patrick McHardy 已提交
195 196
	0x08, 0x00
};				/* Ethertype IP (0800) */
L
Linus Torvalds 已提交
197

198 199 200 201 202
static const struct nla_policy atm_policy[TCA_ATM_MAX + 1] = {
	[TCA_ATM_FD]		= { .type = NLA_U32 },
	[TCA_ATM_EXCESS]	= { .type = NLA_U32 },
};

L
Linus Torvalds 已提交
203
static int atm_tc_change(struct Qdisc *sch, u32 classid, u32 parent,
204
			 struct nlattr **tca, unsigned long *arg)
L
Linus Torvalds 已提交
205
{
206
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
207
	struct atm_flow_data *flow = (struct atm_flow_data *)*arg;
L
Linus Torvalds 已提交
208
	struct atm_flow_data *excess = NULL;
209 210
	struct nlattr *opt = tca[TCA_OPTIONS];
	struct nlattr *tb[TCA_ATM_MAX + 1];
L
Linus Torvalds 已提交
211
	struct socket *sock;
P
Patrick McHardy 已提交
212
	int fd, error, hdr_len;
L
Linus Torvalds 已提交
213 214
	void *hdr;

215
	pr_debug("atm_tc_change(sch %p,[qdisc %p],classid %x,parent %x,"
P
Patrick McHardy 已提交
216
		"flow %p,opt %p)\n", sch, p, classid, parent, flow, opt);
L
Linus Torvalds 已提交
217 218 219 220 221 222 223 224 225 226 227 228
	/*
	 * The concept of parents doesn't apply for this qdisc.
	 */
	if (parent && parent != TC_H_ROOT && parent != sch->handle)
		return -EINVAL;
	/*
	 * ATM classes cannot be changed. In order to change properties of the
	 * ATM connection, that socket needs to be modified directly (via the
	 * native ATM API. In order to send a flow to a different VC, the old
	 * class needs to be removed and a new one added. (This may be changed
	 * later.)
	 */
P
Patrick McHardy 已提交
229 230
	if (flow)
		return -EBUSY;
231
	if (opt == NULL)
L
Linus Torvalds 已提交
232
		return -EINVAL;
233 234

	error = nla_parse_nested(tb, TCA_ATM_MAX, opt, atm_policy);
235 236 237
	if (error < 0)
		return error;

238
	if (!tb[TCA_ATM_FD])
L
Linus Torvalds 已提交
239
		return -EINVAL;
240
	fd = nla_get_u32(tb[TCA_ATM_FD]);
241
	pr_debug("atm_tc_change: fd %d\n", fd);
242 243 244
	if (tb[TCA_ATM_HDR]) {
		hdr_len = nla_len(tb[TCA_ATM_HDR]);
		hdr = nla_data(tb[TCA_ATM_HDR]);
P
Patrick McHardy 已提交
245
	} else {
L
Linus Torvalds 已提交
246
		hdr_len = RFC1483LLC_LEN;
P
Patrick McHardy 已提交
247
		hdr = NULL;	/* default LLC/SNAP for IP */
L
Linus Torvalds 已提交
248
	}
249
	if (!tb[TCA_ATM_EXCESS])
P
Patrick McHardy 已提交
250
		excess = NULL;
L
Linus Torvalds 已提交
251
	else {
P
Patrick McHardy 已提交
252
		excess = (struct atm_flow_data *)
253
			atm_tc_get(sch, nla_get_u32(tb[TCA_ATM_EXCESS]));
P
Patrick McHardy 已提交
254 255
		if (!excess)
			return -ENOENT;
L
Linus Torvalds 已提交
256
	}
257
	pr_debug("atm_tc_change: type %d, payload %d, hdr_len %d\n",
258
		 opt->nla_type, nla_len(opt), hdr_len);
259 260
	sock = sockfd_lookup(fd, &error);
	if (!sock)
P
Patrick McHardy 已提交
261
		return error;	/* f_count++ */
262
	pr_debug("atm_tc_change: f_count %d\n", file_count(sock->file));
263
	if (sock->ops->family != PF_ATMSVC && sock->ops->family != PF_ATMPVC) {
L
Linus Torvalds 已提交
264
		error = -EPROTOTYPE;
265
		goto err_out;
L
Linus Torvalds 已提交
266 267 268 269 270
	}
	/* @@@ should check if the socket is really operational or we'll crash
	   on vcc->send */
	if (classid) {
		if (TC_H_MAJ(classid ^ sch->handle)) {
271
			pr_debug("atm_tc_change: classid mismatch\n");
L
Linus Torvalds 已提交
272 273 274
			error = -EINVAL;
			goto err_out;
		}
P
Patrick McHardy 已提交
275
		if (find_flow(p, flow)) {
L
Linus Torvalds 已提交
276 277 278
			error = -EEXIST;
			goto err_out;
		}
P
Patrick McHardy 已提交
279
	} else {
L
Linus Torvalds 已提交
280 281 282 283
		int i;
		unsigned long cl;

		for (i = 1; i < 0x8000; i++) {
P
Patrick McHardy 已提交
284
			classid = TC_H_MAKE(sch->handle, 0x8000 | i);
285 286
			cl = atm_tc_get(sch, classid);
			if (!cl)
P
Patrick McHardy 已提交
287 288
				break;
			atm_tc_put(sch, cl);
L
Linus Torvalds 已提交
289 290
		}
	}
291
	pr_debug("atm_tc_change: new id %x\n", classid);
292
	flow = kzalloc(sizeof(struct atm_flow_data) + hdr_len, GFP_KERNEL);
293
	pr_debug("atm_tc_change: flow %p\n", flow);
L
Linus Torvalds 已提交
294 295 296 297 298
	if (!flow) {
		error = -ENOBUFS;
		goto err_out;
	}
	flow->filter_list = NULL;
299 300
	flow->q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, classid);
	if (!flow->q)
L
Linus Torvalds 已提交
301
		flow->q = &noop_qdisc;
302
	pr_debug("atm_tc_change: qdisc %p\n", flow->q);
L
Linus Torvalds 已提交
303
	flow->sock = sock;
P
Patrick McHardy 已提交
304
	flow->vcc = ATM_SD(sock);	/* speedup */
L
Linus Torvalds 已提交
305
	flow->vcc->user_back = flow;
306
	pr_debug("atm_tc_change: vcc %p\n", flow->vcc);
L
Linus Torvalds 已提交
307 308 309 310 311 312 313 314 315 316
	flow->old_pop = flow->vcc->pop;
	flow->parent = p;
	flow->vcc->pop = sch_atm_pop;
	flow->classid = classid;
	flow->ref = 1;
	flow->excess = excess;
	flow->next = p->link.next;
	p->link.next = flow;
	flow->hdr_len = hdr_len;
	if (hdr)
P
Patrick McHardy 已提交
317
		memcpy(flow->hdr, hdr, hdr_len);
L
Linus Torvalds 已提交
318
	else
P
Patrick McHardy 已提交
319 320
		memcpy(flow->hdr, llc_oui_ip, sizeof(llc_oui_ip));
	*arg = (unsigned long)flow;
L
Linus Torvalds 已提交
321 322
	return 0;
err_out:
P
Patrick McHardy 已提交
323 324
	if (excess)
		atm_tc_put(sch, (unsigned long)excess);
L
Linus Torvalds 已提交
325 326 327 328
	sockfd_put(sock);
	return error;
}

P
Patrick McHardy 已提交
329
static int atm_tc_delete(struct Qdisc *sch, unsigned long arg)
L
Linus Torvalds 已提交
330
{
331
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
332
	struct atm_flow_data *flow = (struct atm_flow_data *)arg;
L
Linus Torvalds 已提交
333

334 335
	pr_debug("atm_tc_delete(sch %p,[qdisc %p],flow %p)\n", sch, p, flow);
	if (!find_flow(qdisc_priv(sch), flow))
P
Patrick McHardy 已提交
336 337 338
		return -EINVAL;
	if (flow->filter_list || flow == &p->link)
		return -EBUSY;
L
Linus Torvalds 已提交
339 340 341 342 343
	/*
	 * Reference count must be 2: one for "keepalive" (set at class
	 * creation), and one for the reference held when calling delete.
	 */
	if (flow->ref < 2) {
P
Patrick McHardy 已提交
344
		printk(KERN_ERR "atm_tc_delete: flow->ref == %d\n", flow->ref);
L
Linus Torvalds 已提交
345 346
		return -EINVAL;
	}
P
Patrick McHardy 已提交
347 348 349
	if (flow->ref > 2)
		return -EBUSY;	/* catch references via excess, etc. */
	atm_tc_put(sch, arg);
L
Linus Torvalds 已提交
350 351 352
	return 0;
}

P
Patrick McHardy 已提交
353
static void atm_tc_walk(struct Qdisc *sch, struct qdisc_walker *walker)
L
Linus Torvalds 已提交
354
{
355
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
356 357
	struct atm_flow_data *flow;

358
	pr_debug("atm_tc_walk(sch %p,[qdisc %p],walker %p)\n", sch, p, walker);
P
Patrick McHardy 已提交
359 360
	if (walker->stop)
		return;
L
Linus Torvalds 已提交
361 362
	for (flow = p->flows; flow; flow = flow->next) {
		if (walker->count >= walker->skip)
P
Patrick McHardy 已提交
363
			if (walker->fn(sch, (unsigned long)flow, walker) < 0) {
L
Linus Torvalds 已提交
364 365 366 367 368 369 370
				walker->stop = 1;
				break;
			}
		walker->count++;
	}
}

P
Patrick McHardy 已提交
371
static struct tcf_proto **atm_tc_find_tcf(struct Qdisc *sch, unsigned long cl)
L
Linus Torvalds 已提交
372
{
373
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
374
	struct atm_flow_data *flow = (struct atm_flow_data *)cl;
L
Linus Torvalds 已提交
375

376
	pr_debug("atm_tc_find_tcf(sch %p,[qdisc %p],flow %p)\n", sch, p, flow);
377
	return flow ? &flow->filter_list : &p->link.filter_list;
L
Linus Torvalds 已提交
378 379 380 381
}

/* --------------------------- Qdisc operations ---------------------------- */

P
Patrick McHardy 已提交
382
static int atm_tc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
L
Linus Torvalds 已提交
383
{
384
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
385
	struct atm_flow_data *flow = NULL;	/* @@@ */
L
Linus Torvalds 已提交
386 387 388 389
	struct tcf_result res;
	int result;
	int ret = NET_XMIT_POLICED;

390
	pr_debug("atm_tc_enqueue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
P
Patrick McHardy 已提交
391
	result = TC_POLICE_OK;	/* be nice to gcc */
L
Linus Torvalds 已提交
392
	if (TC_H_MAJ(skb->priority) != sch->handle ||
P
Patrick McHardy 已提交
393
	    !(flow = (struct atm_flow_data *)atm_tc_get(sch, skb->priority)))
L
Linus Torvalds 已提交
394 395
		for (flow = p->flows; flow; flow = flow->next)
			if (flow->filter_list) {
396 397 398
				result = tc_classify_compat(skb,
							    flow->filter_list,
							    &res);
P
Patrick McHardy 已提交
399 400 401 402 403
				if (result < 0)
					continue;
				flow = (struct atm_flow_data *)res.class;
				if (!flow)
					flow = lookup_flow(sch, res.classid);
L
Linus Torvalds 已提交
404 405
				break;
			}
P
Patrick McHardy 已提交
406 407
	if (!flow)
		flow = &p->link;
L
Linus Torvalds 已提交
408 409 410
	else {
		if (flow->vcc)
			ATM_SKB(skb)->atm_options = flow->vcc->atm_options;
P
Patrick McHardy 已提交
411
		/*@@@ looks good ... but it's not supposed to work :-) */
412 413 414 415 416 417 418 419 420
#ifdef CONFIG_NET_CLS_ACT
		switch (result) {
		case TC_ACT_QUEUED:
		case TC_ACT_STOLEN:
			kfree_skb(skb);
			return NET_XMIT_SUCCESS;
		case TC_ACT_SHOT:
			kfree_skb(skb);
			goto drop;
421 422 423 424 425 426
		case TC_POLICE_RECLASSIFY:
			if (flow->excess)
				flow = flow->excess;
			else
				ATM_SKB(skb)->atm_options |= ATM_ATMOPT_CLP;
			break;
427
		}
L
Linus Torvalds 已提交
428 429
#endif
	}
430

431 432
	ret = flow->q->enqueue(skb, flow->q);
	if (ret != 0) {
433
drop: __maybe_unused
L
Linus Torvalds 已提交
434
		sch->qstats.drops++;
P
Patrick McHardy 已提交
435 436
		if (flow)
			flow->qstats.drops++;
L
Linus Torvalds 已提交
437 438 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 464 465 466 467 468
		return ret;
	}
	sch->bstats.bytes += skb->len;
	sch->bstats.packets++;
	flow->bstats.bytes += skb->len;
	flow->bstats.packets++;
	/*
	 * Okay, this may seem weird. We pretend we've dropped the packet if
	 * it goes via ATM. The reason for this is that the outer qdisc
	 * expects to be able to q->dequeue the packet later on if we return
	 * success at this place. Also, sch->q.qdisc needs to reflect whether
	 * there is a packet egligible for dequeuing or not. Note that the
	 * statistics of the outer qdisc are necessarily wrong because of all
	 * this. There's currently no correct solution for this.
	 */
	if (flow == &p->link) {
		sch->q.qlen++;
		return 0;
	}
	tasklet_schedule(&p->task);
	return NET_XMIT_BYPASS;
}

/*
 * Dequeue packets and send them over ATM. Note that we quite deliberately
 * avoid checking net_device's flow control here, simply because sch_atm
 * uses its own channels, which have nothing to do with any CLIP/LANE/or
 * non-ATM interfaces.
 */

static void sch_atm_dequeue(unsigned long data)
{
P
Patrick McHardy 已提交
469
	struct Qdisc *sch = (struct Qdisc *)data;
470
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
471 472 473
	struct atm_flow_data *flow;
	struct sk_buff *skb;

474
	pr_debug("sch_atm_dequeue(sch %p,[qdisc %p])\n", sch, p);
L
Linus Torvalds 已提交
475 476 477 478 479 480
	for (flow = p->link.next; flow; flow = flow->next)
		/*
		 * If traffic is properly shaped, this won't generate nasty
		 * little bursts. Otherwise, it may ... (but that's okay)
		 */
		while ((skb = flow->q->dequeue(flow->q))) {
P
Patrick McHardy 已提交
481 482
			if (!atm_may_send(flow->vcc, skb->truesize)) {
				(void)flow->q->ops->requeue(skb, flow->q);
L
Linus Torvalds 已提交
483 484
				break;
			}
485
			pr_debug("atm_tc_dequeue: sending on class %p\n", flow);
L
Linus Torvalds 已提交
486
			/* remove any LL header somebody else has attached */
487
			skb_pull(skb, skb_network_offset(skb));
L
Linus Torvalds 已提交
488 489 490
			if (skb_headroom(skb) < flow->hdr_len) {
				struct sk_buff *new;

P
Patrick McHardy 已提交
491
				new = skb_realloc_headroom(skb, flow->hdr_len);
L
Linus Torvalds 已提交
492
				dev_kfree_skb(skb);
P
Patrick McHardy 已提交
493 494
				if (!new)
					continue;
L
Linus Torvalds 已提交
495 496
				skb = new;
			}
497
			pr_debug("sch_atm_dequeue: ip %p, data %p\n",
498
				 skb_network_header(skb), skb->data);
L
Linus Torvalds 已提交
499
			ATM_SKB(skb)->vcc = flow->vcc;
P
Patrick McHardy 已提交
500 501
			memcpy(skb_push(skb, flow->hdr_len), flow->hdr,
			       flow->hdr_len);
L
Linus Torvalds 已提交
502 503 504
			atomic_add(skb->truesize,
				   &sk_atm(flow->vcc)->sk_wmem_alloc);
			/* atm.atm_options are already set by atm_tc_enqueue */
P
Patrick McHardy 已提交
505
			flow->vcc->send(flow->vcc, skb);
L
Linus Torvalds 已提交
506 507 508 509 510
		}
}

static struct sk_buff *atm_tc_dequeue(struct Qdisc *sch)
{
511
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
512 513
	struct sk_buff *skb;

514
	pr_debug("atm_tc_dequeue(sch %p,[qdisc %p])\n", sch, p);
L
Linus Torvalds 已提交
515 516
	tasklet_schedule(&p->task);
	skb = p->link.q->dequeue(p->link.q);
P
Patrick McHardy 已提交
517 518
	if (skb)
		sch->q.qlen--;
L
Linus Torvalds 已提交
519 520 521
	return skb;
}

P
Patrick McHardy 已提交
522
static int atm_tc_requeue(struct sk_buff *skb, struct Qdisc *sch)
L
Linus Torvalds 已提交
523
{
524
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
525 526
	int ret;

527
	pr_debug("atm_tc_requeue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
P
Patrick McHardy 已提交
528
	ret = p->link.q->ops->requeue(skb, p->link.q);
L
Linus Torvalds 已提交
529
	if (!ret) {
P
Patrick McHardy 已提交
530 531 532
		sch->q.qlen++;
		sch->qstats.requeues++;
	} else {
L
Linus Torvalds 已提交
533 534 535 536 537 538 539 540
		sch->qstats.drops++;
		p->link.qstats.drops++;
	}
	return ret;
}

static unsigned int atm_tc_drop(struct Qdisc *sch)
{
541
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
542 543 544
	struct atm_flow_data *flow;
	unsigned int len;

545
	pr_debug("atm_tc_drop(sch %p,[qdisc %p])\n", sch, p);
L
Linus Torvalds 已提交
546 547 548 549 550 551
	for (flow = p->flows; flow; flow = flow->next)
		if (flow->q->ops->drop && (len = flow->q->ops->drop(flow->q)))
			return len;
	return 0;
}

552
static int atm_tc_init(struct Qdisc *sch, struct nlattr *opt)
L
Linus Torvalds 已提交
553
{
554
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
555

556
	pr_debug("atm_tc_init(sch %p,[qdisc %p],opt %p)\n", sch, p, opt);
L
Linus Torvalds 已提交
557
	p->flows = &p->link;
558 559
	p->link.q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, sch->handle);
	if (!p->link.q)
L
Linus Torvalds 已提交
560
		p->link.q = &noop_qdisc;
561
	pr_debug("atm_tc_init: link (%p) qdisc %p\n", &p->link, p->link.q);
L
Linus Torvalds 已提交
562 563 564 565 566 567
	p->link.filter_list = NULL;
	p->link.vcc = NULL;
	p->link.sock = NULL;
	p->link.classid = sch->handle;
	p->link.ref = 1;
	p->link.next = NULL;
P
Patrick McHardy 已提交
568
	tasklet_init(&p->task, sch_atm_dequeue, (unsigned long)sch);
L
Linus Torvalds 已提交
569 570 571 572 573
	return 0;
}

static void atm_tc_reset(struct Qdisc *sch)
{
574
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
575 576
	struct atm_flow_data *flow;

577
	pr_debug("atm_tc_reset(sch %p,[qdisc %p])\n", sch, p);
P
Patrick McHardy 已提交
578 579
	for (flow = p->flows; flow; flow = flow->next)
		qdisc_reset(flow->q);
L
Linus Torvalds 已提交
580 581 582 583 584
	sch->q.qlen = 0;
}

static void atm_tc_destroy(struct Qdisc *sch)
{
585
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
586 587
	struct atm_flow_data *flow;

588
	pr_debug("atm_tc_destroy(sch %p,[qdisc %p])\n", sch, p);
L
Linus Torvalds 已提交
589 590
	/* races ? */
	while ((flow = p->flows)) {
591
		tcf_destroy_chain(flow->filter_list);
592
		flow->filter_list = NULL;
L
Linus Torvalds 已提交
593
		if (flow->ref > 1)
P
Patrick McHardy 已提交
594 595 596
			printk(KERN_ERR "atm_destroy: %p->ref = %d\n", flow,
			       flow->ref);
		atm_tc_put(sch, (unsigned long)flow);
L
Linus Torvalds 已提交
597 598
		if (p->flows == flow) {
			printk(KERN_ERR "atm_destroy: putting flow %p didn't "
P
Patrick McHardy 已提交
599 600
			       "kill it\n", flow);
			p->flows = flow->next;	/* brute force */
L
Linus Torvalds 已提交
601 602 603 604 605 606 607
			break;
		}
	}
	tasklet_kill(&p->task);
}

static int atm_tc_dump_class(struct Qdisc *sch, unsigned long cl,
P
Patrick McHardy 已提交
608
			     struct sk_buff *skb, struct tcmsg *tcm)
L
Linus Torvalds 已提交
609
{
610
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
611
	struct atm_flow_data *flow = (struct atm_flow_data *)cl;
612
	struct nlattr *nest;
L
Linus Torvalds 已提交
613

614
	pr_debug("atm_tc_dump_class(sch %p,[qdisc %p],flow %p,skb %p,tcm %p)\n",
P
Patrick McHardy 已提交
615 616 617
		sch, p, flow, skb, tcm);
	if (!find_flow(p, flow))
		return -EINVAL;
L
Linus Torvalds 已提交
618
	tcm->tcm_handle = flow->classid;
619
	tcm->tcm_info = flow->q->handle;
620 621 622 623 624

	nest = nla_nest_start(skb, TCA_OPTIONS);
	if (nest == NULL)
		goto nla_put_failure;

625
	NLA_PUT(skb, TCA_ATM_HDR, flow->hdr_len, flow->hdr);
L
Linus Torvalds 已提交
626 627 628 629 630 631 632 633
	if (flow->vcc) {
		struct sockaddr_atmpvc pvc;
		int state;

		pvc.sap_family = AF_ATMPVC;
		pvc.sap_addr.itf = flow->vcc->dev ? flow->vcc->dev->number : -1;
		pvc.sap_addr.vpi = flow->vcc->vpi;
		pvc.sap_addr.vci = flow->vcc->vci;
634
		NLA_PUT(skb, TCA_ATM_ADDR, sizeof(pvc), &pvc);
L
Linus Torvalds 已提交
635
		state = ATM_VF2VS(flow->vcc->flags);
636
		NLA_PUT_U32(skb, TCA_ATM_STATE, state);
L
Linus Torvalds 已提交
637 638
	}
	if (flow->excess)
639
		NLA_PUT_U32(skb, TCA_ATM_EXCESS, flow->classid);
L
Linus Torvalds 已提交
640
	else {
641
		NLA_PUT_U32(skb, TCA_ATM_EXCESS, 0);
L
Linus Torvalds 已提交
642
	}
643 644

	nla_nest_end(skb, nest);
L
Linus Torvalds 已提交
645 646
	return skb->len;

647
nla_put_failure:
648
	nla_nest_cancel(skb, nest);
L
Linus Torvalds 已提交
649 650 651 652
	return -1;
}
static int
atm_tc_dump_class_stats(struct Qdisc *sch, unsigned long arg,
P
Patrick McHardy 已提交
653
			struct gnet_dump *d)
L
Linus Torvalds 已提交
654
{
P
Patrick McHardy 已提交
655
	struct atm_flow_data *flow = (struct atm_flow_data *)arg;
L
Linus Torvalds 已提交
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670

	flow->qstats.qlen = flow->q->q.qlen;

	if (gnet_stats_copy_basic(d, &flow->bstats) < 0 ||
	    gnet_stats_copy_queue(d, &flow->qstats) < 0)
		return -1;

	return 0;
}

static int atm_tc_dump(struct Qdisc *sch, struct sk_buff *skb)
{
	return 0;
}

671
static const struct Qdisc_class_ops atm_class_ops = {
P
Patrick McHardy 已提交
672 673 674 675 676 677 678 679 680 681 682 683
	.graft		= atm_tc_graft,
	.leaf		= atm_tc_leaf,
	.get		= atm_tc_get,
	.put		= atm_tc_put,
	.change		= atm_tc_change,
	.delete		= atm_tc_delete,
	.walk		= atm_tc_walk,
	.tcf_chain	= atm_tc_find_tcf,
	.bind_tcf	= atm_tc_bind_filter,
	.unbind_tcf	= atm_tc_put,
	.dump		= atm_tc_dump_class,
	.dump_stats	= atm_tc_dump_class_stats,
L
Linus Torvalds 已提交
684 685
};

686
static struct Qdisc_ops atm_qdisc_ops __read_mostly = {
P
Patrick McHardy 已提交
687 688 689 690 691 692 693 694 695 696 697 698
	.cl_ops		= &atm_class_ops,
	.id		= "atm",
	.priv_size	= sizeof(struct atm_qdisc_data),
	.enqueue	= atm_tc_enqueue,
	.dequeue	= atm_tc_dequeue,
	.requeue	= atm_tc_requeue,
	.drop		= atm_tc_drop,
	.init		= atm_tc_init,
	.reset		= atm_tc_reset,
	.destroy	= atm_tc_destroy,
	.dump		= atm_tc_dump,
	.owner		= THIS_MODULE,
L
Linus Torvalds 已提交
699 700 701 702 703 704 705
};

static int __init atm_init(void)
{
	return register_qdisc(&atm_qdisc_ops);
}

706
static void __exit atm_exit(void)
L
Linus Torvalds 已提交
707 708 709 710 711 712 713
{
	unregister_qdisc(&atm_qdisc_ops);
}

module_init(atm_init)
module_exit(atm_exit)
MODULE_LICENSE("GPL");