ia64/linux-2.6.18-xen.hg

view drivers/net/shaper.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 * Simple traffic shaper for Linux NET3.
3 *
4 * (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
5 * http://www.redhat.com
6 *
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.
11 *
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.
15 *
16 *
17 * Algorithm:
18 *
19 * Queue Frame:
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
24 *
25 * We work to the following constants
26 *
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
31 * host.
32 * SHAPER_MAXSLIP Maximum time a priority frame may jump forward.
33 * That bounds the penalty we will inflict on low
34 * priority traffic.
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.
40 *
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.
48 *
49 * BUGS:
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
54 *
55 * Update History :
56 *
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
63 *
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>
67 *
68 * Use skb->cb for private data.
69 * 2000/03 Andi Kleen
70 */
72 #include <linux/module.h>
73 #include <linux/kernel.h>
74 #include <linux/fcntl.h>
75 #include <linux/mm.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>
87 #include <net/dst.h>
88 #include <net/arp.h>
90 struct shaper_cb {
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 */
96 };
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);
105 /*
106 * Compute clocks on a buffer
107 */
109 static int shaper_clocks(struct shaper *shaper, struct sk_buff *skb)
110 {
111 int t=skb->len/shaper->bytespertick;
112 return t;
113 }
115 /*
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.
119 */
121 static void shaper_setspeed(struct shaper *shaper, int bitspersec)
122 {
123 shaper->bitspersec=bitspersec;
124 shaper->bytespertick=(bitspersec/HZ)/8;
125 if(!shaper->bytespertick)
126 shaper->bytespertick++;
127 }
129 /*
130 * Throw a frame at a shaper.
131 */
134 static int shaper_start_xmit(struct sk_buff *skb, struct net_device *dev)
135 {
136 struct shaper *shaper = dev->priv;
137 struct sk_buff *ptr;
139 spin_lock(&shaper->lock);
140 ptr=shaper->sendq.prev;
142 /*
143 * Set up our packet details
144 */
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;
153 /*
154 * Time slots for this packet.
155 */
157 SHAPERCB(skb)->shapelen= shaper_clocks(shaper,skb);
159 {
160 struct sk_buff *tmp;
161 /*
162 * Up our shape clock by the time pending on the queue
163 * (Should keep this in the shaper as a variable..)
164 */
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;
168 /*
169 * Queue over time. Spill packet.
170 */
171 if(time_after(SHAPERCB(skb)->shapeclock,jiffies + SHAPER_LATENCY)) {
172 dev_kfree_skb(skb);
173 shaper->stats.tx_dropped++;
174 } else
175 skb_queue_tail(&shaper->sendq, skb);
176 }
178 if(sh_debug)
179 printk("Frame queued.\n");
180 if(skb_queue_len(&shaper->sendq)>SHAPER_QLEN)
181 {
182 ptr=skb_dequeue(&shaper->sendq);
183 dev_kfree_skb(ptr);
184 shaper->stats.collisions++;
185 }
186 shaper_kick(shaper);
187 spin_unlock(&shaper->lock);
188 return 0;
189 }
191 /*
192 * Transmit from a shaper
193 */
195 static void shaper_queue_xmit(struct shaper *shaper, struct sk_buff *skb)
196 {
197 struct sk_buff *newskb=skb_clone(skb, GFP_ATOMIC);
198 if(sh_debug)
199 printk("Kick frame on %p\n",newskb);
200 if(newskb)
201 {
202 newskb->dev=shaper->dev;
203 newskb->priority=2;
204 if(sh_debug)
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++;
212 if(sh_debug)
213 printk("Kicked new frame out.\n");
214 dev_kfree_skb(skb);
215 }
216 }
218 /*
219 * Timer handler for shaping clock
220 */
222 static void shaper_timer(unsigned long data)
223 {
224 struct shaper *shaper = (struct shaper *)data;
226 spin_lock(&shaper->lock);
227 shaper_kick(shaper);
228 spin_unlock(&shaper->lock);
229 }
231 /*
232 * Kick a shaper queue and try and do something sensible with the
233 * queue.
234 */
236 static void shaper_kick(struct shaper *shaper)
237 {
238 struct sk_buff *skb;
240 /*
241 * Walk the list (may be empty)
242 */
244 while((skb=skb_peek(&shaper->sendq))!=NULL)
245 {
246 /*
247 * Each packet due to go out by now (within an error
248 * of SHAPER_BURST) gets kicked onto the link
249 */
251 if(sh_debug)
252 printk("Clock = %ld, jiffies = %ld\n", SHAPERCB(skb)->shapeclock, jiffies);
253 if(time_before_eq(SHAPERCB(skb)->shapeclock, jiffies + SHAPER_BURST))
254 {
255 /*
256 * Pull the frame and get interrupts back on.
257 */
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;
263 /*
264 * Pass on to the physical target device via
265 * our low level packet thrower.
266 */
268 SHAPERCB(skb)->shapepend=0;
269 shaper_queue_xmit(shaper, skb); /* Fire */
270 }
271 else
272 break;
273 }
275 /*
276 * Next kick.
277 */
279 if(skb!=NULL)
280 mod_timer(&shaper->timer, SHAPERCB(skb)->shapeclock);
281 }
284 /*
285 * Bring the interface up. We just disallow this until a
286 * bind.
287 */
289 static int shaper_open(struct net_device *dev)
290 {
291 struct shaper *shaper=dev->priv;
293 /*
294 * Can't open until attached.
295 * Also can't open until speed is set, or we'll get
296 * a division by zero.
297 */
299 if(shaper->dev==NULL)
300 return -ENODEV;
301 if(shaper->bitspersec==0)
302 return -EINVAL;
303 return 0;
304 }
306 /*
307 * Closing a shaper flushes the queues.
308 */
310 static int shaper_close(struct net_device *dev)
311 {
312 struct shaper *shaper=dev->priv;
313 struct sk_buff *skb;
315 while ((skb = skb_dequeue(&shaper->sendq)) != NULL)
316 dev_kfree_skb(skb);
318 spin_lock_bh(&shaper->lock);
319 shaper_kick(shaper);
320 spin_unlock_bh(&shaper->lock);
322 del_timer_sync(&shaper->timer);
323 return 0;
324 }
326 /*
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.
330 */
332 static struct net_device_stats *shaper_get_stats(struct net_device *dev)
333 {
334 struct shaper *sh=dev->priv;
335 return &sh->stats;
336 }
338 static int shaper_header(struct sk_buff *skb, struct net_device *dev,
339 unsigned short type, void *daddr, void *saddr, unsigned len)
340 {
341 struct shaper *sh=dev->priv;
342 int v;
343 if(sh_debug)
344 printk("Shaper header\n");
345 skb->dev=sh->dev;
346 v=sh->hard_header(skb,sh->dev,type,daddr,saddr,len);
347 skb->dev=dev;
348 return v;
349 }
351 static int shaper_rebuild_header(struct sk_buff *skb)
352 {
353 struct shaper *sh=skb->dev->priv;
354 struct net_device *dev=skb->dev;
355 int v;
356 if(sh_debug)
357 printk("Shaper rebuild header\n");
358 skb->dev=sh->dev;
359 v=sh->rebuild_header(skb);
360 skb->dev=dev;
361 return v;
362 }
364 #if 0
365 static int shaper_cache(struct neighbour *neigh, struct hh_cache *hh)
366 {
367 struct shaper *sh=neigh->dev->priv;
368 struct net_device *tmp;
369 int ret;
370 if(sh_debug)
371 printk("Shaper header cache bind\n");
372 tmp=neigh->dev;
373 neigh->dev=sh->dev;
374 ret=sh->hard_header_cache(neigh,hh);
375 neigh->dev=tmp;
376 return ret;
377 }
379 static void shaper_cache_update(struct hh_cache *hh, struct net_device *dev,
380 unsigned char *haddr)
381 {
382 struct shaper *sh=dev->priv;
383 if(sh_debug)
384 printk("Shaper cache update\n");
385 sh->header_cache_update(hh, sh->dev, haddr);
386 }
387 #endif
389 #ifdef CONFIG_INET
391 static int shaper_neigh_setup(struct neighbour *n)
392 {
393 #ifdef CONFIG_INET
394 if (n->nud_state == NUD_NONE) {
395 n->ops = &arp_broken_ops;
396 n->output = n->ops->output;
397 }
398 #endif
399 return 0;
400 }
402 static int shaper_neigh_setup_dev(struct net_device *dev, struct neigh_parms *p)
403 {
404 #ifdef CONFIG_INET
405 if (p->tbl->family == AF_INET) {
406 p->neigh_setup = shaper_neigh_setup;
407 p->ucast_probes = 0;
408 p->mcast_probes = 0;
409 }
410 #endif
411 return 0;
412 }
414 #else /* !(CONFIG_INET) */
416 static int shaper_neigh_setup_dev(struct net_device *dev, struct neigh_parms *p)
417 {
418 return 0;
419 }
421 #endif
423 static int shaper_attach(struct net_device *shdev, struct shaper *sh, struct net_device *dev)
424 {
425 sh->dev = dev;
426 sh->hard_start_xmit=dev->hard_start_xmit;
427 sh->get_stats=dev->get_stats;
428 if(dev->hard_header)
429 {
430 sh->hard_header=dev->hard_header;
431 shdev->hard_header = shaper_header;
432 }
433 else
434 shdev->hard_header = NULL;
436 if(dev->rebuild_header)
437 {
438 sh->rebuild_header = dev->rebuild_header;
439 shdev->rebuild_header = shaper_rebuild_header;
440 }
441 else
442 shdev->rebuild_header = NULL;
444 #if 0
445 if(dev->hard_header_cache)
446 {
447 sh->hard_header_cache = dev->hard_header_cache;
448 shdev->hard_header_cache= shaper_cache;
449 }
450 else
451 {
452 shdev->hard_header_cache= NULL;
453 }
455 if(dev->header_cache_update)
456 {
457 sh->header_cache_update = dev->header_cache_update;
458 shdev->header_cache_update = shaper_cache_update;
459 }
460 else
461 shdev->header_cache_update= NULL;
462 #else
463 shdev->header_cache_update = NULL;
464 shdev->hard_header_cache = NULL;
465 #endif
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;
471 shdev->mtu=dev->mtu;
472 sh->bitspersec=0;
473 return 0;
474 }
476 static int shaper_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
477 {
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)
482 {
483 if(!capable(CAP_NET_ADMIN))
484 return -EPERM;
485 }
487 switch(ss->ss_cmd)
488 {
489 case SHAPER_SET_DEV:
490 {
491 struct net_device *them=__dev_get_by_name(ss->ss_name);
492 if(them==NULL)
493 return -ENODEV;
494 if(sh->dev)
495 return -EBUSY;
496 return shaper_attach(dev,dev->priv, them);
497 }
498 case SHAPER_GET_DEV:
499 if(sh->dev==NULL)
500 return -ENODEV;
501 strcpy(ss->ss_name, sh->dev->name);
502 return 0;
503 case SHAPER_SET_SPEED:
504 shaper_setspeed(sh,ss->ss_speed);
505 return 0;
506 case SHAPER_GET_SPEED:
507 ss->ss_speed=sh->bitspersec;
508 return 0;
509 default:
510 return -EINVAL;
511 }
512 }
514 static void shaper_init_priv(struct net_device *dev)
515 {
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);
523 }
525 /*
526 * Add a shaper device to the system
527 */
529 static void __init shaper_setup(struct net_device *dev)
530 {
531 /*
532 * Set up the shaper.
533 */
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;
545 /*
546 * Intialise the packet queues
547 */
549 /*
550 * Handlers for when we attach to a device.
551 */
553 dev->hard_header = shaper_header;
554 dev->rebuild_header = shaper_rebuild_header;
555 #if 0
556 dev->hard_header_cache = shaper_cache;
557 dev->header_cache_update= shaper_cache_update;
558 #endif
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;
564 dev->mtu = 1500;
565 dev->addr_len = 0;
566 dev->tx_queue_len = 10;
567 dev->flags = 0;
568 }
570 static int shapers = 1;
571 #ifdef MODULE
573 module_param(shapers, int, 0);
574 MODULE_PARM_DESC(shapers, "Traffic shaper: maximum number of shapers");
576 #else /* MODULE */
578 static int __init set_num_shapers(char *str)
579 {
580 shapers = simple_strtol(str, NULL, 0);
581 return 1;
582 }
584 __setup("shapers=", set_num_shapers);
586 #endif /* MODULE */
588 static struct net_device **devs;
590 static unsigned int shapers_registered = 0;
592 static int __init shaper_init(void)
593 {
594 int i;
595 size_t alloc_size;
596 struct net_device *dev;
597 char name[IFNAMSIZ];
599 if (shapers < 1)
600 return -ENODEV;
602 alloc_size = sizeof(*dev) * shapers;
603 devs = kmalloc(alloc_size, GFP_KERNEL);
604 if (!devs)
605 return -ENOMEM;
606 memset(devs, 0, alloc_size);
608 for (i = 0; i < shapers; i++) {
610 snprintf(name, IFNAMSIZ, "shaper%d", i);
611 dev = alloc_netdev(sizeof(struct shaper), name,
612 shaper_setup);
613 if (!dev)
614 break;
616 if (register_netdev(dev)) {
617 free_netdev(dev);
618 break;
619 }
621 devs[i] = dev;
622 shapers_registered++;
623 }
625 if (!shapers_registered) {
626 kfree(devs);
627 devs = NULL;
628 }
630 return (shapers_registered ? 0 : -ENODEV);
631 }
633 static void __exit shaper_exit (void)
634 {
635 int i;
637 for (i = 0; i < shapers_registered; i++) {
638 if (devs[i]) {
639 unregister_netdev(devs[i]);
640 free_netdev(devs[i]);
641 }
642 }
644 kfree(devs);
645 devs = NULL;
646 }
648 module_init(shaper_init);
649 module_exit(shaper_exit);
650 MODULE_LICENSE("GPL");