ia64/linux-2.6.18-xen.hg

view drivers/acpi/utilities/utobject.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: utobject - ACPI object create/delete/size/cache routines
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/amlcode.h>
48 #define _COMPONENT ACPI_UTILITIES
49 ACPI_MODULE_NAME("utobject")
51 /* Local prototypes */
52 static acpi_status
53 acpi_ut_get_simple_object_size(union acpi_operand_object *obj,
54 acpi_size * obj_length);
56 static acpi_status
57 acpi_ut_get_package_object_size(union acpi_operand_object *obj,
58 acpi_size * obj_length);
60 static acpi_status
61 acpi_ut_get_element_length(u8 object_type,
62 union acpi_operand_object *source_object,
63 union acpi_generic_state *state, void *context);
65 /*******************************************************************************
66 *
67 * FUNCTION: acpi_ut_create_internal_object_dbg
68 *
69 * PARAMETERS: module_name - Source file name of caller
70 * line_number - Line number of caller
71 * component_id - Component type of caller
72 * Type - ACPI Type of the new object
73 *
74 * RETURN: A new internal object, null on failure
75 *
76 * DESCRIPTION: Create and initialize a new internal object.
77 *
78 * NOTE: We always allocate the worst-case object descriptor because
79 * these objects are cached, and we want them to be
80 * one-size-satisifies-any-request. This in itself may not be
81 * the most memory efficient, but the efficiency of the object
82 * cache should more than make up for this!
83 *
84 ******************************************************************************/
86 union acpi_operand_object *acpi_ut_create_internal_object_dbg(char *module_name,
87 u32 line_number,
88 u32 component_id,
89 acpi_object_type
90 type)
91 {
92 union acpi_operand_object *object;
93 union acpi_operand_object *second_object;
95 ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg,
96 acpi_ut_get_type_name(type));
98 /* Allocate the raw object descriptor */
100 object =
101 acpi_ut_allocate_object_desc_dbg(module_name, line_number,
102 component_id);
103 if (!object) {
104 return_PTR(NULL);
105 }
107 switch (type) {
108 case ACPI_TYPE_REGION:
109 case ACPI_TYPE_BUFFER_FIELD:
111 /* These types require a secondary object */
113 second_object = acpi_ut_allocate_object_desc_dbg(module_name,
114 line_number,
115 component_id);
116 if (!second_object) {
117 acpi_ut_delete_object_desc(object);
118 return_PTR(NULL);
119 }
121 second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
122 second_object->common.reference_count = 1;
124 /* Link the second object to the first */
126 object->common.next_object = second_object;
127 break;
129 default:
130 /* All others have no secondary object */
131 break;
132 }
134 /* Save the object type in the object descriptor */
136 object->common.type = (u8) type;
138 /* Init the reference count */
140 object->common.reference_count = 1;
142 /* Any per-type initialization should go here */
144 return_PTR(object);
145 }
147 /*******************************************************************************
148 *
149 * FUNCTION: acpi_ut_create_buffer_object
150 *
151 * PARAMETERS: buffer_size - Size of buffer to be created
152 *
153 * RETURN: Pointer to a new Buffer object, null on failure
154 *
155 * DESCRIPTION: Create a fully initialized buffer object
156 *
157 ******************************************************************************/
159 union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
160 {
161 union acpi_operand_object *buffer_desc;
162 u8 *buffer = NULL;
164 ACPI_FUNCTION_TRACE_U32(ut_create_buffer_object, buffer_size);
166 /* Create a new Buffer object */
168 buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
169 if (!buffer_desc) {
170 return_PTR(NULL);
171 }
173 /* Create an actual buffer only if size > 0 */
175 if (buffer_size > 0) {
177 /* Allocate the actual buffer */
179 buffer = ACPI_ALLOCATE_ZEROED(buffer_size);
180 if (!buffer) {
181 ACPI_ERROR((AE_INFO, "Could not allocate size %X",
182 (u32) buffer_size));
183 acpi_ut_remove_reference(buffer_desc);
184 return_PTR(NULL);
185 }
186 }
188 /* Complete buffer object initialization */
190 buffer_desc->buffer.flags |= AOPOBJ_DATA_VALID;
191 buffer_desc->buffer.pointer = buffer;
192 buffer_desc->buffer.length = (u32) buffer_size;
194 /* Return the new buffer descriptor */
196 return_PTR(buffer_desc);
197 }
199 /*******************************************************************************
200 *
201 * FUNCTION: acpi_ut_create_string_object
202 *
203 * PARAMETERS: string_size - Size of string to be created. Does not
204 * include NULL terminator, this is added
205 * automatically.
206 *
207 * RETURN: Pointer to a new String object
208 *
209 * DESCRIPTION: Create a fully initialized string object
210 *
211 ******************************************************************************/
213 union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
214 {
215 union acpi_operand_object *string_desc;
216 char *string;
218 ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size);
220 /* Create a new String object */
222 string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
223 if (!string_desc) {
224 return_PTR(NULL);
225 }
227 /*
228 * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
229 * NOTE: Zero-length strings are NULL terminated
230 */
231 string = ACPI_ALLOCATE_ZEROED(string_size + 1);
232 if (!string) {
233 ACPI_ERROR((AE_INFO, "Could not allocate size %X",
234 (u32) string_size));
235 acpi_ut_remove_reference(string_desc);
236 return_PTR(NULL);
237 }
239 /* Complete string object initialization */
241 string_desc->string.pointer = string;
242 string_desc->string.length = (u32) string_size;
244 /* Return the new string descriptor */
246 return_PTR(string_desc);
247 }
249 /*******************************************************************************
250 *
251 * FUNCTION: acpi_ut_valid_internal_object
252 *
253 * PARAMETERS: Object - Object to be validated
254 *
255 * RETURN: TRUE if object is valid, FALSE otherwise
256 *
257 * DESCRIPTION: Validate a pointer to be an union acpi_operand_object
258 *
259 ******************************************************************************/
261 u8 acpi_ut_valid_internal_object(void *object)
262 {
264 ACPI_FUNCTION_NAME(ut_valid_internal_object);
266 /* Check for a null pointer */
268 if (!object) {
269 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "**** Null Object Ptr\n"));
270 return (FALSE);
271 }
273 /* Check the descriptor type field */
275 switch (ACPI_GET_DESCRIPTOR_TYPE(object)) {
276 case ACPI_DESC_TYPE_OPERAND:
278 /* The object appears to be a valid union acpi_operand_object */
280 return (TRUE);
282 default:
283 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
284 "%p is not not an ACPI operand obj [%s]\n",
285 object, acpi_ut_get_descriptor_name(object)));
286 break;
287 }
289 return (FALSE);
290 }
292 /*******************************************************************************
293 *
294 * FUNCTION: acpi_ut_allocate_object_desc_dbg
295 *
296 * PARAMETERS: module_name - Caller's module name (for error output)
297 * line_number - Caller's line number (for error output)
298 * component_id - Caller's component ID (for error output)
299 *
300 * RETURN: Pointer to newly allocated object descriptor. Null on error
301 *
302 * DESCRIPTION: Allocate a new object descriptor. Gracefully handle
303 * error conditions.
304 *
305 ******************************************************************************/
307 void *acpi_ut_allocate_object_desc_dbg(char *module_name,
308 u32 line_number, u32 component_id)
309 {
310 union acpi_operand_object *object;
312 ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg);
314 object = acpi_os_acquire_object(acpi_gbl_operand_cache);
315 if (!object) {
316 ACPI_ERROR((module_name, line_number,
317 "Could not allocate an object descriptor"));
319 return_PTR(NULL);
320 }
322 /* Mark the descriptor type */
324 memset(object, 0, sizeof(union acpi_operand_object));
325 ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
327 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
328 object, (u32) sizeof(union acpi_operand_object)));
330 return_PTR(object);
331 }
333 /*******************************************************************************
334 *
335 * FUNCTION: acpi_ut_delete_object_desc
336 *
337 * PARAMETERS: Object - An Acpi internal object to be deleted
338 *
339 * RETURN: None.
340 *
341 * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache
342 *
343 ******************************************************************************/
345 void acpi_ut_delete_object_desc(union acpi_operand_object *object)
346 {
347 ACPI_FUNCTION_TRACE_PTR(ut_delete_object_desc, object);
349 /* Object must be an union acpi_operand_object */
351 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
352 ACPI_ERROR((AE_INFO,
353 "%p is not an ACPI Operand object [%s]", object,
354 acpi_ut_get_descriptor_name(object)));
355 return_VOID;
356 }
358 (void)acpi_os_release_object(acpi_gbl_operand_cache, object);
359 return_VOID;
360 }
362 /*******************************************************************************
363 *
364 * FUNCTION: acpi_ut_get_simple_object_size
365 *
366 * PARAMETERS: internal_object - An ACPI operand object
367 * obj_length - Where the length is returned
368 *
369 * RETURN: Status
370 *
371 * DESCRIPTION: This function is called to determine the space required to
372 * contain a simple object for return to an external user.
373 *
374 * The length includes the object structure plus any additional
375 * needed space.
376 *
377 ******************************************************************************/
379 static acpi_status
380 acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object,
381 acpi_size * obj_length)
382 {
383 acpi_size length;
384 acpi_status status = AE_OK;
386 ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object);
388 /*
389 * Handle a null object (Could be a uninitialized package
390 * element -- which is legal)
391 */
392 if (!internal_object) {
393 *obj_length = 0;
394 return_ACPI_STATUS(AE_OK);
395 }
397 /* Start with the length of the Acpi object */
399 length = sizeof(union acpi_object);
401 if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
403 /* Object is a named object (reference), just return the length */
405 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
406 return_ACPI_STATUS(status);
407 }
409 /*
410 * The final length depends on the object type
411 * Strings and Buffers are packed right up against the parent object and
412 * must be accessed bytewise or there may be alignment problems on
413 * certain processors
414 */
415 switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
416 case ACPI_TYPE_STRING:
418 length += (acpi_size) internal_object->string.length + 1;
419 break;
421 case ACPI_TYPE_BUFFER:
423 length += (acpi_size) internal_object->buffer.length;
424 break;
426 case ACPI_TYPE_INTEGER:
427 case ACPI_TYPE_PROCESSOR:
428 case ACPI_TYPE_POWER:
430 /*
431 * No extra data for these types
432 */
433 break;
435 case ACPI_TYPE_LOCAL_REFERENCE:
437 switch (internal_object->reference.opcode) {
438 case AML_INT_NAMEPATH_OP:
440 /*
441 * Get the actual length of the full pathname to this object.
442 * The reference will be converted to the pathname to the object
443 */
444 length +=
445 ACPI_ROUND_UP_TO_NATIVE_WORD
446 (acpi_ns_get_pathname_length
447 (internal_object->reference.node));
448 break;
450 default:
452 /*
453 * No other reference opcodes are supported.
454 * Notably, Locals and Args are not supported, but this may be
455 * required eventually.
456 */
457 ACPI_ERROR((AE_INFO,
458 "Unsupported Reference opcode=%X in object %p",
459 internal_object->reference.opcode,
460 internal_object));
461 status = AE_TYPE;
462 break;
463 }
464 break;
466 default:
468 ACPI_ERROR((AE_INFO, "Unsupported type=%X in object %p",
469 ACPI_GET_OBJECT_TYPE(internal_object),
470 internal_object));
471 status = AE_TYPE;
472 break;
473 }
475 /*
476 * Account for the space required by the object rounded up to the next
477 * multiple of the machine word size. This keeps each object aligned
478 * on a machine word boundary. (preventing alignment faults on some
479 * machines.)
480 */
481 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
482 return_ACPI_STATUS(status);
483 }
485 /*******************************************************************************
486 *
487 * FUNCTION: acpi_ut_get_element_length
488 *
489 * PARAMETERS: acpi_pkg_callback
490 *
491 * RETURN: Status
492 *
493 * DESCRIPTION: Get the length of one package element.
494 *
495 ******************************************************************************/
497 static acpi_status
498 acpi_ut_get_element_length(u8 object_type,
499 union acpi_operand_object *source_object,
500 union acpi_generic_state *state, void *context)
501 {
502 acpi_status status = AE_OK;
503 struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
504 acpi_size object_space;
506 switch (object_type) {
507 case ACPI_COPY_TYPE_SIMPLE:
509 /*
510 * Simple object - just get the size (Null object/entry is handled
511 * here also) and sum it into the running package length
512 */
513 status =
514 acpi_ut_get_simple_object_size(source_object,
515 &object_space);
516 if (ACPI_FAILURE(status)) {
517 return (status);
518 }
520 info->length += object_space;
521 break;
523 case ACPI_COPY_TYPE_PACKAGE:
525 /* Package object - nothing much to do here, let the walk handle it */
527 info->num_packages++;
528 state->pkg.this_target_obj = NULL;
529 break;
531 default:
533 /* No other types allowed */
535 return (AE_BAD_PARAMETER);
536 }
538 return (status);
539 }
541 /*******************************************************************************
542 *
543 * FUNCTION: acpi_ut_get_package_object_size
544 *
545 * PARAMETERS: internal_object - An ACPI internal object
546 * obj_length - Where the length is returned
547 *
548 * RETURN: Status
549 *
550 * DESCRIPTION: This function is called to determine the space required to
551 * contain a package object for return to an external user.
552 *
553 * This is moderately complex since a package contains other
554 * objects including packages.
555 *
556 ******************************************************************************/
558 static acpi_status
559 acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
560 acpi_size * obj_length)
561 {
562 acpi_status status;
563 struct acpi_pkg_info info;
565 ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object);
567 info.length = 0;
568 info.object_space = 0;
569 info.num_packages = 1;
571 status = acpi_ut_walk_package_tree(internal_object, NULL,
572 acpi_ut_get_element_length, &info);
573 if (ACPI_FAILURE(status)) {
574 return_ACPI_STATUS(status);
575 }
577 /*
578 * We have handled all of the objects in all levels of the package.
579 * just add the length of the package objects themselves.
580 * Round up to the next machine word.
581 */
582 info.length += ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
583 (acpi_size) info.num_packages;
585 /* Return the total package length */
587 *obj_length = info.length;
588 return_ACPI_STATUS(status);
589 }
591 /*******************************************************************************
592 *
593 * FUNCTION: acpi_ut_get_object_size
594 *
595 * PARAMETERS: internal_object - An ACPI internal object
596 * obj_length - Where the length will be returned
597 *
598 * RETURN: Status
599 *
600 * DESCRIPTION: This function is called to determine the space required to
601 * contain an object for return to an API user.
602 *
603 ******************************************************************************/
605 acpi_status
606 acpi_ut_get_object_size(union acpi_operand_object *internal_object,
607 acpi_size * obj_length)
608 {
609 acpi_status status;
611 ACPI_FUNCTION_ENTRY();
613 if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
614 ACPI_DESC_TYPE_OPERAND)
615 && (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE)) {
616 status =
617 acpi_ut_get_package_object_size(internal_object,
618 obj_length);
619 } else {
620 status =
621 acpi_ut_get_simple_object_size(internal_object, obj_length);
622 }
624 return (status);
625 }