ia64/linux-2.6.18-xen.hg

view drivers/acpi/namespace/nsinit.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: nsinit - namespace initialization
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/acnamesp.h>
46 #include <acpi/acdispat.h>
47 #include <acpi/acinterp.h>
49 #define _COMPONENT ACPI_NAMESPACE
50 ACPI_MODULE_NAME("nsinit")
52 /* Local prototypes */
53 static acpi_status
54 acpi_ns_init_one_object(acpi_handle obj_handle,
55 u32 level, void *context, void **return_value);
57 static acpi_status
58 acpi_ns_init_one_device(acpi_handle obj_handle,
59 u32 nesting_level, void *context, void **return_value);
61 static acpi_status
62 acpi_ns_find_ini_methods(acpi_handle obj_handle,
63 u32 nesting_level, void *context, void **return_value);
65 /*******************************************************************************
66 *
67 * FUNCTION: acpi_ns_initialize_objects
68 *
69 * PARAMETERS: None
70 *
71 * RETURN: Status
72 *
73 * DESCRIPTION: Walk the entire namespace and perform any necessary
74 * initialization on the objects found therein
75 *
76 ******************************************************************************/
78 acpi_status acpi_ns_initialize_objects(void)
79 {
80 acpi_status status;
81 struct acpi_init_walk_info info;
83 ACPI_FUNCTION_TRACE(ns_initialize_objects);
85 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
86 "**** Starting initialization of namespace objects ****\n"));
87 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
88 "Completing Region/Field/Buffer/Package initialization:"));
90 /* Set all init info to zero */
92 ACPI_MEMSET(&info, 0, sizeof(struct acpi_init_walk_info));
94 /* Walk entire namespace from the supplied root */
96 status = acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
97 ACPI_UINT32_MAX, acpi_ns_init_one_object,
98 &info, NULL);
99 if (ACPI_FAILURE(status)) {
100 ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace"));
101 }
103 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
104 "\nInitialized %hd/%hd Regions %hd/%hd Fields %hd/%hd Buffers %hd/%hd Packages (%hd nodes)\n",
105 info.op_region_init, info.op_region_count,
106 info.field_init, info.field_count,
107 info.buffer_init, info.buffer_count,
108 info.package_init, info.package_count,
109 info.object_count));
111 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
112 "%hd Control Methods found\n", info.method_count));
113 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
114 "%hd Op Regions found\n", info.op_region_count));
116 return_ACPI_STATUS(AE_OK);
117 }
119 /*******************************************************************************
120 *
121 * FUNCTION: acpi_ns_initialize_devices
122 *
123 * PARAMETERS: None
124 *
125 * RETURN: acpi_status
126 *
127 * DESCRIPTION: Walk the entire namespace and initialize all ACPI devices.
128 * This means running _INI on all present devices.
129 *
130 * Note: We install PCI config space handler on region access,
131 * not here.
132 *
133 ******************************************************************************/
135 acpi_status acpi_ns_initialize_devices(void)
136 {
137 acpi_status status;
138 struct acpi_device_walk_info info;
140 ACPI_FUNCTION_TRACE(ns_initialize_devices);
142 /* Init counters */
144 info.device_count = 0;
145 info.num_STA = 0;
146 info.num_INI = 0;
148 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
149 "Initializing Device/Processor/Thermal objects by executing _INI methods:"));
151 /* Tree analysis: find all subtrees that contain _INI methods */
153 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
154 ACPI_UINT32_MAX, FALSE,
155 acpi_ns_find_ini_methods, &info, NULL);
156 if (ACPI_FAILURE(status)) {
157 goto error_exit;
158 }
160 /* Allocate the evaluation information block */
162 info.evaluate_info =
163 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
164 if (!info.evaluate_info) {
165 status = AE_NO_MEMORY;
166 goto error_exit;
167 }
169 /* Walk namespace to execute all _INIs on present devices */
171 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
172 ACPI_UINT32_MAX, FALSE,
173 acpi_ns_init_one_device, &info, NULL);
175 ACPI_FREE(info.evaluate_info);
176 if (ACPI_FAILURE(status)) {
177 goto error_exit;
178 }
180 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
181 "\nExecuted %hd _INI methods requiring %hd _STA executions (examined %hd objects)\n",
182 info.num_INI, info.num_STA, info.device_count));
184 return_ACPI_STATUS(status);
186 error_exit:
187 ACPI_EXCEPTION((AE_INFO, status, "During device initialization"));
188 return_ACPI_STATUS(status);
189 }
191 /*******************************************************************************
192 *
193 * FUNCTION: acpi_ns_init_one_object
194 *
195 * PARAMETERS: obj_handle - Node
196 * Level - Current nesting level
197 * Context - Points to a init info struct
198 * return_value - Not used
199 *
200 * RETURN: Status
201 *
202 * DESCRIPTION: Callback from acpi_walk_namespace. Invoked for every object
203 * within the namespace.
204 *
205 * Currently, the only objects that require initialization are:
206 * 1) Methods
207 * 2) Op Regions
208 *
209 ******************************************************************************/
211 static acpi_status
212 acpi_ns_init_one_object(acpi_handle obj_handle,
213 u32 level, void *context, void **return_value)
214 {
215 acpi_object_type type;
216 acpi_status status;
217 struct acpi_init_walk_info *info =
218 (struct acpi_init_walk_info *)context;
219 struct acpi_namespace_node *node =
220 (struct acpi_namespace_node *)obj_handle;
221 union acpi_operand_object *obj_desc;
223 ACPI_FUNCTION_NAME(ns_init_one_object);
225 info->object_count++;
227 /* And even then, we are only interested in a few object types */
229 type = acpi_ns_get_type(obj_handle);
230 obj_desc = acpi_ns_get_attached_object(node);
231 if (!obj_desc) {
232 return (AE_OK);
233 }
235 /* Increment counters for object types we are looking for */
237 switch (type) {
238 case ACPI_TYPE_REGION:
239 info->op_region_count++;
240 break;
242 case ACPI_TYPE_BUFFER_FIELD:
243 info->field_count++;
244 break;
246 case ACPI_TYPE_BUFFER:
247 info->buffer_count++;
248 break;
250 case ACPI_TYPE_PACKAGE:
251 info->package_count++;
252 break;
254 default:
256 /* No init required, just exit now */
257 return (AE_OK);
258 }
260 /*
261 * If the object is already initialized, nothing else to do
262 */
263 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
264 return (AE_OK);
265 }
267 /*
268 * Must lock the interpreter before executing AML code
269 */
270 status = acpi_ex_enter_interpreter();
271 if (ACPI_FAILURE(status)) {
272 return (status);
273 }
275 /*
276 * Each of these types can contain executable AML code within the
277 * declaration.
278 */
279 switch (type) {
280 case ACPI_TYPE_REGION:
282 info->op_region_init++;
283 status = acpi_ds_get_region_arguments(obj_desc);
284 break;
286 case ACPI_TYPE_BUFFER_FIELD:
288 info->field_init++;
289 status = acpi_ds_get_buffer_field_arguments(obj_desc);
290 break;
292 case ACPI_TYPE_BUFFER:
294 info->buffer_init++;
295 status = acpi_ds_get_buffer_arguments(obj_desc);
296 break;
298 case ACPI_TYPE_PACKAGE:
300 info->package_init++;
301 status = acpi_ds_get_package_arguments(obj_desc);
302 break;
304 default:
305 /* No other types can get here */
306 break;
307 }
309 if (ACPI_FAILURE(status)) {
310 ACPI_EXCEPTION((AE_INFO, status,
311 "Could not execute arguments for [%4.4s] (%s)",
312 acpi_ut_get_node_name(node),
313 acpi_ut_get_type_name(type)));
314 }
316 /*
317 * Print a dot for each object unless we are going to print the entire
318 * pathname
319 */
320 if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) {
321 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, "."));
322 }
324 /*
325 * We ignore errors from above, and always return OK, since we don't want
326 * to abort the walk on any single error.
327 */
328 acpi_ex_exit_interpreter();
329 return (AE_OK);
330 }
332 /*******************************************************************************
333 *
334 * FUNCTION: acpi_ns_find_ini_methods
335 *
336 * PARAMETERS: acpi_walk_callback
337 *
338 * RETURN: acpi_status
339 *
340 * DESCRIPTION: Called during namespace walk. Finds objects named _INI under
341 * device/processor/thermal objects, and marks the entire subtree
342 * with a SUBTREE_HAS_INI flag. This flag is used during the
343 * subsequent device initialization walk to avoid entire subtrees
344 * that do not contain an _INI.
345 *
346 ******************************************************************************/
348 static acpi_status
349 acpi_ns_find_ini_methods(acpi_handle obj_handle,
350 u32 nesting_level, void *context, void **return_value)
351 {
352 struct acpi_device_walk_info *info =
353 ACPI_CAST_PTR(struct acpi_device_walk_info, context);
354 struct acpi_namespace_node *node;
355 struct acpi_namespace_node *parent_node;
357 /* Keep count of device/processor/thermal objects */
359 node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
360 if ((node->type == ACPI_TYPE_DEVICE) ||
361 (node->type == ACPI_TYPE_PROCESSOR) ||
362 (node->type == ACPI_TYPE_THERMAL)) {
363 info->device_count++;
364 return (AE_OK);
365 }
367 /* We are only looking for methods named _INI */
369 if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) {
370 return (AE_OK);
371 }
373 /*
374 * The only _INI methods that we care about are those that are
375 * present under Device, Processor, and Thermal objects.
376 */
377 parent_node = acpi_ns_get_parent_node(node);
378 switch (parent_node->type) {
379 case ACPI_TYPE_DEVICE:
380 case ACPI_TYPE_PROCESSOR:
381 case ACPI_TYPE_THERMAL:
383 /* Mark parent and bubble up the INI present flag to the root */
385 while (parent_node) {
386 parent_node->flags |= ANOBJ_SUBTREE_HAS_INI;
387 parent_node = acpi_ns_get_parent_node(parent_node);
388 }
389 break;
391 default:
392 break;
393 }
395 return (AE_OK);
396 }
398 /*******************************************************************************
399 *
400 * FUNCTION: acpi_ns_init_one_device
401 *
402 * PARAMETERS: acpi_walk_callback
403 *
404 * RETURN: acpi_status
405 *
406 * DESCRIPTION: This is called once per device soon after ACPI is enabled
407 * to initialize each device. It determines if the device is
408 * present, and if so, calls _INI.
409 *
410 ******************************************************************************/
412 static acpi_status
413 acpi_ns_init_one_device(acpi_handle obj_handle,
414 u32 nesting_level, void *context, void **return_value)
415 {
416 struct acpi_device_walk_info *walk_info =
417 ACPI_CAST_PTR(struct acpi_device_walk_info, context);
418 struct acpi_evaluate_info *info = walk_info->evaluate_info;
419 u32 flags;
420 acpi_status status;
421 struct acpi_namespace_node *device_node;
423 ACPI_FUNCTION_TRACE(ns_init_one_device);
425 /* We are interested in Devices, Processors and thermal_zones only */
427 device_node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
428 if ((device_node->type != ACPI_TYPE_DEVICE) &&
429 (device_node->type != ACPI_TYPE_PROCESSOR) &&
430 (device_node->type != ACPI_TYPE_THERMAL)) {
431 return_ACPI_STATUS(AE_OK);
432 }
434 /*
435 * Because of an earlier namespace analysis, all subtrees that contain an
436 * _INI method are tagged.
437 *
438 * If this device subtree does not contain any _INI methods, we
439 * can exit now and stop traversing this entire subtree.
440 */
441 if (!(device_node->flags & ANOBJ_SUBTREE_HAS_INI)) {
442 return_ACPI_STATUS(AE_CTRL_DEPTH);
443 }
445 /*
446 * Run _STA to determine if this device is present and functioning. We
447 * must know this information for two important reasons (from ACPI spec):
448 *
449 * 1) We can only run _INI if the device is present.
450 * 2) We must abort the device tree walk on this subtree if the device is
451 * not present and is not functional (we will not examine the children)
452 *
453 * The _STA method is not required to be present under the device, we
454 * assume the device is present if _STA does not exist.
455 */
456 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
457 (ACPI_TYPE_METHOD, device_node, METHOD_NAME__STA));
459 status = acpi_ut_execute_STA(device_node, &flags);
460 if (ACPI_FAILURE(status)) {
462 /* Ignore error and move on to next device */
464 return_ACPI_STATUS(AE_OK);
465 }
467 /*
468 * Flags == -1 means that _STA was not found. In this case, we assume that
469 * the device is both present and functional.
470 *
471 * From the ACPI spec, description of _STA:
472 *
473 * "If a device object (including the processor object) does not have an
474 * _STA object, then OSPM assumes that all of the above bits are set (in
475 * other words, the device is present, ..., and functioning)"
476 */
477 if (flags != ACPI_UINT32_MAX) {
478 walk_info->num_STA++;
479 }
481 /*
482 * Examine the PRESENT and FUNCTIONING status bits
483 *
484 * Note: ACPI spec does not seem to specify behavior for the present but
485 * not functioning case, so we assume functioning if present.
486 */
487 if (!(flags & ACPI_STA_DEVICE_PRESENT)) {
489 /* Device is not present, we must examine the Functioning bit */
491 if (flags & ACPI_STA_DEVICE_FUNCTIONING) {
492 /*
493 * Device is not present but is "functioning". In this case,
494 * we will not run _INI, but we continue to examine the children
495 * of this device.
496 *
497 * From the ACPI spec, description of _STA: (Note - no mention
498 * of whether to run _INI or not on the device in question)
499 *
500 * "_STA may return bit 0 clear (not present) with bit 3 set
501 * (device is functional). This case is used to indicate a valid
502 * device for which no device driver should be loaded (for example,
503 * a bridge device.) Children of this device may be present and
504 * valid. OSPM should continue enumeration below a device whose
505 * _STA returns this bit combination"
506 */
507 return_ACPI_STATUS(AE_OK);
508 } else {
509 /*
510 * Device is not present and is not functioning. We must abort the
511 * walk of this subtree immediately -- don't look at the children
512 * of such a device.
513 *
514 * From the ACPI spec, description of _INI:
515 *
516 * "If the _STA method indicates that the device is not present,
517 * OSPM will not run the _INI and will not examine the children
518 * of the device for _INI methods"
519 */
520 return_ACPI_STATUS(AE_CTRL_DEPTH);
521 }
522 }
524 /*
525 * The device is present or is assumed present if no _STA exists.
526 * Run the _INI if it exists (not required to exist)
527 *
528 * Note: We know there is an _INI within this subtree, but it may not be
529 * under this particular device, it may be lower in the branch.
530 */
531 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
532 (ACPI_TYPE_METHOD, device_node, METHOD_NAME__INI));
534 info->prefix_node = device_node;
535 info->pathname = METHOD_NAME__INI;
536 info->parameters = NULL;
537 info->parameter_type = ACPI_PARAM_ARGS;
538 info->flags = ACPI_IGNORE_RETURN_VALUE;
540 status = acpi_ns_evaluate(info);
541 if (ACPI_SUCCESS(status)) {
542 walk_info->num_INI++;
544 if ((acpi_dbg_level <= ACPI_LV_ALL_EXCEPTIONS) &&
545 (!(acpi_dbg_level & ACPI_LV_INFO))) {
546 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, "."));
547 }
548 }
549 #ifdef ACPI_DEBUG_OUTPUT
550 else if (status != AE_NOT_FOUND) {
552 /* Ignore error and move on to next device */
554 char *scope_name =
555 acpi_ns_get_external_pathname(info->resolved_node);
557 ACPI_EXCEPTION((AE_INFO, status, "during %s._INI execution",
558 scope_name));
559 ACPI_FREE(scope_name);
560 }
561 #endif
563 /* Ignore errors from above */
565 status = AE_OK;
567 /*
568 * The _INI method has been run if present; call the Global Initialization
569 * Handler for this device.
570 */
571 if (acpi_gbl_init_handler) {
572 status =
573 acpi_gbl_init_handler(device_node, ACPI_INIT_DEVICE_INI);
574 }
576 return_ACPI_STATUS(status);
577 }