blob: 5a002c247231820f1f42e5acf77befdc0f590f1c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* net/sched/sch_teql.c "True" (or "trivial") link equalizer.
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License
5 * as published by the Free Software Foundation; either version
6 * 2 of the License, or (at your option) any later version.
7 *
8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
9 */
10
11#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/types.h>
13#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/errno.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020016#include <linux/if_arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/netdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/skbuff.h>
20#include <linux/moduleparam.h>
Patrick McHardy0ba48052007-07-02 22:49:07 -070021#include <net/dst.h>
22#include <net/neighbour.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <net/pkt_sched.h>
24
25/*
26 How to setup it.
27 ----------------
28
29 After loading this module you will find a new device teqlN
30 and new qdisc with the same name. To join a slave to the equalizer
31 you should just set this qdisc on a device f.e.
32
33 # tc qdisc add dev eth0 root teql0
34 # tc qdisc add dev eth1 root teql0
35
36 That's all. Full PnP 8)
37
38 Applicability.
39 --------------
40
41 1. Slave devices MUST be active devices, i.e., they must raise the tbusy
42 signal and generate EOI events. If you want to equalize virtual devices
43 like tunnels, use a normal eql device.
44 2. This device puts no limitations on physical slave characteristics
45 f.e. it will equalize 9600baud line and 100Mb ethernet perfectly :-)
46 Certainly, large difference in link speeds will make the resulting
47 eqalized link unusable, because of huge packet reordering.
48 I estimate an upper useful difference as ~10 times.
49 3. If the slave requires address resolution, only protocols using
50 neighbour cache (IPv4/IPv6) will work over the equalized link.
51 Other protocols are still allowed to use the slave device directly,
52 which will not break load balancing, though native slave
53 traffic will have the highest priority. */
54
55struct teql_master
56{
57 struct Qdisc_ops qops;
58 struct net_device *dev;
59 struct Qdisc *slaves;
60 struct list_head master_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061};
62
63struct teql_sched_data
64{
65 struct Qdisc *next;
66 struct teql_master *m;
67 struct neighbour *ncache;
68 struct sk_buff_head q;
69};
70
71#define NEXT_SLAVE(q) (((struct teql_sched_data*)qdisc_priv(q))->next)
72
Roel Kluincc8fd142008-01-31 17:08:47 -080073#define FMASK (IFF_BROADCAST|IFF_POINTOPOINT)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75/* "teql*" qdisc routines */
76
77static int
78teql_enqueue(struct sk_buff *skb, struct Qdisc* sch)
79{
David S. Miller5ce2d482008-07-08 17:06:30 -070080 struct net_device *dev = qdisc_dev(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 struct teql_sched_data *q = qdisc_priv(sch);
82
Krishna Kumar4cd8c9e2007-05-08 18:57:50 -070083 if (q->q.qlen < dev->tx_queue_len) {
84 __skb_queue_tail(&q->q, skb);
Jussi Kivilinna0abf77e2008-07-20 00:08:27 -070085 sch->bstats.bytes += qdisc_pkt_len(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 sch->bstats.packets++;
87 return 0;
88 }
89
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 kfree_skb(skb);
91 sch->qstats.drops++;
92 return NET_XMIT_DROP;
93}
94
Linus Torvalds1da177e2005-04-16 15:20:36 -070095static struct sk_buff *
96teql_dequeue(struct Qdisc* sch)
97{
98 struct teql_sched_data *dat = qdisc_priv(sch);
David S. Millerb0e1e642008-07-08 17:42:10 -070099 struct netdev_queue *dat_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 struct sk_buff *skb;
101
102 skb = __skb_dequeue(&dat->q);
David S. Millere8a04642008-07-17 00:34:19 -0700103 dat_queue = netdev_get_tx_queue(dat->m->dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 if (skb == NULL) {
David S. Millerb0e1e642008-07-08 17:42:10 -0700105 struct net_device *m = qdisc_dev(dat_queue->qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 if (m) {
107 dat->m->slaves = sch;
108 netif_wake_queue(m);
109 }
110 }
David S. Millerb0e1e642008-07-08 17:42:10 -0700111 sch->q.qlen = dat->q.qlen + dat_queue->qdisc->q.qlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 return skb;
113}
114
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700115static struct sk_buff *
116teql_peek(struct Qdisc* sch)
117{
118 /* teql is meant to be used as root qdisc */
119 return NULL;
120}
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122static __inline__ void
123teql_neigh_release(struct neighbour *n)
124{
125 if (n)
126 neigh_release(n);
127}
128
129static void
130teql_reset(struct Qdisc* sch)
131{
132 struct teql_sched_data *dat = qdisc_priv(sch);
133
134 skb_queue_purge(&dat->q);
135 sch->q.qlen = 0;
136 teql_neigh_release(xchg(&dat->ncache, NULL));
137}
138
139static void
140teql_destroy(struct Qdisc* sch)
141{
142 struct Qdisc *q, *prev;
143 struct teql_sched_data *dat = qdisc_priv(sch);
144 struct teql_master *master = dat->m;
145
146 if ((prev = master->slaves) != NULL) {
147 do {
148 q = NEXT_SLAVE(prev);
149 if (q == sch) {
150 NEXT_SLAVE(prev) = NEXT_SLAVE(q);
151 if (q == master->slaves) {
152 master->slaves = NEXT_SLAVE(q);
153 if (q == master->slaves) {
David S. Millere8a04642008-07-17 00:34:19 -0700154 struct netdev_queue *txq;
David S. Miller83874002008-07-17 00:53:03 -0700155 spinlock_t *root_lock;
David S. Millere8a04642008-07-17 00:34:19 -0700156
157 txq = netdev_get_tx_queue(master->dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 master->slaves = NULL;
David S. Miller83874002008-07-17 00:53:03 -0700159
Jarek Poplawski102396a2008-08-29 14:21:52 -0700160 root_lock = qdisc_root_sleeping_lock(txq->qdisc);
David S. Miller83874002008-07-17 00:53:03 -0700161 spin_lock_bh(root_lock);
David S. Millere8a04642008-07-17 00:34:19 -0700162 qdisc_reset(txq->qdisc);
David S. Miller83874002008-07-17 00:53:03 -0700163 spin_unlock_bh(root_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 }
165 }
166 skb_queue_purge(&dat->q);
167 teql_neigh_release(xchg(&dat->ncache, NULL));
168 break;
169 }
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 } while ((prev = q) != master->slaves);
172 }
173}
174
Patrick McHardy1e904742008-01-22 22:11:17 -0800175static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176{
David S. Miller5ce2d482008-07-08 17:06:30 -0700177 struct net_device *dev = qdisc_dev(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 struct teql_master *m = (struct teql_master*)sch->ops;
179 struct teql_sched_data *q = qdisc_priv(sch);
180
181 if (dev->hard_header_len > m->dev->hard_header_len)
182 return -EINVAL;
183
184 if (m->dev == dev)
185 return -ELOOP;
186
187 q->m = m;
188
189 skb_queue_head_init(&q->q);
190
191 if (m->slaves) {
192 if (m->dev->flags & IFF_UP) {
193 if ((m->dev->flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT))
194 || (m->dev->flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST))
195 || (m->dev->flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST))
196 || dev->mtu < m->dev->mtu)
197 return -EINVAL;
198 } else {
199 if (!(dev->flags&IFF_POINTOPOINT))
200 m->dev->flags &= ~IFF_POINTOPOINT;
201 if (!(dev->flags&IFF_BROADCAST))
202 m->dev->flags &= ~IFF_BROADCAST;
203 if (!(dev->flags&IFF_MULTICAST))
204 m->dev->flags &= ~IFF_MULTICAST;
205 if (dev->mtu < m->dev->mtu)
206 m->dev->mtu = dev->mtu;
207 }
208 q->next = NEXT_SLAVE(m->slaves);
209 NEXT_SLAVE(m->slaves) = sch;
210 } else {
211 q->next = sch;
212 m->slaves = sch;
213 m->dev->mtu = dev->mtu;
214 m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK);
215 }
216 return 0;
217}
218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220static int
221__teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
222{
David S. Millere8a04642008-07-17 00:34:19 -0700223 struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, 0);
224 struct teql_sched_data *q = qdisc_priv(dev_queue->qdisc);
Eric Dumazetadf30902009-06-02 05:19:30 +0000225 struct neighbour *mn = skb_dst(skb)->neighbour;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 struct neighbour *n = q->ncache;
227
228 if (mn->tbl == NULL)
229 return -EINVAL;
230 if (n && n->tbl == mn->tbl &&
231 memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) {
232 atomic_inc(&n->refcnt);
233 } else {
234 n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev);
235 if (IS_ERR(n))
236 return PTR_ERR(n);
237 }
238 if (neigh_event_send(n, skb_res) == 0) {
239 int err;
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 read_lock(&n->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700242 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
243 n->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 read_unlock(&n->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 if (err < 0) {
247 neigh_release(n);
248 return -EINVAL;
249 }
250 teql_neigh_release(xchg(&q->ncache, n));
251 return 0;
252 }
253 neigh_release(n);
254 return (skb_res == NULL) ? -EAGAIN : 1;
255}
256
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700257static inline int teql_resolve(struct sk_buff *skb,
258 struct sk_buff *skb_res, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259{
David S. Millere8a04642008-07-17 00:34:19 -0700260 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
261 if (txq->qdisc == &noop_qdisc)
Evgeniy Polyakov4f9f8312007-11-06 03:08:09 -0800262 return -ENODEV;
263
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700264 if (dev->header_ops == NULL ||
Eric Dumazetadf30902009-06-02 05:19:30 +0000265 skb_dst(skb) == NULL ||
266 skb_dst(skb)->neighbour == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 return 0;
268 return __teql_resolve(skb, skb_res, dev);
269}
270
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000271static netdev_tx_t teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
Patrick McHardy2941a482006-01-08 22:05:26 -0800273 struct teql_master *master = netdev_priv(dev);
Eric Dumazetab35cd42009-05-19 15:16:34 -0700274 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 struct Qdisc *start, *q;
276 int busy;
277 int nores;
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -0700278 int subq = skb_get_queue_mapping(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 struct sk_buff *skb_res = NULL;
280
281 start = master->slaves;
282
283restart:
284 nores = 0;
285 busy = 0;
286
287 if ((q = start) == NULL)
288 goto drop;
289
290 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700291 struct net_device *slave = qdisc_dev(q);
Stephen Hemminger61294e22009-01-06 10:45:57 -0800292 struct netdev_queue *slave_txq = netdev_get_tx_queue(slave, 0);
293 const struct net_device_ops *slave_ops = slave->netdev_ops;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900294
David S. Millere8a04642008-07-17 00:34:19 -0700295 if (slave_txq->qdisc_sleeping != q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 continue;
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700297 if (__netif_subqueue_stopped(slave, subq) ||
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700298 !netif_running(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 busy = 1;
300 continue;
301 }
302
303 switch (teql_resolve(skb, skb_res, slave)) {
304 case 0:
David S. Millerc3f26a22008-07-31 16:58:50 -0700305 if (__netif_tx_trylock(slave_txq)) {
Eric Dumazetc0f84d02009-05-18 15:12:31 -0700306 unsigned int length = qdisc_pkt_len(skb);
307
David S. Millerc3f26a22008-07-31 16:58:50 -0700308 if (!netif_tx_queue_stopped(slave_txq) &&
309 !netif_tx_queue_frozen(slave_txq) &&
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000310 slave_ops->ndo_start_xmit(skb, slave) == NETDEV_TX_OK) {
Eric Dumazet08baf562009-05-25 22:58:01 -0700311 txq_trans_update(slave_txq);
David S. Millerc3f26a22008-07-31 16:58:50 -0700312 __netif_tx_unlock(slave_txq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 master->slaves = NEXT_SLAVE(q);
314 netif_wake_queue(dev);
Eric Dumazetab35cd42009-05-19 15:16:34 -0700315 txq->tx_packets++;
316 txq->tx_bytes += length;
Patrick McHardy6ed10652009-06-23 06:03:08 +0000317 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
David S. Millerc3f26a22008-07-31 16:58:50 -0700319 __netif_tx_unlock(slave_txq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 }
321 if (netif_queue_stopped(dev))
322 busy = 1;
323 break;
324 case 1:
325 master->slaves = NEXT_SLAVE(q);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000326 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 default:
328 nores = 1;
329 break;
330 }
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300331 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 } while ((q = NEXT_SLAVE(q)) != start);
333
334 if (nores && skb_res == NULL) {
335 skb_res = skb;
336 goto restart;
337 }
338
339 if (busy) {
340 netif_stop_queue(dev);
Patrick McHardy5b548142009-06-12 06:22:29 +0000341 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 }
Eric Dumazetab35cd42009-05-19 15:16:34 -0700343 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345drop:
Eric Dumazetab35cd42009-05-19 15:16:34 -0700346 txq->tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000348 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349}
350
351static int teql_master_open(struct net_device *dev)
352{
353 struct Qdisc * q;
Patrick McHardy2941a482006-01-08 22:05:26 -0800354 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 int mtu = 0xFFFE;
356 unsigned flags = IFF_NOARP|IFF_MULTICAST;
357
358 if (m->slaves == NULL)
359 return -EUNATCH;
360
361 flags = FMASK;
362
363 q = m->slaves;
364 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700365 struct net_device *slave = qdisc_dev(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367 if (slave == NULL)
368 return -EUNATCH;
369
370 if (slave->mtu < mtu)
371 mtu = slave->mtu;
372 if (slave->hard_header_len > LL_MAX_HEADER)
373 return -EINVAL;
374
375 /* If all the slaves are BROADCAST, master is BROADCAST
376 If all the slaves are PtP, master is PtP
377 Otherwise, master is NBMA.
378 */
379 if (!(slave->flags&IFF_POINTOPOINT))
380 flags &= ~IFF_POINTOPOINT;
381 if (!(slave->flags&IFF_BROADCAST))
382 flags &= ~IFF_BROADCAST;
383 if (!(slave->flags&IFF_MULTICAST))
384 flags &= ~IFF_MULTICAST;
385 } while ((q = NEXT_SLAVE(q)) != m->slaves);
386
387 m->dev->mtu = mtu;
388 m->dev->flags = (m->dev->flags&~FMASK) | flags;
389 netif_start_queue(m->dev);
390 return 0;
391}
392
393static int teql_master_close(struct net_device *dev)
394{
395 netif_stop_queue(dev);
396 return 0;
397}
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399static int teql_master_mtu(struct net_device *dev, int new_mtu)
400{
Patrick McHardy2941a482006-01-08 22:05:26 -0800401 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 struct Qdisc *q;
403
404 if (new_mtu < 68)
405 return -EINVAL;
406
407 q = m->slaves;
408 if (q) {
409 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700410 if (new_mtu > qdisc_dev(q)->mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 return -EINVAL;
412 } while ((q=NEXT_SLAVE(q)) != m->slaves);
413 }
414
415 dev->mtu = new_mtu;
416 return 0;
417}
418
Stephen Hemminger61294e22009-01-06 10:45:57 -0800419static const struct net_device_ops teql_netdev_ops = {
420 .ndo_open = teql_master_open,
421 .ndo_stop = teql_master_close,
422 .ndo_start_xmit = teql_master_xmit,
Stephen Hemminger61294e22009-01-06 10:45:57 -0800423 .ndo_change_mtu = teql_master_mtu,
424};
425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426static __init void teql_master_setup(struct net_device *dev)
427{
Patrick McHardy2941a482006-01-08 22:05:26 -0800428 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 struct Qdisc_ops *ops = &master->qops;
430
431 master->dev = dev;
432 ops->priv_size = sizeof(struct teql_sched_data);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 ops->enqueue = teql_enqueue;
435 ops->dequeue = teql_dequeue;
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700436 ops->peek = teql_peek;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 ops->init = teql_qdisc_init;
438 ops->reset = teql_reset;
439 ops->destroy = teql_destroy;
440 ops->owner = THIS_MODULE;
441
Stephen Hemminger61294e22009-01-06 10:45:57 -0800442 dev->netdev_ops = &teql_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 dev->type = ARPHRD_VOID;
444 dev->mtu = 1500;
445 dev->tx_queue_len = 100;
446 dev->flags = IFF_NOARP;
447 dev->hard_header_len = LL_MAX_HEADER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448}
449
450static LIST_HEAD(master_dev_list);
451static int max_equalizers = 1;
452module_param(max_equalizers, int, 0);
453MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
454
455static int __init teql_init(void)
456{
457 int i;
458 int err = -ENODEV;
459
460 for (i = 0; i < max_equalizers; i++) {
461 struct net_device *dev;
462 struct teql_master *master;
463
464 dev = alloc_netdev(sizeof(struct teql_master),
465 "teql%d", teql_master_setup);
466 if (!dev) {
467 err = -ENOMEM;
468 break;
469 }
470
471 if ((err = register_netdev(dev))) {
472 free_netdev(dev);
473 break;
474 }
475
Patrick McHardy2941a482006-01-08 22:05:26 -0800476 master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
479 err = register_qdisc(&master->qops);
480
481 if (err) {
482 unregister_netdev(dev);
483 free_netdev(dev);
484 break;
485 }
486
487 list_add_tail(&master->master_list, &master_dev_list);
488 }
489 return i ? 0 : err;
490}
491
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900492static void __exit teql_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
494 struct teql_master *master, *nxt;
495
496 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
497
498 list_del(&master->master_list);
499
500 unregister_qdisc(&master->qops);
501 unregister_netdev(master->dev);
502 free_netdev(master->dev);
503 }
504}
505
506module_init(teql_init);
507module_exit(teql_exit);
508
509MODULE_LICENSE("GPL");