ia64/linux-2.6.18-xen.hg

view drivers/acpi/events/evrgnini.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 *
3 * Module Name: evrgnini- ACPI address_space (op_region) init
4 *
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2006, R. Byron Moore
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
44 #include <acpi/acpi.h>
45 #include <acpi/acevents.h>
46 #include <acpi/acnamesp.h>
48 #define _COMPONENT ACPI_EVENTS
49 ACPI_MODULE_NAME("evrgnini")
51 /*******************************************************************************
52 *
53 * FUNCTION: acpi_ev_system_memory_region_setup
54 *
55 * PARAMETERS: Handle - Region we are interested in
56 * Function - Start or stop
57 * handler_context - Address space handler context
58 * region_context - Region specific context
59 *
60 * RETURN: Status
61 *
62 * DESCRIPTION: Setup a system_memory operation region
63 *
64 ******************************************************************************/
65 acpi_status
66 acpi_ev_system_memory_region_setup(acpi_handle handle,
67 u32 function,
68 void *handler_context, void **region_context)
69 {
70 union acpi_operand_object *region_desc =
71 (union acpi_operand_object *)handle;
72 struct acpi_mem_space_context *local_region_context;
74 ACPI_FUNCTION_TRACE(ev_system_memory_region_setup);
76 if (function == ACPI_REGION_DEACTIVATE) {
77 if (*region_context) {
78 local_region_context =
79 (struct acpi_mem_space_context *)*region_context;
81 /* Delete a cached mapping if present */
83 if (local_region_context->mapped_length) {
84 acpi_os_unmap_memory(local_region_context->
85 mapped_logical_address,
86 local_region_context->
87 mapped_length);
88 }
89 ACPI_FREE(local_region_context);
90 *region_context = NULL;
91 }
92 return_ACPI_STATUS(AE_OK);
93 }
95 /* Create a new context */
97 local_region_context =
98 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context));
99 if (!(local_region_context)) {
100 return_ACPI_STATUS(AE_NO_MEMORY);
101 }
103 /* Save the region length and address for use in the handler */
105 local_region_context->length = region_desc->region.length;
106 local_region_context->address = region_desc->region.address;
108 *region_context = local_region_context;
109 return_ACPI_STATUS(AE_OK);
110 }
112 /*******************************************************************************
113 *
114 * FUNCTION: acpi_ev_io_space_region_setup
115 *
116 * PARAMETERS: Handle - Region we are interested in
117 * Function - Start or stop
118 * handler_context - Address space handler context
119 * region_context - Region specific context
120 *
121 * RETURN: Status
122 *
123 * DESCRIPTION: Setup a IO operation region
124 *
125 ******************************************************************************/
127 acpi_status
128 acpi_ev_io_space_region_setup(acpi_handle handle,
129 u32 function,
130 void *handler_context, void **region_context)
131 {
132 ACPI_FUNCTION_TRACE(ev_io_space_region_setup);
134 if (function == ACPI_REGION_DEACTIVATE) {
135 *region_context = NULL;
136 } else {
137 *region_context = handler_context;
138 }
140 return_ACPI_STATUS(AE_OK);
141 }
143 /*******************************************************************************
144 *
145 * FUNCTION: acpi_ev_pci_config_region_setup
146 *
147 * PARAMETERS: Handle - Region we are interested in
148 * Function - Start or stop
149 * handler_context - Address space handler context
150 * region_context - Region specific context
151 *
152 * RETURN: Status
153 *
154 * DESCRIPTION: Setup a PCI_Config operation region
155 *
156 * MUTEX: Assumes namespace is not locked
157 *
158 ******************************************************************************/
160 acpi_status
161 acpi_ev_pci_config_region_setup(acpi_handle handle,
162 u32 function,
163 void *handler_context, void **region_context)
164 {
165 acpi_status status = AE_OK;
166 acpi_integer pci_value;
167 struct acpi_pci_id *pci_id = *region_context;
168 union acpi_operand_object *handler_obj;
169 struct acpi_namespace_node *parent_node;
170 struct acpi_namespace_node *pci_root_node;
171 union acpi_operand_object *region_obj =
172 (union acpi_operand_object *)handle;
173 struct acpi_device_id object_hID;
175 ACPI_FUNCTION_TRACE(ev_pci_config_region_setup);
177 handler_obj = region_obj->region.handler;
178 if (!handler_obj) {
179 /*
180 * No installed handler. This shouldn't happen because the dispatch
181 * routine checks before we get here, but we check again just in case.
182 */
183 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
184 "Attempting to init a region %p, with no handler\n",
185 region_obj));
186 return_ACPI_STATUS(AE_NOT_EXIST);
187 }
189 *region_context = NULL;
190 if (function == ACPI_REGION_DEACTIVATE) {
191 if (pci_id) {
192 ACPI_FREE(pci_id);
193 }
194 return_ACPI_STATUS(status);
195 }
197 parent_node = acpi_ns_get_parent_node(region_obj->region.node);
199 /*
200 * Get the _SEG and _BBN values from the device upon which the handler
201 * is installed.
202 *
203 * We need to get the _SEG and _BBN objects relative to the PCI BUS device.
204 * This is the device the handler has been registered to handle.
205 */
207 /*
208 * If the address_space.Node is still pointing to the root, we need
209 * to scan upward for a PCI Root bridge and re-associate the op_region
210 * handlers with that device.
211 */
212 if (handler_obj->address_space.node == acpi_gbl_root_node) {
214 /* Start search from the parent object */
216 pci_root_node = parent_node;
217 while (pci_root_node != acpi_gbl_root_node) {
218 status =
219 acpi_ut_execute_HID(pci_root_node, &object_hID);
220 if (ACPI_SUCCESS(status)) {
221 /*
222 * Got a valid _HID string, check if this is a PCI root.
223 * New for ACPI 3.0: check for a PCI Express root also.
224 */
225 if (!
226 (ACPI_STRNCMP
227 (object_hID.value, PCI_ROOT_HID_STRING,
228 sizeof(PCI_ROOT_HID_STRING))
229 ||
230 !(ACPI_STRNCMP
231 (object_hID.value,
232 PCI_EXPRESS_ROOT_HID_STRING,
233 sizeof(PCI_EXPRESS_ROOT_HID_STRING)))))
234 {
236 /* Install a handler for this PCI root bridge */
238 status =
239 acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
240 if (ACPI_FAILURE(status)) {
241 if (status == AE_SAME_HANDLER) {
242 /*
243 * It is OK if the handler is already installed on the root
244 * bridge. Still need to return a context object for the
245 * new PCI_Config operation region, however.
246 */
247 status = AE_OK;
248 } else {
249 ACPI_EXCEPTION((AE_INFO,
250 status,
251 "Could not install PciConfig handler for Root Bridge %4.4s",
252 acpi_ut_get_node_name
253 (pci_root_node)));
254 }
255 }
256 break;
257 }
258 }
260 pci_root_node = acpi_ns_get_parent_node(pci_root_node);
261 }
263 /* PCI root bridge not found, use namespace root node */
264 } else {
265 pci_root_node = handler_obj->address_space.node;
266 }
268 /*
269 * If this region is now initialized, we are done.
270 * (install_address_space_handler could have initialized it)
271 */
272 if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) {
273 return_ACPI_STATUS(AE_OK);
274 }
276 /* Region is still not initialized. Create a new context */
278 pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id));
279 if (!pci_id) {
280 return_ACPI_STATUS(AE_NO_MEMORY);
281 }
283 /*
284 * For PCI_Config space access, we need the segment, bus,
285 * device and function numbers. Acquire them here.
286 */
288 /*
289 * Get the PCI device and function numbers from the _ADR object
290 * contained in the parent's scope.
291 */
292 status =
293 acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, parent_node,
294 &pci_value);
296 /*
297 * The default is zero, and since the allocation above zeroed
298 * the data, just do nothing on failure.
299 */
300 if (ACPI_SUCCESS(status)) {
301 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value));
302 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value));
303 }
305 /* The PCI segment number comes from the _SEG method */
307 status =
308 acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG, pci_root_node,
309 &pci_value);
310 if (ACPI_SUCCESS(status)) {
311 pci_id->segment = ACPI_LOWORD(pci_value);
312 }
314 /* The PCI bus number comes from the _BBN method */
316 status =
317 acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN, pci_root_node,
318 &pci_value);
319 if (ACPI_SUCCESS(status)) {
320 pci_id->bus = ACPI_LOWORD(pci_value);
321 }
323 /* Complete this device's pci_id */
325 acpi_os_derive_pci_id(pci_root_node, region_obj->region.node, &pci_id);
327 *region_context = pci_id;
328 return_ACPI_STATUS(AE_OK);
329 }
331 /*******************************************************************************
332 *
333 * FUNCTION: acpi_ev_pci_bar_region_setup
334 *
335 * PARAMETERS: Handle - Region we are interested in
336 * Function - Start or stop
337 * handler_context - Address space handler context
338 * region_context - Region specific context
339 *
340 * RETURN: Status
341 *
342 * DESCRIPTION: Setup a pci_bAR operation region
343 *
344 * MUTEX: Assumes namespace is not locked
345 *
346 ******************************************************************************/
348 acpi_status
349 acpi_ev_pci_bar_region_setup(acpi_handle handle,
350 u32 function,
351 void *handler_context, void **region_context)
352 {
353 ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup);
355 return_ACPI_STATUS(AE_OK);
356 }
358 /*******************************************************************************
359 *
360 * FUNCTION: acpi_ev_cmos_region_setup
361 *
362 * PARAMETERS: Handle - Region we are interested in
363 * Function - Start or stop
364 * handler_context - Address space handler context
365 * region_context - Region specific context
366 *
367 * RETURN: Status
368 *
369 * DESCRIPTION: Setup a CMOS operation region
370 *
371 * MUTEX: Assumes namespace is not locked
372 *
373 ******************************************************************************/
375 acpi_status
376 acpi_ev_cmos_region_setup(acpi_handle handle,
377 u32 function,
378 void *handler_context, void **region_context)
379 {
380 ACPI_FUNCTION_TRACE(ev_cmos_region_setup);
382 return_ACPI_STATUS(AE_OK);
383 }
385 /*******************************************************************************
386 *
387 * FUNCTION: acpi_ev_default_region_setup
388 *
389 * PARAMETERS: Handle - Region we are interested in
390 * Function - Start or stop
391 * handler_context - Address space handler context
392 * region_context - Region specific context
393 *
394 * RETURN: Status
395 *
396 * DESCRIPTION: Default region initialization
397 *
398 ******************************************************************************/
400 acpi_status
401 acpi_ev_default_region_setup(acpi_handle handle,
402 u32 function,
403 void *handler_context, void **region_context)
404 {
405 ACPI_FUNCTION_TRACE(ev_default_region_setup);
407 if (function == ACPI_REGION_DEACTIVATE) {
408 *region_context = NULL;
409 } else {
410 *region_context = handler_context;
411 }
413 return_ACPI_STATUS(AE_OK);
414 }
416 /*******************************************************************************
417 *
418 * FUNCTION: acpi_ev_initialize_region
419 *
420 * PARAMETERS: region_obj - Region we are initializing
421 * acpi_ns_locked - Is namespace locked?
422 *
423 * RETURN: Status
424 *
425 * DESCRIPTION: Initializes the region, finds any _REG methods and saves them
426 * for execution at a later time
427 *
428 * Get the appropriate address space handler for a newly
429 * created region.
430 *
431 * This also performs address space specific initialization. For
432 * example, PCI regions must have an _ADR object that contains
433 * a PCI address in the scope of the definition. This address is
434 * required to perform an access to PCI config space.
435 *
436 ******************************************************************************/
438 acpi_status
439 acpi_ev_initialize_region(union acpi_operand_object *region_obj,
440 u8 acpi_ns_locked)
441 {
442 union acpi_operand_object *handler_obj;
443 union acpi_operand_object *obj_desc;
444 acpi_adr_space_type space_id;
445 struct acpi_namespace_node *node;
446 acpi_status status;
447 struct acpi_namespace_node *method_node;
448 acpi_name *reg_name_ptr = (acpi_name *) METHOD_NAME__REG;
449 union acpi_operand_object *region_obj2;
451 ACPI_FUNCTION_TRACE_U32(ev_initialize_region, acpi_ns_locked);
453 if (!region_obj) {
454 return_ACPI_STATUS(AE_BAD_PARAMETER);
455 }
457 if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) {
458 return_ACPI_STATUS(AE_OK);
459 }
461 region_obj2 = acpi_ns_get_secondary_object(region_obj);
462 if (!region_obj2) {
463 return_ACPI_STATUS(AE_NOT_EXIST);
464 }
466 node = acpi_ns_get_parent_node(region_obj->region.node);
467 space_id = region_obj->region.space_id;
469 /* Setup defaults */
471 region_obj->region.handler = NULL;
472 region_obj2->extra.method_REG = NULL;
473 region_obj->common.flags &= ~(AOPOBJ_SETUP_COMPLETE);
474 region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED;
476 /* Find any "_REG" method associated with this region definition */
478 status =
479 acpi_ns_search_one_scope(*reg_name_ptr, node, ACPI_TYPE_METHOD,
480 &method_node);
481 if (ACPI_SUCCESS(status)) {
482 /*
483 * The _REG method is optional and there can be only one per region
484 * definition. This will be executed when the handler is attached
485 * or removed
486 */
487 region_obj2->extra.method_REG = method_node;
488 }
490 /*
491 * The following loop depends upon the root Node having no parent
492 * ie: acpi_gbl_root_node->parent_entry being set to NULL
493 */
494 while (node) {
496 /* Check to see if a handler exists */
498 handler_obj = NULL;
499 obj_desc = acpi_ns_get_attached_object(node);
500 if (obj_desc) {
502 /* Can only be a handler if the object exists */
504 switch (node->type) {
505 case ACPI_TYPE_DEVICE:
507 handler_obj = obj_desc->device.handler;
508 break;
510 case ACPI_TYPE_PROCESSOR:
512 handler_obj = obj_desc->processor.handler;
513 break;
515 case ACPI_TYPE_THERMAL:
517 handler_obj = obj_desc->thermal_zone.handler;
518 break;
520 default:
521 /* Ignore other objects */
522 break;
523 }
525 while (handler_obj) {
527 /* Is this handler of the correct type? */
529 if (handler_obj->address_space.space_id ==
530 space_id) {
532 /* Found correct handler */
534 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
535 "Found handler %p for region %p in obj %p\n",
536 handler_obj,
537 region_obj,
538 obj_desc));
540 status =
541 acpi_ev_attach_region(handler_obj,
542 region_obj,
543 acpi_ns_locked);
545 /*
546 * Tell all users that this region is usable by running the _REG
547 * method
548 */
549 if (acpi_ns_locked) {
550 status =
551 acpi_ut_release_mutex
552 (ACPI_MTX_NAMESPACE);
553 if (ACPI_FAILURE(status)) {
554 return_ACPI_STATUS
555 (status);
556 }
557 }
559 status =
560 acpi_ev_execute_reg_method
561 (region_obj, 1);
563 if (acpi_ns_locked) {
564 status =
565 acpi_ut_acquire_mutex
566 (ACPI_MTX_NAMESPACE);
567 if (ACPI_FAILURE(status)) {
568 return_ACPI_STATUS
569 (status);
570 }
571 }
573 return_ACPI_STATUS(AE_OK);
574 }
576 /* Try next handler in the list */
578 handler_obj = handler_obj->address_space.next;
579 }
580 }
582 /*
583 * This node does not have the handler we need;
584 * Pop up one level
585 */
586 node = acpi_ns_get_parent_node(node);
587 }
589 /* If we get here, there is no handler for this region */
591 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
592 "No handler for RegionType %s(%X) (RegionObj %p)\n",
593 acpi_ut_get_region_name(space_id), space_id,
594 region_obj));
596 return_ACPI_STATUS(AE_NOT_EXIST);
597 }