ia64/linux-2.6.18-xen.hg

view drivers/zorro/zorro.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 * $Id: zorro.c,v 1.1.2.1 1998/06/07 23:21:02 geert Exp $
3 *
4 * Zorro Bus Services
5 *
6 * Copyright (C) 1995-2003 Geert Uytterhoeven
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file COPYING in the main directory of this archive
10 * for more details.
11 */
13 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/zorro.h>
18 #include <linux/bitops.h>
19 #include <linux/string.h>
21 #include <asm/setup.h>
22 #include <asm/amigahw.h>
24 #include "zorro.h"
27 /*
28 * Zorro Expansion Devices
29 */
31 u_int zorro_num_autocon = 0;
32 struct zorro_dev zorro_autocon[ZORRO_NUM_AUTO];
35 /*
36 * Single Zorro bus
37 */
39 struct zorro_bus zorro_bus = {\
40 .resources = {
41 /* Zorro II regions (on Zorro II/III) */
42 { .name = "Zorro II exp", .start = 0x00e80000, .end = 0x00efffff },
43 { .name = "Zorro II mem", .start = 0x00200000, .end = 0x009fffff },
44 /* Zorro III regions (on Zorro III only) */
45 { .name = "Zorro III exp", .start = 0xff000000, .end = 0xffffffff },
46 { .name = "Zorro III cfg", .start = 0x40000000, .end = 0x7fffffff }
47 },
48 .name = "Zorro bus"
49 };
52 /*
53 * Find Zorro Devices
54 */
56 struct zorro_dev *zorro_find_device(zorro_id id, struct zorro_dev *from)
57 {
58 struct zorro_dev *z;
60 if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO))
61 return NULL;
63 for (z = from ? from+1 : &zorro_autocon[0];
64 z < zorro_autocon+zorro_num_autocon;
65 z++)
66 if (id == ZORRO_WILDCARD || id == z->id)
67 return z;
68 return NULL;
69 }
72 /*
73 * Bitmask indicating portions of available Zorro II RAM that are unused
74 * by the system. Every bit represents a 64K chunk, for a maximum of 8MB
75 * (128 chunks, physical 0x00200000-0x009fffff).
76 *
77 * If you want to use (= allocate) portions of this RAM, you should clear
78 * the corresponding bits.
79 *
80 * Possible uses:
81 * - z2ram device
82 * - SCSI DMA bounce buffers
83 *
84 * FIXME: use the normal resource management
85 */
87 DECLARE_BITMAP(zorro_unused_z2ram, 128);
90 static void __init mark_region(unsigned long start, unsigned long end,
91 int flag)
92 {
93 if (flag)
94 start += Z2RAM_CHUNKMASK;
95 else
96 end += Z2RAM_CHUNKMASK;
97 start &= ~Z2RAM_CHUNKMASK;
98 end &= ~Z2RAM_CHUNKMASK;
100 if (end <= Z2RAM_START || start >= Z2RAM_END)
101 return;
102 start = start < Z2RAM_START ? 0x00000000 : start-Z2RAM_START;
103 end = end > Z2RAM_END ? Z2RAM_SIZE : end-Z2RAM_START;
104 while (start < end) {
105 u32 chunk = start>>Z2RAM_CHUNKSHIFT;
106 if (flag)
107 set_bit(chunk, zorro_unused_z2ram);
108 else
109 clear_bit(chunk, zorro_unused_z2ram);
110 start += Z2RAM_CHUNKSIZE;
111 }
112 }
115 static struct resource __init *zorro_find_parent_resource(struct zorro_dev *z)
116 {
117 int i;
119 for (i = 0; i < zorro_bus.num_resources; i++)
120 if (zorro_resource_start(z) >= zorro_bus.resources[i].start &&
121 zorro_resource_end(z) <= zorro_bus.resources[i].end)
122 return &zorro_bus.resources[i];
123 return &iomem_resource;
124 }
127 /*
128 * Initialization
129 */
131 static int __init zorro_init(void)
132 {
133 struct zorro_dev *z;
134 unsigned int i;
136 if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO))
137 return 0;
139 pr_info("Zorro: Probing AutoConfig expansion devices: %d device%s\n",
140 zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s");
142 /* Initialize the Zorro bus */
143 INIT_LIST_HEAD(&zorro_bus.devices);
144 strcpy(zorro_bus.dev.bus_id, "zorro");
145 device_register(&zorro_bus.dev);
147 /* Request the resources */
148 zorro_bus.num_resources = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2;
149 for (i = 0; i < zorro_bus.num_resources; i++)
150 request_resource(&iomem_resource, &zorro_bus.resources[i]);
152 /* Register all devices */
153 for (i = 0; i < zorro_num_autocon; i++) {
154 z = &zorro_autocon[i];
155 z->id = (z->rom.er_Manufacturer<<16) | (z->rom.er_Product<<8);
156 if (z->id == ZORRO_PROD_GVP_EPC_BASE) {
157 /* GVP quirk */
158 unsigned long magic = zorro_resource_start(z)+0x8000;
159 z->id |= *(u16 *)ZTWO_VADDR(magic) & GVP_PRODMASK;
160 }
161 sprintf(z->name, "Zorro device %08x", z->id);
162 zorro_name_device(z);
163 z->resource.name = z->name;
164 if (request_resource(zorro_find_parent_resource(z), &z->resource))
165 printk(KERN_ERR "Zorro: Address space collision on device %s "
166 "[%lx:%lx]\n",
167 z->name, zorro_resource_start(z), zorro_resource_end(z));
168 sprintf(z->dev.bus_id, "%02x", i);
169 z->dev.parent = &zorro_bus.dev;
170 z->dev.bus = &zorro_bus_type;
171 device_register(&z->dev);
172 zorro_create_sysfs_dev_files(z);
173 }
175 /* Mark all available Zorro II memory */
176 zorro_for_each_dev(z) {
177 if (z->rom.er_Type & ERTF_MEMLIST)
178 mark_region(zorro_resource_start(z), zorro_resource_end(z)+1, 1);
179 }
181 /* Unmark all used Zorro II memory */
182 for (i = 0; i < m68k_num_memory; i++)
183 if (m68k_memory[i].addr < 16*1024*1024)
184 mark_region(m68k_memory[i].addr,
185 m68k_memory[i].addr+m68k_memory[i].size, 0);
187 return 0;
188 }
190 subsys_initcall(zorro_init);
192 EXPORT_SYMBOL(zorro_find_device);
193 EXPORT_SYMBOL(zorro_unused_z2ram);
195 MODULE_LICENSE("GPL");