blob: e02687185a594116b125fdbfc7db49bf8a929797 [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090014#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/errno.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020017#include <linux/if_arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/netdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/skbuff.h>
21#include <linux/moduleparam.h>
Patrick McHardy0ba48052007-07-02 22:49:07 -070022#include <net/dst.h>
23#include <net/neighbour.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <net/pkt_sched.h>
25
26/*
27 How to setup it.
28 ----------------
29
30 After loading this module you will find a new device teqlN
31 and new qdisc with the same name. To join a slave to the equalizer
32 you should just set this qdisc on a device f.e.
33
34 # tc qdisc add dev eth0 root teql0
35 # tc qdisc add dev eth1 root teql0
36
37 That's all. Full PnP 8)
38
39 Applicability.
40 --------------
41
42 1. Slave devices MUST be active devices, i.e., they must raise the tbusy
43 signal and generate EOI events. If you want to equalize virtual devices
44 like tunnels, use a normal eql device.
45 2. This device puts no limitations on physical slave characteristics
46 f.e. it will equalize 9600baud line and 100Mb ethernet perfectly :-)
47 Certainly, large difference in link speeds will make the resulting
48 eqalized link unusable, because of huge packet reordering.
49 I estimate an upper useful difference as ~10 times.
50 3. If the slave requires address resolution, only protocols using
51 neighbour cache (IPv4/IPv6) will work over the equalized link.
52 Other protocols are still allowed to use the slave device directly,
53 which will not break load balancing, though native slave
54 traffic will have the highest priority. */
55
Eric Dumazetcc7ec452011-01-19 19:26:56 +000056struct teql_master {
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 struct Qdisc_ops qops;
58 struct net_device *dev;
59 struct Qdisc *slaves;
60 struct list_head master_list;
Eric Dumazet1ac9ad12011-01-12 12:13:14 +000061 unsigned long tx_bytes;
62 unsigned long tx_packets;
63 unsigned long tx_errors;
64 unsigned long tx_dropped;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065};
66
Eric Dumazetcc7ec452011-01-19 19:26:56 +000067struct teql_sched_data {
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 struct Qdisc *next;
69 struct teql_master *m;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 struct sk_buff_head q;
71};
72
Eric Dumazetcc7ec452011-01-19 19:26:56 +000073#define NEXT_SLAVE(q) (((struct teql_sched_data *)qdisc_priv(q))->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
Eric Dumazetcc7ec452011-01-19 19:26:56 +000075#define FMASK (IFF_BROADCAST | IFF_POINTOPOINT)
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77/* "teql*" qdisc routines */
78
79static int
Eric Dumazetcc7ec452011-01-19 19:26:56 +000080teql_enqueue(struct sk_buff *skb, struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081{
David S. Miller5ce2d482008-07-08 17:06:30 -070082 struct net_device *dev = qdisc_dev(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 struct teql_sched_data *q = qdisc_priv(sch);
84
Krishna Kumar4cd8c9e2007-05-08 18:57:50 -070085 if (q->q.qlen < dev->tx_queue_len) {
86 __skb_queue_tail(&q->q, skb);
Ben Greear9871e502010-08-10 01:45:40 -070087 return NET_XMIT_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 }
89
Eric Dumazet17045752012-05-04 04:37:21 +000090 return qdisc_drop(skb, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
92
Linus Torvalds1da177e2005-04-16 15:20:36 -070093static struct sk_buff *
Eric Dumazetcc7ec452011-01-19 19:26:56 +000094teql_dequeue(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
96 struct teql_sched_data *dat = qdisc_priv(sch);
David S. Millerb0e1e642008-07-08 17:42:10 -070097 struct netdev_queue *dat_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 struct sk_buff *skb;
John Fastabend46e5da42014-09-12 20:04:52 -070099 struct Qdisc *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
101 skb = __skb_dequeue(&dat->q);
David S. Millere8a04642008-07-17 00:34:19 -0700102 dat_queue = netdev_get_tx_queue(dat->m->dev, 0);
John Fastabend46e5da42014-09-12 20:04:52 -0700103 q = rcu_dereference_bh(dat_queue->qdisc);
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 if (skb == NULL) {
John Fastabend46e5da42014-09-12 20:04:52 -0700106 struct net_device *m = qdisc_dev(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 if (m) {
108 dat->m->slaves = sch;
109 netif_wake_queue(m);
110 }
Eric Dumazet9190b3b2011-01-20 23:31:33 -0800111 } else {
112 qdisc_bstats_update(sch, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 }
John Fastabend46e5da42014-09-12 20:04:52 -0700114 sch->q.qlen = dat->q.qlen + q->q.qlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 return skb;
116}
117
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700118static struct sk_buff *
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000119teql_peek(struct Qdisc *sch)
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700120{
121 /* teql is meant to be used as root qdisc */
122 return NULL;
123}
124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125static void
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000126teql_reset(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127{
128 struct teql_sched_data *dat = qdisc_priv(sch);
129
130 skb_queue_purge(&dat->q);
131 sch->q.qlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132}
133
134static void
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000135teql_destroy(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
137 struct Qdisc *q, *prev;
138 struct teql_sched_data *dat = qdisc_priv(sch);
139 struct teql_master *master = dat->m;
140
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000141 prev = master->slaves;
142 if (prev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 do {
144 q = NEXT_SLAVE(prev);
145 if (q == sch) {
146 NEXT_SLAVE(prev) = NEXT_SLAVE(q);
147 if (q == master->slaves) {
148 master->slaves = NEXT_SLAVE(q);
149 if (q == master->slaves) {
David S. Millere8a04642008-07-17 00:34:19 -0700150 struct netdev_queue *txq;
David S. Miller83874002008-07-17 00:53:03 -0700151 spinlock_t *root_lock;
David S. Millere8a04642008-07-17 00:34:19 -0700152
153 txq = netdev_get_tx_queue(master->dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 master->slaves = NULL;
David S. Miller83874002008-07-17 00:53:03 -0700155
John Fastabend46e5da42014-09-12 20:04:52 -0700156 root_lock = qdisc_root_sleeping_lock(rtnl_dereference(txq->qdisc));
David S. Miller83874002008-07-17 00:53:03 -0700157 spin_lock_bh(root_lock);
John Fastabend46e5da42014-09-12 20:04:52 -0700158 qdisc_reset(rtnl_dereference(txq->qdisc));
David S. Miller83874002008-07-17 00:53:03 -0700159 spin_unlock_bh(root_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 }
161 }
162 skb_queue_purge(&dat->q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 break;
164 }
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 } while ((prev = q) != master->slaves);
167 }
168}
169
Patrick McHardy1e904742008-01-22 22:11:17 -0800170static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
David S. Miller5ce2d482008-07-08 17:06:30 -0700172 struct net_device *dev = qdisc_dev(sch);
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000173 struct teql_master *m = (struct teql_master *)sch->ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 struct teql_sched_data *q = qdisc_priv(sch);
175
176 if (dev->hard_header_len > m->dev->hard_header_len)
177 return -EINVAL;
178
179 if (m->dev == dev)
180 return -ELOOP;
181
182 q->m = m;
183
184 skb_queue_head_init(&q->q);
185
186 if (m->slaves) {
187 if (m->dev->flags & IFF_UP) {
Joe Perchesf64f9e72009-11-29 16:55:45 -0800188 if ((m->dev->flags & IFF_POINTOPOINT &&
189 !(dev->flags & IFF_POINTOPOINT)) ||
190 (m->dev->flags & IFF_BROADCAST &&
191 !(dev->flags & IFF_BROADCAST)) ||
192 (m->dev->flags & IFF_MULTICAST &&
193 !(dev->flags & IFF_MULTICAST)) ||
194 dev->mtu < m->dev->mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 return -EINVAL;
196 } else {
197 if (!(dev->flags&IFF_POINTOPOINT))
198 m->dev->flags &= ~IFF_POINTOPOINT;
199 if (!(dev->flags&IFF_BROADCAST))
200 m->dev->flags &= ~IFF_BROADCAST;
201 if (!(dev->flags&IFF_MULTICAST))
202 m->dev->flags &= ~IFF_MULTICAST;
203 if (dev->mtu < m->dev->mtu)
204 m->dev->mtu = dev->mtu;
205 }
206 q->next = NEXT_SLAVE(m->slaves);
207 NEXT_SLAVE(m->slaves) = sch;
208 } else {
209 q->next = sch;
210 m->slaves = sch;
211 m->dev->mtu = dev->mtu;
212 m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK);
213 }
214 return 0;
215}
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
218static int
Eric Dumazetf7e57042011-11-30 04:08:58 +0000219__teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res,
220 struct net_device *dev, struct netdev_queue *txq,
David S. Millerdbedbe6d2012-07-02 21:57:45 -0700221 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
David S. Millerdbedbe6d2012-07-02 21:57:45 -0700223 struct neighbour *n;
224 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
David S. Millerdbedbe6d2012-07-02 21:57:45 -0700226 n = dst_neigh_lookup_skb(dst, skb);
227 if (!n)
228 return -ENOENT;
229
230 if (dst->dev != dev) {
231 struct neighbour *mn;
232
233 mn = __neigh_lookup_errno(n->tbl, n->primary_key, dev);
234 neigh_release(n);
235 if (IS_ERR(mn))
236 return PTR_ERR(mn);
237 n = mn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
David S. Millerdbedbe6d2012-07-02 21:57:45 -0700239
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 if (neigh_event_send(n, skb_res) == 0) {
241 int err;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000242 char haddr[MAX_ADDR_LEN];
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700243
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000244 neigh_ha_snapshot(haddr, n, dev);
Jiri Pirkod8b96052015-01-13 17:13:43 +0100245 err = dev_hard_header(skb, dev, ntohs(tc_skb_protocol(skb)),
246 haddr, NULL, skb->len);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700247
David S. Millerdbedbe6d2012-07-02 21:57:45 -0700248 if (err < 0)
249 err = -EINVAL;
250 } else {
251 err = (skb_res == NULL) ? -EAGAIN : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253 neigh_release(n);
David S. Millerdbedbe6d2012-07-02 21:57:45 -0700254 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255}
256
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700257static inline int teql_resolve(struct sk_buff *skb,
Eric Dumazetf7e57042011-11-30 04:08:58 +0000258 struct sk_buff *skb_res,
259 struct net_device *dev,
260 struct netdev_queue *txq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
Eric Dumazetf7e57042011-11-30 04:08:58 +0000262 struct dst_entry *dst = skb_dst(skb);
Eric Dumazetf7e57042011-11-30 04:08:58 +0000263 int res;
264
John Fastabend46e5da42014-09-12 20:04:52 -0700265 if (rcu_access_pointer(txq->qdisc) == &noop_qdisc)
Evgeniy Polyakov4f9f8312007-11-06 03:08:09 -0800266 return -ENODEV;
267
Eric Dumazetf7e57042011-11-30 04:08:58 +0000268 if (!dev->header_ops || !dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 return 0;
Eric Dumazetf7e57042011-11-30 04:08:58 +0000270
271 rcu_read_lock();
David S. Millerdbedbe6d2012-07-02 21:57:45 -0700272 res = __teql_resolve(skb, skb_res, dev, txq, dst);
Eric Dumazetf7e57042011-11-30 04:08:58 +0000273 rcu_read_unlock();
274
275 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276}
277
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000278static netdev_tx_t teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Patrick McHardy2941a482006-01-08 22:05:26 -0800280 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 struct Qdisc *start, *q;
282 int busy;
283 int nores;
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -0700284 int subq = skb_get_queue_mapping(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 struct sk_buff *skb_res = NULL;
286
287 start = master->slaves;
288
289restart:
290 nores = 0;
291 busy = 0;
292
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000293 q = start;
294 if (!q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 goto drop;
296
297 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700298 struct net_device *slave = qdisc_dev(q);
Stephen Hemminger61294e22009-01-06 10:45:57 -0800299 struct netdev_queue *slave_txq = netdev_get_tx_queue(slave, 0);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900300
David S. Millere8a04642008-07-17 00:34:19 -0700301 if (slave_txq->qdisc_sleeping != q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 continue;
Tom Herbert734664982011-11-28 16:32:44 +0000303 if (netif_xmit_stopped(netdev_get_tx_queue(slave, subq)) ||
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700304 !netif_running(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 busy = 1;
306 continue;
307 }
308
Eric Dumazetf7e57042011-11-30 04:08:58 +0000309 switch (teql_resolve(skb, skb_res, slave, slave_txq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 case 0:
David S. Millerc3f26a22008-07-31 16:58:50 -0700311 if (__netif_tx_trylock(slave_txq)) {
Eric Dumazetc0f84d02009-05-18 15:12:31 -0700312 unsigned int length = qdisc_pkt_len(skb);
313
Tom Herbert734664982011-11-28 16:32:44 +0000314 if (!netif_xmit_frozen_or_stopped(slave_txq) &&
David S. Millerfa2dbdc2014-08-29 21:55:22 -0700315 netdev_start_xmit(skb, slave, slave_txq, false) ==
316 NETDEV_TX_OK) {
David S. Millerc3f26a22008-07-31 16:58:50 -0700317 __netif_tx_unlock(slave_txq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 master->slaves = NEXT_SLAVE(q);
319 netif_wake_queue(dev);
Eric Dumazet1ac9ad12011-01-12 12:13:14 +0000320 master->tx_packets++;
321 master->tx_bytes += length;
Patrick McHardy6ed10652009-06-23 06:03:08 +0000322 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 }
David S. Millerc3f26a22008-07-31 16:58:50 -0700324 __netif_tx_unlock(slave_txq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 }
Tom Herbert734664982011-11-28 16:32:44 +0000326 if (netif_xmit_stopped(netdev_get_tx_queue(dev, 0)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 busy = 1;
328 break;
329 case 1:
330 master->slaves = NEXT_SLAVE(q);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000331 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 default:
333 nores = 1;
334 break;
335 }
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300336 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 } while ((q = NEXT_SLAVE(q)) != start);
338
339 if (nores && skb_res == NULL) {
340 skb_res = skb;
341 goto restart;
342 }
343
344 if (busy) {
345 netif_stop_queue(dev);
Patrick McHardy5b548142009-06-12 06:22:29 +0000346 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 }
Eric Dumazet1ac9ad12011-01-12 12:13:14 +0000348 master->tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350drop:
Eric Dumazet1ac9ad12011-01-12 12:13:14 +0000351 master->tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000353 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354}
355
356static int teql_master_open(struct net_device *dev)
357{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000358 struct Qdisc *q;
Patrick McHardy2941a482006-01-08 22:05:26 -0800359 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 int mtu = 0xFFFE;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000361 unsigned int flags = IFF_NOARP | IFF_MULTICAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
363 if (m->slaves == NULL)
364 return -EUNATCH;
365
366 flags = FMASK;
367
368 q = m->slaves;
369 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700370 struct net_device *slave = qdisc_dev(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
372 if (slave == NULL)
373 return -EUNATCH;
374
375 if (slave->mtu < mtu)
376 mtu = slave->mtu;
377 if (slave->hard_header_len > LL_MAX_HEADER)
378 return -EINVAL;
379
380 /* If all the slaves are BROADCAST, master is BROADCAST
381 If all the slaves are PtP, master is PtP
382 Otherwise, master is NBMA.
383 */
384 if (!(slave->flags&IFF_POINTOPOINT))
385 flags &= ~IFF_POINTOPOINT;
386 if (!(slave->flags&IFF_BROADCAST))
387 flags &= ~IFF_BROADCAST;
388 if (!(slave->flags&IFF_MULTICAST))
389 flags &= ~IFF_MULTICAST;
390 } while ((q = NEXT_SLAVE(q)) != m->slaves);
391
392 m->dev->mtu = mtu;
393 m->dev->flags = (m->dev->flags&~FMASK) | flags;
394 netif_start_queue(m->dev);
395 return 0;
396}
397
398static int teql_master_close(struct net_device *dev)
399{
400 netif_stop_queue(dev);
401 return 0;
402}
403
Eric Dumazet1ac9ad12011-01-12 12:13:14 +0000404static struct rtnl_link_stats64 *teql_master_stats64(struct net_device *dev,
405 struct rtnl_link_stats64 *stats)
406{
407 struct teql_master *m = netdev_priv(dev);
408
409 stats->tx_packets = m->tx_packets;
410 stats->tx_bytes = m->tx_bytes;
411 stats->tx_errors = m->tx_errors;
412 stats->tx_dropped = m->tx_dropped;
413 return stats;
414}
415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416static int teql_master_mtu(struct net_device *dev, int new_mtu)
417{
Patrick McHardy2941a482006-01-08 22:05:26 -0800418 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 struct Qdisc *q;
420
421 if (new_mtu < 68)
422 return -EINVAL;
423
424 q = m->slaves;
425 if (q) {
426 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700427 if (new_mtu > qdisc_dev(q)->mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 return -EINVAL;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000429 } while ((q = NEXT_SLAVE(q)) != m->slaves);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 }
431
432 dev->mtu = new_mtu;
433 return 0;
434}
435
Stephen Hemminger61294e22009-01-06 10:45:57 -0800436static const struct net_device_ops teql_netdev_ops = {
437 .ndo_open = teql_master_open,
438 .ndo_stop = teql_master_close,
439 .ndo_start_xmit = teql_master_xmit,
Eric Dumazet1ac9ad12011-01-12 12:13:14 +0000440 .ndo_get_stats64 = teql_master_stats64,
Stephen Hemminger61294e22009-01-06 10:45:57 -0800441 .ndo_change_mtu = teql_master_mtu,
442};
443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444static __init void teql_master_setup(struct net_device *dev)
445{
Patrick McHardy2941a482006-01-08 22:05:26 -0800446 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 struct Qdisc_ops *ops = &master->qops;
448
449 master->dev = dev;
450 ops->priv_size = sizeof(struct teql_sched_data);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900451
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 ops->enqueue = teql_enqueue;
453 ops->dequeue = teql_dequeue;
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700454 ops->peek = teql_peek;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 ops->init = teql_qdisc_init;
456 ops->reset = teql_reset;
457 ops->destroy = teql_destroy;
458 ops->owner = THIS_MODULE;
459
Stephen Hemminger61294e22009-01-06 10:45:57 -0800460 dev->netdev_ops = &teql_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 dev->type = ARPHRD_VOID;
462 dev->mtu = 1500;
463 dev->tx_queue_len = 100;
464 dev->flags = IFF_NOARP;
465 dev->hard_header_len = LL_MAX_HEADER;
Eric Dumazet02875872014-10-05 18:38:35 -0700466 netif_keep_dst(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467}
468
469static LIST_HEAD(master_dev_list);
470static int max_equalizers = 1;
471module_param(max_equalizers, int, 0);
472MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
473
474static int __init teql_init(void)
475{
476 int i;
477 int err = -ENODEV;
478
479 for (i = 0; i < max_equalizers; i++) {
480 struct net_device *dev;
481 struct teql_master *master;
482
Tom Gundersenc835a672014-07-14 16:37:24 +0200483 dev = alloc_netdev(sizeof(struct teql_master), "teql%d",
484 NET_NAME_UNKNOWN, teql_master_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 if (!dev) {
486 err = -ENOMEM;
487 break;
488 }
489
490 if ((err = register_netdev(dev))) {
491 free_netdev(dev);
492 break;
493 }
494
Patrick McHardy2941a482006-01-08 22:05:26 -0800495 master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
497 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
498 err = register_qdisc(&master->qops);
499
500 if (err) {
501 unregister_netdev(dev);
502 free_netdev(dev);
503 break;
504 }
505
506 list_add_tail(&master->master_list, &master_dev_list);
507 }
508 return i ? 0 : err;
509}
510
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900511static void __exit teql_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
513 struct teql_master *master, *nxt;
514
515 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
516
517 list_del(&master->master_list);
518
519 unregister_qdisc(&master->qops);
520 unregister_netdev(master->dev);
521 free_netdev(master->dev);
522 }
523}
524
525module_init(teql_init);
526module_exit(teql_exit);
527
528MODULE_LICENSE("GPL");