ia64/linux-2.6.18-xen.hg

view arch/mips/arc/memory.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 * memory.c: PROM library functions for acquiring/using memory descriptors
3 * given to us from the ARCS firmware.
4 *
5 * Copyright (C) 1996 by David S. Miller
6 * Copyright (C) 1999, 2000, 2001 by Ralf Baechle
7 * Copyright (C) 1999, 2000 by Silicon Graphics, Inc.
8 *
9 * PROM library functions for acquiring/using memory descriptors given to us
10 * from the ARCS firmware. This is only used when CONFIG_ARC_MEMORY is set
11 * because on some machines like SGI IP27 the ARC memory configuration data
12 * completly bogus and alternate easier to use mechanisms are available.
13 */
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/types.h>
17 #include <linux/sched.h>
18 #include <linux/mm.h>
19 #include <linux/bootmem.h>
20 #include <linux/swap.h>
22 #include <asm/sgialib.h>
23 #include <asm/page.h>
24 #include <asm/pgtable.h>
25 #include <asm/bootinfo.h>
27 #undef DEBUG
29 /*
30 * For ARC firmware memory functions the unit of meassuring memory is always
31 * a 4k page of memory
32 */
33 #define ARC_PAGE_SHIFT 12
35 struct linux_mdesc * __init ArcGetMemoryDescriptor(struct linux_mdesc *Current)
36 {
37 return (struct linux_mdesc *) ARC_CALL1(get_mdesc, Current);
38 }
40 #ifdef DEBUG /* convenient for debugging */
41 static char *arcs_mtypes[8] = {
42 "Exception Block",
43 "ARCS Romvec Page",
44 "Free/Contig RAM",
45 "Generic Free RAM",
46 "Bad Memory",
47 "Standalone Program Pages",
48 "ARCS Temp Storage Area",
49 "ARCS Permanent Storage Area"
50 };
52 static char *arc_mtypes[8] = {
53 "Exception Block",
54 "SystemParameterBlock",
55 "FreeMemory",
56 "Bad Memory",
57 "LoadedProgram",
58 "FirmwareTemporary",
59 "FirmwarePermanent",
60 "FreeContiguous"
61 };
62 #define mtypes(a) (prom_flags & PROM_FLAG_ARCS) ? arcs_mtypes[a.arcs] \
63 : arc_mtypes[a.arc]
64 #endif
66 static inline int memtype_classify_arcs (union linux_memtypes type)
67 {
68 switch (type.arcs) {
69 case arcs_fcontig:
70 case arcs_free:
71 return BOOT_MEM_RAM;
72 case arcs_atmp:
73 return BOOT_MEM_ROM_DATA;
74 case arcs_eblock:
75 case arcs_rvpage:
76 case arcs_bmem:
77 case arcs_prog:
78 case arcs_aperm:
79 return BOOT_MEM_RESERVED;
80 default:
81 BUG();
82 }
83 while(1); /* Nuke warning. */
84 }
86 static inline int memtype_classify_arc (union linux_memtypes type)
87 {
88 switch (type.arc) {
89 case arc_free:
90 case arc_fcontig:
91 return BOOT_MEM_RAM;
92 case arc_atmp:
93 return BOOT_MEM_ROM_DATA;
94 case arc_eblock:
95 case arc_rvpage:
96 case arc_bmem:
97 case arc_prog:
98 case arc_aperm:
99 return BOOT_MEM_RESERVED;
100 default:
101 BUG();
102 }
103 while(1); /* Nuke warning. */
104 }
106 static int __init prom_memtype_classify (union linux_memtypes type)
107 {
108 if (prom_flags & PROM_FLAG_ARCS) /* SGI is ``different'' ... */
109 return memtype_classify_arcs(type);
111 return memtype_classify_arc(type);
112 }
114 void __init prom_meminit(void)
115 {
116 struct linux_mdesc *p;
118 #ifdef DEBUG
119 int i = 0;
121 prom_printf("ARCS MEMORY DESCRIPTOR dump:\n");
122 p = ArcGetMemoryDescriptor(PROM_NULL_MDESC);
123 while(p) {
124 prom_printf("[%d,%p]: base<%08lx> pages<%08lx> type<%s>\n",
125 i, p, p->base, p->pages, mtypes(p->type));
126 p = ArcGetMemoryDescriptor(p);
127 i++;
128 }
129 #endif
131 p = PROM_NULL_MDESC;
132 while ((p = ArcGetMemoryDescriptor(p))) {
133 unsigned long base, size;
134 long type;
136 base = p->base << ARC_PAGE_SHIFT;
137 size = p->pages << ARC_PAGE_SHIFT;
138 type = prom_memtype_classify(p->type);
140 add_memory_region(base, size, type);
141 }
142 }
144 unsigned long __init prom_free_prom_memory(void)
145 {
146 unsigned long freed = 0;
147 unsigned long addr;
148 int i;
150 if (prom_flags & PROM_FLAG_DONT_FREE_TEMP)
151 return 0;
153 for (i = 0; i < boot_mem_map.nr_map; i++) {
154 if (boot_mem_map.map[i].type != BOOT_MEM_ROM_DATA)
155 continue;
157 addr = boot_mem_map.map[i].addr;
158 while (addr < boot_mem_map.map[i].addr
159 + boot_mem_map.map[i].size) {
160 ClearPageReserved(virt_to_page(__va(addr)));
161 init_page_count(virt_to_page(__va(addr)));
162 free_page((unsigned long)__va(addr));
163 addr += PAGE_SIZE;
164 freed += PAGE_SIZE;
165 }
166 }
167 printk(KERN_INFO "Freeing prom memory: %ldkb freed\n", freed >> 10);
169 return freed;
170 }