ia64/linux-2.6.18-xen.hg

view drivers/rapidio/rio-driver.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 * RapidIO driver support
3 *
4 * Copyright 2005 MontaVista Software, Inc.
5 * Matt Porter <mporter@kernel.crashing.org>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
11 */
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/rio.h>
16 #include <linux/rio_ids.h>
18 #include "rio.h"
20 /**
21 * rio_match_device - Tell if a RIO device has a matching RIO device id structure
22 * @id: the RIO device id structure to match against
23 * @rdev: the RIO device structure to match against
24 *
25 * Used from driver probe and bus matching to check whether a RIO device
26 * matches a device id structure provided by a RIO driver. Returns the
27 * matching &struct rio_device_id or %NULL if there is no match.
28 */
29 static const struct rio_device_id *rio_match_device(const struct rio_device_id
30 *id,
31 const struct rio_dev *rdev)
32 {
33 while (id->vid || id->asm_vid) {
34 if (((id->vid == RIO_ANY_ID) || (id->vid == rdev->vid)) &&
35 ((id->did == RIO_ANY_ID) || (id->did == rdev->did)) &&
36 ((id->asm_vid == RIO_ANY_ID)
37 || (id->asm_vid == rdev->asm_vid))
38 && ((id->asm_did == RIO_ANY_ID)
39 || (id->asm_did == rdev->asm_did)))
40 return id;
41 id++;
42 }
43 return NULL;
44 }
46 /**
47 * rio_dev_get - Increments the reference count of the RIO device structure
48 *
49 * @rdev: RIO device being referenced
50 *
51 * Each live reference to a device should be refcounted.
52 *
53 * Drivers for RIO devices should normally record such references in
54 * their probe() methods, when they bind to a device, and release
55 * them by calling rio_dev_put(), in their disconnect() methods.
56 */
57 struct rio_dev *rio_dev_get(struct rio_dev *rdev)
58 {
59 if (rdev)
60 get_device(&rdev->dev);
62 return rdev;
63 }
65 /**
66 * rio_dev_put - Release a use of the RIO device structure
67 *
68 * @rdev: RIO device being disconnected
69 *
70 * Must be called when a user of a device is finished with it.
71 * When the last user of the device calls this function, the
72 * memory of the device is freed.
73 */
74 void rio_dev_put(struct rio_dev *rdev)
75 {
76 if (rdev)
77 put_device(&rdev->dev);
78 }
80 /**
81 * rio_device_probe - Tell if a RIO device structure has a matching RIO
82 * device id structure
83 * @id: the RIO device id structure to match against
84 * @dev: the RIO device structure to match against
85 *
86 * return 0 and set rio_dev->driver when drv claims rio_dev, else error
87 */
88 static int rio_device_probe(struct device *dev)
89 {
90 struct rio_driver *rdrv = to_rio_driver(dev->driver);
91 struct rio_dev *rdev = to_rio_dev(dev);
92 int error = -ENODEV;
93 const struct rio_device_id *id;
95 if (!rdev->driver && rdrv->probe) {
96 if (!rdrv->id_table)
97 return error;
98 id = rio_match_device(rdrv->id_table, rdev);
99 rio_dev_get(rdev);
100 if (id)
101 error = rdrv->probe(rdev, id);
102 if (error >= 0) {
103 rdev->driver = rdrv;
104 error = 0;
105 rio_dev_put(rdev);
106 }
107 }
108 return error;
109 }
111 /**
112 * rio_device_remove - Remove a RIO device from the system
113 *
114 * @dev: the RIO device structure to match against
115 *
116 * Remove a RIO device from the system. If it has an associated
117 * driver, then run the driver remove() method. Then update
118 * the reference count.
119 */
120 static int rio_device_remove(struct device *dev)
121 {
122 struct rio_dev *rdev = to_rio_dev(dev);
123 struct rio_driver *rdrv = rdev->driver;
125 if (rdrv) {
126 if (rdrv->remove)
127 rdrv->remove(rdev);
128 rdev->driver = NULL;
129 }
131 rio_dev_put(rdev);
133 return 0;
134 }
136 /**
137 * rio_register_driver - register a new RIO driver
138 * @rdrv: the RIO driver structure to register
139 *
140 * Adds a &struct rio_driver to the list of registered drivers
141 * Returns a negative value on error, otherwise 0. If no error
142 * occurred, the driver remains registered even if no device
143 * was claimed during registration.
144 */
145 int rio_register_driver(struct rio_driver *rdrv)
146 {
147 /* initialize common driver fields */
148 rdrv->driver.name = rdrv->name;
149 rdrv->driver.bus = &rio_bus_type;
151 /* register with core */
152 return driver_register(&rdrv->driver);
153 }
155 /**
156 * rio_unregister_driver - unregister a RIO driver
157 * @rdrv: the RIO driver structure to unregister
158 *
159 * Deletes the &struct rio_driver from the list of registered RIO
160 * drivers, gives it a chance to clean up by calling its remove()
161 * function for each device it was responsible for, and marks those
162 * devices as driverless.
163 */
164 void rio_unregister_driver(struct rio_driver *rdrv)
165 {
166 driver_unregister(&rdrv->driver);
167 }
169 /**
170 * rio_match_bus - Tell if a RIO device structure has a matching RIO
171 * driver device id structure
172 * @dev: the standard device structure to match against
173 * @drv: the standard driver structure containing the ids to match against
174 *
175 * Used by a driver to check whether a RIO device present in the
176 * system is in its list of supported devices. Returns 1 if
177 * there is a matching &struct rio_device_id or 0 if there is
178 * no match.
179 */
180 static int rio_match_bus(struct device *dev, struct device_driver *drv)
181 {
182 struct rio_dev *rdev = to_rio_dev(dev);
183 struct rio_driver *rdrv = to_rio_driver(drv);
184 const struct rio_device_id *id = rdrv->id_table;
185 const struct rio_device_id *found_id;
187 if (!id)
188 goto out;
190 found_id = rio_match_device(id, rdev);
192 if (found_id)
193 return 1;
195 out:return 0;
196 }
198 static struct device rio_bus = {
199 .bus_id = "rapidio",
200 };
202 struct bus_type rio_bus_type = {
203 .name = "rapidio",
204 .match = rio_match_bus,
205 .dev_attrs = rio_dev_attrs,
206 .probe = rio_device_probe,
207 .remove = rio_device_remove,
208 };
210 /**
211 * rio_bus_init - Register the RapidIO bus with the device model
212 *
213 * Registers the RIO bus device and RIO bus type with the Linux
214 * device model.
215 */
216 static int __init rio_bus_init(void)
217 {
218 if (device_register(&rio_bus) < 0)
219 printk("RIO: failed to register RIO bus device\n");
220 return bus_register(&rio_bus_type);
221 }
223 postcore_initcall(rio_bus_init);
225 EXPORT_SYMBOL_GPL(rio_register_driver);
226 EXPORT_SYMBOL_GPL(rio_unregister_driver);
227 EXPORT_SYMBOL_GPL(rio_bus_type);
228 EXPORT_SYMBOL_GPL(rio_dev_get);
229 EXPORT_SYMBOL_GPL(rio_dev_put);