sch_atm.c 19.6 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

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

210
	pr_debug("atm_tc_change(sch %p,[qdisc %p],classid %x,parent %x,"
P
Patrick McHardy 已提交
211
		"flow %p,opt %p)\n", sch, p, classid, parent, flow, opt);
L
Linus Torvalds 已提交
212 213 214 215 216 217 218 219 220 221 222 223
	/*
	 * 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 已提交
224 225
	if (flow)
		return -EBUSY;
226
	if (opt == NULL || nla_parse_nested(tb, TCA_ATM_MAX, opt, NULL))
L
Linus Torvalds 已提交
227
		return -EINVAL;
228
	if (!tb[TCA_ATM_FD] || nla_len(tb[TCA_ATM_FD]) < sizeof(fd))
L
Linus Torvalds 已提交
229
		return -EINVAL;
230
	fd = *(int *)nla_data(tb[TCA_ATM_FD]);
231
	pr_debug("atm_tc_change: fd %d\n", fd);
232 233 234
	if (tb[TCA_ATM_HDR]) {
		hdr_len = nla_len(tb[TCA_ATM_HDR]);
		hdr = nla_data(tb[TCA_ATM_HDR]);
P
Patrick McHardy 已提交
235
	} else {
L
Linus Torvalds 已提交
236
		hdr_len = RFC1483LLC_LEN;
P
Patrick McHardy 已提交
237
		hdr = NULL;	/* default LLC/SNAP for IP */
L
Linus Torvalds 已提交
238
	}
239
	if (!tb[TCA_ATM_EXCESS])
P
Patrick McHardy 已提交
240
		excess = NULL;
L
Linus Torvalds 已提交
241
	else {
242
		if (nla_len(tb[TCA_ATM_EXCESS]) != sizeof(u32))
L
Linus Torvalds 已提交
243
			return -EINVAL;
P
Patrick McHardy 已提交
244
		excess = (struct atm_flow_data *)
245
			atm_tc_get(sch, *(u32 *)nla_data(tb[TCA_ATM_EXCESS]));
P
Patrick McHardy 已提交
246 247
		if (!excess)
			return -ENOENT;
L
Linus Torvalds 已提交
248
	}
249
	pr_debug("atm_tc_change: type %d, payload %d, hdr_len %d\n",
250
		 opt->nla_type, nla_len(opt), hdr_len);
251 252
	sock = sockfd_lookup(fd, &error);
	if (!sock)
P
Patrick McHardy 已提交
253
		return error;	/* f_count++ */
254
	pr_debug("atm_tc_change: f_count %d\n", file_count(sock->file));
255
	if (sock->ops->family != PF_ATMSVC && sock->ops->family != PF_ATMPVC) {
L
Linus Torvalds 已提交
256
		error = -EPROTOTYPE;
257
		goto err_out;
L
Linus Torvalds 已提交
258 259 260 261 262
	}
	/* @@@ should check if the socket is really operational or we'll crash
	   on vcc->send */
	if (classid) {
		if (TC_H_MAJ(classid ^ sch->handle)) {
263
			pr_debug("atm_tc_change: classid mismatch\n");
L
Linus Torvalds 已提交
264 265 266
			error = -EINVAL;
			goto err_out;
		}
P
Patrick McHardy 已提交
267
		if (find_flow(p, flow)) {
L
Linus Torvalds 已提交
268 269 270
			error = -EEXIST;
			goto err_out;
		}
P
Patrick McHardy 已提交
271
	} else {
L
Linus Torvalds 已提交
272 273 274 275
		int i;
		unsigned long cl;

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

P
Patrick McHardy 已提交
321
static int atm_tc_delete(struct Qdisc *sch, unsigned long arg)
L
Linus Torvalds 已提交
322
{
323
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
324
	struct atm_flow_data *flow = (struct atm_flow_data *)arg;
L
Linus Torvalds 已提交
325

326 327
	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 已提交
328 329 330
		return -EINVAL;
	if (flow->filter_list || flow == &p->link)
		return -EBUSY;
L
Linus Torvalds 已提交
331 332 333 334 335
	/*
	 * 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 已提交
336
		printk(KERN_ERR "atm_tc_delete: flow->ref == %d\n", flow->ref);
L
Linus Torvalds 已提交
337 338
		return -EINVAL;
	}
P
Patrick McHardy 已提交
339 340 341
	if (flow->ref > 2)
		return -EBUSY;	/* catch references via excess, etc. */
	atm_tc_put(sch, arg);
L
Linus Torvalds 已提交
342 343 344
	return 0;
}

P
Patrick McHardy 已提交
345
static void atm_tc_walk(struct Qdisc *sch, struct qdisc_walker *walker)
L
Linus Torvalds 已提交
346
{
347
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
348 349
	struct atm_flow_data *flow;

350
	pr_debug("atm_tc_walk(sch %p,[qdisc %p],walker %p)\n", sch, p, walker);
P
Patrick McHardy 已提交
351 352
	if (walker->stop)
		return;
L
Linus Torvalds 已提交
353 354
	for (flow = p->flows; flow; flow = flow->next) {
		if (walker->count >= walker->skip)
P
Patrick McHardy 已提交
355
			if (walker->fn(sch, (unsigned long)flow, walker) < 0) {
L
Linus Torvalds 已提交
356 357 358 359 360 361 362
				walker->stop = 1;
				break;
			}
		walker->count++;
	}
}

P
Patrick McHardy 已提交
363
static struct tcf_proto **atm_tc_find_tcf(struct Qdisc *sch, unsigned long cl)
L
Linus Torvalds 已提交
364
{
365
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
366
	struct atm_flow_data *flow = (struct atm_flow_data *)cl;
L
Linus Torvalds 已提交
367

368
	pr_debug("atm_tc_find_tcf(sch %p,[qdisc %p],flow %p)\n", sch, p, flow);
369
	return flow ? &flow->filter_list : &p->link.filter_list;
L
Linus Torvalds 已提交
370 371 372 373
}

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

P
Patrick McHardy 已提交
374
static int atm_tc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
L
Linus Torvalds 已提交
375
{
376
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
377
	struct atm_flow_data *flow = NULL;	/* @@@ */
L
Linus Torvalds 已提交
378 379 380 381
	struct tcf_result res;
	int result;
	int ret = NET_XMIT_POLICED;

382
	pr_debug("atm_tc_enqueue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
P
Patrick McHardy 已提交
383
	result = TC_POLICE_OK;	/* be nice to gcc */
L
Linus Torvalds 已提交
384
	if (TC_H_MAJ(skb->priority) != sch->handle ||
P
Patrick McHardy 已提交
385
	    !(flow = (struct atm_flow_data *)atm_tc_get(sch, skb->priority)))
L
Linus Torvalds 已提交
386 387
		for (flow = p->flows; flow; flow = flow->next)
			if (flow->filter_list) {
388 389 390
				result = tc_classify_compat(skb,
							    flow->filter_list,
							    &res);
P
Patrick McHardy 已提交
391 392 393 394 395
				if (result < 0)
					continue;
				flow = (struct atm_flow_data *)res.class;
				if (!flow)
					flow = lookup_flow(sch, res.classid);
L
Linus Torvalds 已提交
396 397
				break;
			}
P
Patrick McHardy 已提交
398 399
	if (!flow)
		flow = &p->link;
L
Linus Torvalds 已提交
400 401 402
	else {
		if (flow->vcc)
			ATM_SKB(skb)->atm_options = flow->vcc->atm_options;
P
Patrick McHardy 已提交
403
		/*@@@ looks good ... but it's not supposed to work :-) */
404 405 406 407 408 409 410 411 412
#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;
413 414 415 416 417 418
		case TC_POLICE_RECLASSIFY:
			if (flow->excess)
				flow = flow->excess;
			else
				ATM_SKB(skb)->atm_options |= ATM_ATMOPT_CLP;
			break;
419
		}
L
Linus Torvalds 已提交
420 421
#endif
	}
422

423 424
	ret = flow->q->enqueue(skb, flow->q);
	if (ret != 0) {
425
drop: __maybe_unused
L
Linus Torvalds 已提交
426
		sch->qstats.drops++;
P
Patrick McHardy 已提交
427 428
		if (flow)
			flow->qstats.drops++;
L
Linus Torvalds 已提交
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
		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 已提交
461
	struct Qdisc *sch = (struct Qdisc *)data;
462
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
463 464 465
	struct atm_flow_data *flow;
	struct sk_buff *skb;

466
	pr_debug("sch_atm_dequeue(sch %p,[qdisc %p])\n", sch, p);
L
Linus Torvalds 已提交
467 468 469 470 471 472
	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 已提交
473 474
			if (!atm_may_send(flow->vcc, skb->truesize)) {
				(void)flow->q->ops->requeue(skb, flow->q);
L
Linus Torvalds 已提交
475 476
				break;
			}
477
			pr_debug("atm_tc_dequeue: sending on class %p\n", flow);
L
Linus Torvalds 已提交
478
			/* remove any LL header somebody else has attached */
479
			skb_pull(skb, skb_network_offset(skb));
L
Linus Torvalds 已提交
480 481 482
			if (skb_headroom(skb) < flow->hdr_len) {
				struct sk_buff *new;

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

static struct sk_buff *atm_tc_dequeue(struct Qdisc *sch)
{
503
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
504 505
	struct sk_buff *skb;

506
	pr_debug("atm_tc_dequeue(sch %p,[qdisc %p])\n", sch, p);
L
Linus Torvalds 已提交
507 508
	tasklet_schedule(&p->task);
	skb = p->link.q->dequeue(p->link.q);
P
Patrick McHardy 已提交
509 510
	if (skb)
		sch->q.qlen--;
L
Linus Torvalds 已提交
511 512 513
	return skb;
}

P
Patrick McHardy 已提交
514
static int atm_tc_requeue(struct sk_buff *skb, struct Qdisc *sch)
L
Linus Torvalds 已提交
515
{
516
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
517 518
	int ret;

519
	pr_debug("atm_tc_requeue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
P
Patrick McHardy 已提交
520
	ret = p->link.q->ops->requeue(skb, p->link.q);
L
Linus Torvalds 已提交
521
	if (!ret) {
P
Patrick McHardy 已提交
522 523 524
		sch->q.qlen++;
		sch->qstats.requeues++;
	} else {
L
Linus Torvalds 已提交
525 526 527 528 529 530 531 532
		sch->qstats.drops++;
		p->link.qstats.drops++;
	}
	return ret;
}

static unsigned int atm_tc_drop(struct Qdisc *sch)
{
533
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
534 535 536
	struct atm_flow_data *flow;
	unsigned int len;

537
	pr_debug("atm_tc_drop(sch %p,[qdisc %p])\n", sch, p);
L
Linus Torvalds 已提交
538 539 540 541 542 543
	for (flow = p->flows; flow; flow = flow->next)
		if (flow->q->ops->drop && (len = flow->q->ops->drop(flow->q)))
			return len;
	return 0;
}

544
static int atm_tc_init(struct Qdisc *sch, struct nlattr *opt)
L
Linus Torvalds 已提交
545
{
546
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
547

548
	pr_debug("atm_tc_init(sch %p,[qdisc %p],opt %p)\n", sch, p, opt);
L
Linus Torvalds 已提交
549
	p->flows = &p->link;
550 551
	p->link.q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, sch->handle);
	if (!p->link.q)
L
Linus Torvalds 已提交
552
		p->link.q = &noop_qdisc;
553
	pr_debug("atm_tc_init: link (%p) qdisc %p\n", &p->link, p->link.q);
L
Linus Torvalds 已提交
554 555 556 557 558 559
	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 已提交
560
	tasklet_init(&p->task, sch_atm_dequeue, (unsigned long)sch);
L
Linus Torvalds 已提交
561 562 563 564 565
	return 0;
}

static void atm_tc_reset(struct Qdisc *sch)
{
566
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
567 568
	struct atm_flow_data *flow;

569
	pr_debug("atm_tc_reset(sch %p,[qdisc %p])\n", sch, p);
P
Patrick McHardy 已提交
570 571
	for (flow = p->flows; flow; flow = flow->next)
		qdisc_reset(flow->q);
L
Linus Torvalds 已提交
572 573 574 575 576
	sch->q.qlen = 0;
}

static void atm_tc_destroy(struct Qdisc *sch)
{
577
	struct atm_qdisc_data *p = qdisc_priv(sch);
L
Linus Torvalds 已提交
578 579
	struct atm_flow_data *flow;

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

static int atm_tc_dump_class(struct Qdisc *sch, unsigned long cl,
P
Patrick McHardy 已提交
600
			     struct sk_buff *skb, struct tcmsg *tcm)
L
Linus Torvalds 已提交
601
{
602
	struct atm_qdisc_data *p = qdisc_priv(sch);
P
Patrick McHardy 已提交
603
	struct atm_flow_data *flow = (struct atm_flow_data *)cl;
604
	unsigned char *b = skb_tail_pointer(skb);
605
	struct nlattr *nla;
L
Linus Torvalds 已提交
606

607
	pr_debug("atm_tc_dump_class(sch %p,[qdisc %p],flow %p,skb %p,tcm %p)\n",
P
Patrick McHardy 已提交
608 609 610
		sch, p, flow, skb, tcm);
	if (!find_flow(p, flow))
		return -EINVAL;
L
Linus Torvalds 已提交
611
	tcm->tcm_handle = flow->classid;
612
	tcm->tcm_info = flow->q->handle;
613 614 615
	nla = (struct nlattr *)b;
	NLA_PUT(skb, TCA_OPTIONS, 0, NULL);
	NLA_PUT(skb, TCA_ATM_HDR, flow->hdr_len, flow->hdr);
L
Linus Torvalds 已提交
616 617 618 619 620 621 622 623
	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;
624
		NLA_PUT(skb, TCA_ATM_ADDR, sizeof(pvc), &pvc);
L
Linus Torvalds 已提交
625
		state = ATM_VF2VS(flow->vcc->flags);
626
		NLA_PUT(skb, TCA_ATM_STATE, sizeof(state), &state);
L
Linus Torvalds 已提交
627 628
	}
	if (flow->excess)
629
		NLA_PUT(skb, TCA_ATM_EXCESS, sizeof(u32), &flow->classid);
L
Linus Torvalds 已提交
630 631 632
	else {
		static u32 zero;

633
		NLA_PUT(skb, TCA_ATM_EXCESS, sizeof(zero), &zero);
L
Linus Torvalds 已提交
634
	}
635
	nla->nla_len = skb_tail_pointer(skb) - b;
L
Linus Torvalds 已提交
636 637
	return skb->len;

638
nla_put_failure:
639
	nlmsg_trim(skb, b);
L
Linus Torvalds 已提交
640 641 642 643
	return -1;
}
static int
atm_tc_dump_class_stats(struct Qdisc *sch, unsigned long arg,
P
Patrick McHardy 已提交
644
			struct gnet_dump *d)
L
Linus Torvalds 已提交
645
{
P
Patrick McHardy 已提交
646
	struct atm_flow_data *flow = (struct atm_flow_data *)arg;
L
Linus Torvalds 已提交
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661

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

662
static const struct Qdisc_class_ops atm_class_ops = {
P
Patrick McHardy 已提交
663 664 665 666 667 668 669 670 671 672 673 674
	.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 已提交
675 676
};

677
static struct Qdisc_ops atm_qdisc_ops __read_mostly = {
P
Patrick McHardy 已提交
678 679 680 681 682 683 684 685 686 687 688 689
	.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 已提交
690 691 692 693 694 695 696
};

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

697
static void __exit atm_exit(void)
L
Linus Torvalds 已提交
698 699 700 701 702 703 704
{
	unregister_qdisc(&atm_qdisc_ops);
}

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