ia64/linux-2.6.18-xen.hg

view lib/extable.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 * Derived from arch/ppc/mm/extable.c and arch/i386/mm/extable.c.
3 *
4 * Copyright (C) 2004 Paul Mackerras, IBM Corp.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/sort.h>
15 #include <asm/uaccess.h>
17 #ifndef ARCH_HAS_SORT_EXTABLE
18 /*
19 * The exception table needs to be sorted so that the binary
20 * search that we use to find entries in it works properly.
21 * This is used both for the kernel exception table and for
22 * the exception tables of modules that get loaded.
23 */
24 static int cmp_ex(const void *a, const void *b)
25 {
26 const struct exception_table_entry *x = a, *y = b;
28 /* avoid overflow */
29 if (x->insn > y->insn)
30 return 1;
31 if (x->insn < y->insn)
32 return -1;
33 return 0;
34 }
36 void sort_extable(struct exception_table_entry *start,
37 struct exception_table_entry *finish)
38 {
39 sort(start, finish - start, sizeof(struct exception_table_entry),
40 cmp_ex, NULL);
41 }
42 #endif
44 #ifndef ARCH_HAS_SEARCH_EXTABLE
45 /*
46 * Search one exception table for an entry corresponding to the
47 * given instruction address, and return the address of the entry,
48 * or NULL if none is found.
49 * We use a binary search, and thus we assume that the table is
50 * already sorted.
51 */
52 const struct exception_table_entry *
53 search_extable(const struct exception_table_entry *first,
54 const struct exception_table_entry *last,
55 unsigned long value)
56 {
57 while (first <= last) {
58 const struct exception_table_entry *mid;
60 mid = (last - first) / 2 + first;
61 /*
62 * careful, the distance between entries can be
63 * larger than 2GB:
64 */
65 if (mid->insn < value)
66 first = mid + 1;
67 else if (mid->insn > value)
68 last = mid - 1;
69 else
70 return mid;
71 }
72 return NULL;
73 }
74 #endif