2 * Simple traffic shaper for Linux NET3.
4 * (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
5 * http://www.redhat.com
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
12 * Neither Alan Cox nor CymruNet Ltd. admit liability nor provide
13 * warranty for any of this software. This material is provided
14 * "AS-IS" and at no charge.
20 * Compute time length of frame at regulated speed
21 * Add frame to queue at appropriate point
22 * Adjust time length computation for followup frames
23 * Any frame that falls outside of its boundaries is freed
25 * We work to the following constants
27 * SHAPER_QLEN Maximum queued frames
28 * SHAPER_LATENCY Bounding latency on a frame. Leaving this latency
29 * window drops the frame. This stops us queueing
30 * frames for a long time and confusing a remote
32 * SHAPER_MAXSLIP Maximum time a priority frame may jump forward.
33 * That bounds the penalty we will inflict on low
35 * SHAPER_BURST Time range we call "now" in order to reduce
36 * system load. The more we make this the burstier
37 * the behaviour, the better local performance you
38 * get through packet clustering on routers and the
39 * worse the remote end gets to judge rtts.
41 * This is designed to handle lower speed links ( < 200K/second or so). We
42 * run off a 100-150Hz base clock typically. This gives us a resolution at
43 * 200Kbit/second of about 2Kbit or 256 bytes. Above that our timer
44 * resolution may start to cause much more burstiness in the traffic. We
45 * could avoid a lot of that by calling kick_shaper() at the end of the
46 * tied device transmissions. If you run above about 100K second you
47 * may need to tune the supposed speed rate for the right values.
50 * Downing the interface under the shaper before the shaper
51 * will render your machine defunct. Don't for now shape over
52 * PPP or SLIP therefore!
53 * This will be fixed in BETA4
57 * bh_atomic() SMP races fixes and rewritten the locking code to
58 * be SMP safe and irq-mask friendly.
59 * NOTE: we can't use start_bh_atomic() in kick_shaper()
60 * because it's going to be recalled from an irq handler,
61 * and synchronize_bh() is a nono if called from irq context.
62 * 1999 Andrea Arcangeli
64 * Device statistics (tx_pakets, tx_bytes,
65 * tx_drops: queue_over_time and collisions: max_queue_exceded)
66 * 1999/06/18 Jordi Murgo <savage@apostols.org>
68 * Use skb->cb for private data.
72 #include <linux/module.h>
73 #include <linux/kernel.h>
74 #include <linux/fcntl.h>
76 #include <linux/slab.h>
77 #include <linux/string.h>
78 #include <linux/errno.h>
79 #include <linux/netdevice.h>
80 #include <linux/etherdevice.h>
81 #include <linux/skbuff.h>
82 #include <linux/if_arp.h>
83 #include <linux/init.h>
84 #include <linux/if_shaper.h>
85 #include <linux/jiffies.h>
91 unsigned long shapeclock
; /* Time it should go out */
92 unsigned long shapestamp
; /* Stamp for shaper */
93 __u32 shapelatency
; /* Latency on frame */
94 __u32 shapelen
; /* Frame length in clocks */
95 __u16 shapepend
; /* Pending */
97 #define SHAPERCB(skb) ((struct shaper_cb *) ((skb)->cb))
99 static int sh_debug
; /* Debug flag */
101 #define SHAPER_BANNER "CymruNet Traffic Shaper BETA 0.04 for Linux 2.1\n"
103 static void shaper_kick(struct shaper
*sh
);
106 * Compute clocks on a buffer
109 static int shaper_clocks(struct shaper
*shaper
, struct sk_buff
*skb
)
111 int t
=skb
->len
/shaper
->bytespertick
;
116 * Set the speed of a shaper. We compute this in bytes per tick since
117 * thats how the machine wants to run. Quoted input is in bits per second
118 * as is traditional (note not BAUD). We assume 8 bit bytes.
121 static void shaper_setspeed(struct shaper
*shaper
, int bitspersec
)
123 shaper
->bitspersec
=bitspersec
;
124 shaper
->bytespertick
=(bitspersec
/HZ
)/8;
125 if(!shaper
->bytespertick
)
126 shaper
->bytespertick
++;
130 * Throw a frame at a shaper.
134 static int shaper_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
136 struct shaper
*shaper
= dev
->priv
;
139 spin_lock(&shaper
->lock
);
140 ptr
=shaper
->sendq
.prev
;
143 * Set up our packet details
146 SHAPERCB(skb
)->shapelatency
=0;
147 SHAPERCB(skb
)->shapeclock
=shaper
->recovery
;
148 if(time_before(SHAPERCB(skb
)->shapeclock
, jiffies
))
149 SHAPERCB(skb
)->shapeclock
=jiffies
;
150 skb
->priority
=0; /* short term bug fix */
151 SHAPERCB(skb
)->shapestamp
=jiffies
;
154 * Time slots for this packet.
157 SHAPERCB(skb
)->shapelen
= shaper_clocks(shaper
,skb
);
162 * Up our shape clock by the time pending on the queue
163 * (Should keep this in the shaper as a variable..)
165 for(tmp
=skb_peek(&shaper
->sendq
); tmp
!=NULL
&&
166 tmp
!=(struct sk_buff
*)&shaper
->sendq
; tmp
=tmp
->next
)
167 SHAPERCB(skb
)->shapeclock
+=SHAPERCB(tmp
)->shapelen
;
169 * Queue over time. Spill packet.
171 if(time_after(SHAPERCB(skb
)->shapeclock
,jiffies
+ SHAPER_LATENCY
)) {
173 shaper
->stats
.tx_dropped
++;
175 skb_queue_tail(&shaper
->sendq
, skb
);
179 printk("Frame queued.\n");
180 if(skb_queue_len(&shaper
->sendq
)>SHAPER_QLEN
)
182 ptr
=skb_dequeue(&shaper
->sendq
);
184 shaper
->stats
.collisions
++;
187 spin_unlock(&shaper
->lock
);
192 * Transmit from a shaper
195 static void shaper_queue_xmit(struct shaper
*shaper
, struct sk_buff
*skb
)
197 struct sk_buff
*newskb
=skb_clone(skb
, GFP_ATOMIC
);
199 printk("Kick frame on %p\n",newskb
);
202 newskb
->dev
=shaper
->dev
;
205 printk("Kick new frame to %s, %d\n",
206 shaper
->dev
->name
,newskb
->priority
);
207 dev_queue_xmit(newskb
);
209 shaper
->stats
.tx_bytes
+= skb
->len
;
210 shaper
->stats
.tx_packets
++;
213 printk("Kicked new frame out.\n");
219 * Timer handler for shaping clock
222 static void shaper_timer(unsigned long data
)
224 struct shaper
*shaper
= (struct shaper
*)data
;
226 spin_lock(&shaper
->lock
);
228 spin_unlock(&shaper
->lock
);
232 * Kick a shaper queue and try and do something sensible with the
236 static void shaper_kick(struct shaper
*shaper
)
241 * Walk the list (may be empty)
244 while((skb
=skb_peek(&shaper
->sendq
))!=NULL
)
247 * Each packet due to go out by now (within an error
248 * of SHAPER_BURST) gets kicked onto the link
252 printk("Clock = %ld, jiffies = %ld\n", SHAPERCB(skb
)->shapeclock
, jiffies
);
253 if(time_before_eq(SHAPERCB(skb
)->shapeclock
, jiffies
+ SHAPER_BURST
))
256 * Pull the frame and get interrupts back on.
259 skb_unlink(skb
, &shaper
->sendq
);
260 if (shaper
->recovery
<
261 SHAPERCB(skb
)->shapeclock
+ SHAPERCB(skb
)->shapelen
)
262 shaper
->recovery
= SHAPERCB(skb
)->shapeclock
+ SHAPERCB(skb
)->shapelen
;
264 * Pass on to the physical target device via
265 * our low level packet thrower.
268 SHAPERCB(skb
)->shapepend
=0;
269 shaper_queue_xmit(shaper
, skb
); /* Fire */
280 mod_timer(&shaper
->timer
, SHAPERCB(skb
)->shapeclock
);
285 * Bring the interface up. We just disallow this until a
289 static int shaper_open(struct net_device
*dev
)
291 struct shaper
*shaper
=dev
->priv
;
294 * Can't open until attached.
295 * Also can't open until speed is set, or we'll get
296 * a division by zero.
299 if(shaper
->dev
==NULL
)
301 if(shaper
->bitspersec
==0)
307 * Closing a shaper flushes the queues.
310 static int shaper_close(struct net_device
*dev
)
312 struct shaper
*shaper
=dev
->priv
;
315 while ((skb
= skb_dequeue(&shaper
->sendq
)) != NULL
)
318 spin_lock_bh(&shaper
->lock
);
320 spin_unlock_bh(&shaper
->lock
);
322 del_timer_sync(&shaper
->timer
);
327 * Revectored calls. We alter the parameters and call the functions
328 * for our attached device. This enables us to bandwidth allocate after
329 * ARP and other resolutions and not before.
332 static struct net_device_stats
*shaper_get_stats(struct net_device
*dev
)
334 struct shaper
*sh
=dev
->priv
;
338 static int shaper_header(struct sk_buff
*skb
, struct net_device
*dev
,
339 unsigned short type
, void *daddr
, void *saddr
, unsigned len
)
341 struct shaper
*sh
=dev
->priv
;
344 printk("Shaper header\n");
346 v
=sh
->hard_header(skb
,sh
->dev
,type
,daddr
,saddr
,len
);
351 static int shaper_rebuild_header(struct sk_buff
*skb
)
353 struct shaper
*sh
=skb
->dev
->priv
;
354 struct net_device
*dev
=skb
->dev
;
357 printk("Shaper rebuild header\n");
359 v
=sh
->rebuild_header(skb
);
365 static int shaper_cache(struct neighbour
*neigh
, struct hh_cache
*hh
)
367 struct shaper
*sh
=neigh
->dev
->priv
;
368 struct net_device
*tmp
;
371 printk("Shaper header cache bind\n");
374 ret
=sh
->hard_header_cache(neigh
,hh
);
379 static void shaper_cache_update(struct hh_cache
*hh
, struct net_device
*dev
,
380 unsigned char *haddr
)
382 struct shaper
*sh
=dev
->priv
;
384 printk("Shaper cache update\n");
385 sh
->header_cache_update(hh
, sh
->dev
, haddr
);
391 static int shaper_neigh_setup(struct neighbour
*n
)
394 if (n
->nud_state
== NUD_NONE
) {
395 n
->ops
= &arp_broken_ops
;
396 n
->output
= n
->ops
->output
;
402 static int shaper_neigh_setup_dev(struct net_device
*dev
, struct neigh_parms
*p
)
405 if (p
->tbl
->family
== AF_INET
) {
406 p
->neigh_setup
= shaper_neigh_setup
;
414 #else /* !(CONFIG_INET) */
416 static int shaper_neigh_setup_dev(struct net_device
*dev
, struct neigh_parms
*p
)
423 static int shaper_attach(struct net_device
*shdev
, struct shaper
*sh
, struct net_device
*dev
)
426 sh
->hard_start_xmit
=dev
->hard_start_xmit
;
427 sh
->get_stats
=dev
->get_stats
;
430 sh
->hard_header
=dev
->hard_header
;
431 shdev
->hard_header
= shaper_header
;
434 shdev
->hard_header
= NULL
;
436 if(dev
->rebuild_header
)
438 sh
->rebuild_header
= dev
->rebuild_header
;
439 shdev
->rebuild_header
= shaper_rebuild_header
;
442 shdev
->rebuild_header
= NULL
;
445 if(dev
->hard_header_cache
)
447 sh
->hard_header_cache
= dev
->hard_header_cache
;
448 shdev
->hard_header_cache
= shaper_cache
;
452 shdev
->hard_header_cache
= NULL
;
455 if(dev
->header_cache_update
)
457 sh
->header_cache_update
= dev
->header_cache_update
;
458 shdev
->header_cache_update
= shaper_cache_update
;
461 shdev
->header_cache_update
= NULL
;
463 shdev
->header_cache_update
= NULL
;
464 shdev
->hard_header_cache
= NULL
;
466 shdev
->neigh_setup
= shaper_neigh_setup_dev
;
468 shdev
->hard_header_len
=dev
->hard_header_len
;
469 shdev
->type
=dev
->type
;
470 shdev
->addr_len
=dev
->addr_len
;
476 static int shaper_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
478 struct shaperconf
*ss
= (struct shaperconf
*)&ifr
->ifr_ifru
;
479 struct shaper
*sh
=dev
->priv
;
481 if(ss
->ss_cmd
== SHAPER_SET_DEV
|| ss
->ss_cmd
== SHAPER_SET_SPEED
)
483 if(!capable(CAP_NET_ADMIN
))
491 struct net_device
*them
=__dev_get_by_name(ss
->ss_name
);
496 return shaper_attach(dev
,dev
->priv
, them
);
501 strcpy(ss
->ss_name
, sh
->dev
->name
);
503 case SHAPER_SET_SPEED
:
504 shaper_setspeed(sh
,ss
->ss_speed
);
506 case SHAPER_GET_SPEED
:
507 ss
->ss_speed
=sh
->bitspersec
;
514 static void shaper_init_priv(struct net_device
*dev
)
516 struct shaper
*sh
= dev
->priv
;
518 skb_queue_head_init(&sh
->sendq
);
519 init_timer(&sh
->timer
);
520 sh
->timer
.function
=shaper_timer
;
521 sh
->timer
.data
=(unsigned long)sh
;
522 spin_lock_init(&sh
->lock
);
526 * Add a shaper device to the system
529 static void __init
shaper_setup(struct net_device
*dev
)
535 SET_MODULE_OWNER(dev
);
537 shaper_init_priv(dev
);
539 dev
->open
= shaper_open
;
540 dev
->stop
= shaper_close
;
541 dev
->hard_start_xmit
= shaper_start_xmit
;
542 dev
->get_stats
= shaper_get_stats
;
543 dev
->set_multicast_list
= NULL
;
546 * Intialise the packet queues
550 * Handlers for when we attach to a device.
553 dev
->hard_header
= shaper_header
;
554 dev
->rebuild_header
= shaper_rebuild_header
;
556 dev
->hard_header_cache
= shaper_cache
;
557 dev
->header_cache_update
= shaper_cache_update
;
559 dev
->neigh_setup
= shaper_neigh_setup_dev
;
560 dev
->do_ioctl
= shaper_ioctl
;
561 dev
->hard_header_len
= 0;
562 dev
->type
= ARPHRD_ETHER
; /* initially */
563 dev
->set_mac_address
= NULL
;
566 dev
->tx_queue_len
= 10;
570 static int shapers
= 1;
573 module_param(shapers
, int, 0);
574 MODULE_PARM_DESC(shapers
, "Traffic shaper: maximum number of shapers");
578 static int __init
set_num_shapers(char *str
)
580 shapers
= simple_strtol(str
, NULL
, 0);
584 __setup("shapers=", set_num_shapers
);
588 static struct net_device
**devs
;
590 static unsigned int shapers_registered
= 0;
592 static int __init
shaper_init(void)
596 struct net_device
*dev
;
602 alloc_size
= sizeof(*dev
) * shapers
;
603 devs
= kzalloc(alloc_size
, GFP_KERNEL
);
607 for (i
= 0; i
< shapers
; i
++) {
609 snprintf(name
, IFNAMSIZ
, "shaper%d", i
);
610 dev
= alloc_netdev(sizeof(struct shaper
), name
,
615 if (register_netdev(dev
)) {
621 shapers_registered
++;
624 if (!shapers_registered
) {
629 return (shapers_registered
? 0 : -ENODEV
);
632 static void __exit
shaper_exit (void)
636 for (i
= 0; i
< shapers_registered
; i
++) {
638 unregister_netdev(devs
[i
]);
639 free_netdev(devs
[i
]);
647 module_init(shaper_init
);
648 module_exit(shaper_exit
);
649 MODULE_LICENSE("GPL");
This page took 0.043601 seconds and 5 git commands to generate.