ia64/linux-2.6.18-xen.hg

view drivers/acpi/utilities/utdelete.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: utdelete - object deletion and reference count utilities
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/acinterp.h>
46 #include <acpi/acnamesp.h>
47 #include <acpi/acevents.h>
48 #include <acpi/amlcode.h>
50 #define _COMPONENT ACPI_UTILITIES
51 ACPI_MODULE_NAME("utdelete")
53 /* Local prototypes */
54 static void acpi_ut_delete_internal_obj(union acpi_operand_object *object);
56 static void
57 acpi_ut_update_ref_count(union acpi_operand_object *object, u32 action);
59 /*******************************************************************************
60 *
61 * FUNCTION: acpi_ut_delete_internal_obj
62 *
63 * PARAMETERS: Object - Object to be deleted
64 *
65 * RETURN: None
66 *
67 * DESCRIPTION: Low level object deletion, after reference counts have been
68 * updated (All reference counts, including sub-objects!)
69 *
70 ******************************************************************************/
72 static void acpi_ut_delete_internal_obj(union acpi_operand_object *object)
73 {
74 void *obj_pointer = NULL;
75 union acpi_operand_object *handler_desc;
76 union acpi_operand_object *second_desc;
77 union acpi_operand_object *next_desc;
79 ACPI_FUNCTION_TRACE_PTR(ut_delete_internal_obj, object);
81 if (!object) {
82 return_VOID;
83 }
85 /*
86 * Must delete or free any pointers within the object that are not
87 * actual ACPI objects (for example, a raw buffer pointer).
88 */
89 switch (ACPI_GET_OBJECT_TYPE(object)) {
90 case ACPI_TYPE_STRING:
92 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
93 "**** String %p, ptr %p\n", object,
94 object->string.pointer));
96 /* Free the actual string buffer */
98 if (!(object->common.flags & AOPOBJ_STATIC_POINTER)) {
100 /* But only if it is NOT a pointer into an ACPI table */
102 obj_pointer = object->string.pointer;
103 }
104 break;
106 case ACPI_TYPE_BUFFER:
108 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
109 "**** Buffer %p, ptr %p\n", object,
110 object->buffer.pointer));
112 /* Free the actual buffer */
114 if (!(object->common.flags & AOPOBJ_STATIC_POINTER)) {
116 /* But only if it is NOT a pointer into an ACPI table */
118 obj_pointer = object->buffer.pointer;
119 }
120 break;
122 case ACPI_TYPE_PACKAGE:
124 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
125 " **** Package of count %X\n",
126 object->package.count));
128 /*
129 * Elements of the package are not handled here, they are deleted
130 * separately
131 */
133 /* Free the (variable length) element pointer array */
135 obj_pointer = object->package.elements;
136 break;
138 case ACPI_TYPE_DEVICE:
140 if (object->device.gpe_block) {
141 (void)acpi_ev_delete_gpe_block(object->device.
142 gpe_block);
143 }
145 /* Walk the handler list for this device */
147 handler_desc = object->device.handler;
148 while (handler_desc) {
149 next_desc = handler_desc->address_space.next;
150 acpi_ut_remove_reference(handler_desc);
151 handler_desc = next_desc;
152 }
153 break;
155 case ACPI_TYPE_MUTEX:
157 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
158 "***** Mutex %p, OS Mutex %p\n",
159 object, object->mutex.os_mutex));
161 if (object->mutex.os_mutex != ACPI_GLOBAL_LOCK) {
162 acpi_ex_unlink_mutex(object);
163 acpi_os_delete_mutex(object->mutex.os_mutex);
164 } else {
165 /* Global Lock "mutex" is actually a counting semaphore */
167 (void)
168 acpi_os_delete_semaphore
169 (acpi_gbl_global_lock_semaphore);
170 acpi_gbl_global_lock_semaphore = NULL;
171 }
172 break;
174 case ACPI_TYPE_EVENT:
176 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
177 "***** Event %p, OS Semaphore %p\n",
178 object, object->event.os_semaphore));
180 (void)acpi_os_delete_semaphore(object->event.os_semaphore);
181 object->event.os_semaphore = NULL;
182 break;
184 case ACPI_TYPE_METHOD:
186 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
187 "***** Method %p\n", object));
189 /* Delete the method mutex if it exists */
191 if (object->method.mutex) {
192 acpi_os_delete_mutex(object->method.mutex->mutex.
193 os_mutex);
194 acpi_ut_delete_object_desc(object->method.mutex);
195 object->method.mutex = NULL;
196 }
197 break;
199 case ACPI_TYPE_REGION:
201 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
202 "***** Region %p\n", object));
204 second_desc = acpi_ns_get_secondary_object(object);
205 if (second_desc) {
206 /*
207 * Free the region_context if and only if the handler is one of the
208 * default handlers -- and therefore, we created the context object
209 * locally, it was not created by an external caller.
210 */
211 handler_desc = object->region.handler;
212 if (handler_desc) {
213 if (handler_desc->address_space.handler_flags &
214 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) {
216 /* Deactivate region and free region context */
218 if (handler_desc->address_space.setup) {
219 (void)handler_desc->
220 address_space.setup(object,
221 ACPI_REGION_DEACTIVATE,
222 handler_desc->
223 address_space.
224 context,
225 &second_desc->
226 extra.
227 region_context);
228 }
229 }
231 acpi_ut_remove_reference(handler_desc);
232 }
234 /* Now we can free the Extra object */
236 acpi_ut_delete_object_desc(second_desc);
237 }
238 break;
240 case ACPI_TYPE_BUFFER_FIELD:
242 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
243 "***** Buffer Field %p\n", object));
245 second_desc = acpi_ns_get_secondary_object(object);
246 if (second_desc) {
247 acpi_ut_delete_object_desc(second_desc);
248 }
249 break;
251 default:
252 break;
253 }
255 /* Free any allocated memory (pointer within the object) found above */
257 if (obj_pointer) {
258 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
259 "Deleting Object Subptr %p\n", obj_pointer));
260 ACPI_FREE(obj_pointer);
261 }
263 /* Now the object can be safely deleted */
265 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n",
266 object, acpi_ut_get_object_type_name(object)));
268 acpi_ut_delete_object_desc(object);
269 return_VOID;
270 }
272 /*******************************************************************************
273 *
274 * FUNCTION: acpi_ut_delete_internal_object_list
275 *
276 * PARAMETERS: obj_list - Pointer to the list to be deleted
277 *
278 * RETURN: None
279 *
280 * DESCRIPTION: This function deletes an internal object list, including both
281 * simple objects and package objects
282 *
283 ******************************************************************************/
285 void acpi_ut_delete_internal_object_list(union acpi_operand_object **obj_list)
286 {
287 union acpi_operand_object **internal_obj;
289 ACPI_FUNCTION_TRACE(ut_delete_internal_object_list);
291 /* Walk the null-terminated internal list */
293 for (internal_obj = obj_list; *internal_obj; internal_obj++) {
294 acpi_ut_remove_reference(*internal_obj);
295 }
297 /* Free the combined parameter pointer list and object array */
299 ACPI_FREE(obj_list);
300 return_VOID;
301 }
303 /*******************************************************************************
304 *
305 * FUNCTION: acpi_ut_update_ref_count
306 *
307 * PARAMETERS: Object - Object whose ref count is to be updated
308 * Action - What to do
309 *
310 * RETURN: New ref count
311 *
312 * DESCRIPTION: Modify the ref count and return it.
313 *
314 ******************************************************************************/
316 static void
317 acpi_ut_update_ref_count(union acpi_operand_object *object, u32 action)
318 {
319 u16 count;
320 u16 new_count;
322 ACPI_FUNCTION_NAME(ut_update_ref_count);
324 if (!object) {
325 return;
326 }
328 count = object->common.reference_count;
329 new_count = count;
331 /*
332 * Perform the reference count action (increment, decrement, force delete)
333 */
334 switch (action) {
335 case REF_INCREMENT:
337 new_count++;
338 object->common.reference_count = new_count;
340 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
341 "Obj %p Refs=%X, [Incremented]\n",
342 object, new_count));
343 break;
345 case REF_DECREMENT:
347 if (count < 1) {
348 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
349 "Obj %p Refs=%X, can't decrement! (Set to 0)\n",
350 object, new_count));
352 new_count = 0;
353 } else {
354 new_count--;
356 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
357 "Obj %p Refs=%X, [Decremented]\n",
358 object, new_count));
359 }
361 if (ACPI_GET_OBJECT_TYPE(object) == ACPI_TYPE_METHOD) {
362 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
363 "Method Obj %p Refs=%X, [Decremented]\n",
364 object, new_count));
365 }
367 object->common.reference_count = new_count;
368 if (new_count == 0) {
369 acpi_ut_delete_internal_obj(object);
370 }
371 break;
373 case REF_FORCE_DELETE:
375 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
376 "Obj %p Refs=%X, Force delete! (Set to 0)\n",
377 object, count));
379 new_count = 0;
380 object->common.reference_count = new_count;
381 acpi_ut_delete_internal_obj(object);
382 break;
384 default:
386 ACPI_ERROR((AE_INFO, "Unknown action (%X)", action));
387 break;
388 }
390 /*
391 * Sanity check the reference count, for debug purposes only.
392 * (A deleted object will have a huge reference count)
393 */
394 if (count > ACPI_MAX_REFERENCE_COUNT) {
395 ACPI_WARNING((AE_INFO,
396 "Large Reference Count (%X) in object %p", count,
397 object));
398 }
399 }
401 /*******************************************************************************
402 *
403 * FUNCTION: acpi_ut_update_object_reference
404 *
405 * PARAMETERS: Object - Increment ref count for this object
406 * and all sub-objects
407 * Action - Either REF_INCREMENT or REF_DECREMENT or
408 * REF_FORCE_DELETE
409 *
410 * RETURN: Status
411 *
412 * DESCRIPTION: Increment the object reference count
413 *
414 * Object references are incremented when:
415 * 1) An object is attached to a Node (namespace object)
416 * 2) An object is copied (all subobjects must be incremented)
417 *
418 * Object references are decremented when:
419 * 1) An object is detached from an Node
420 *
421 ******************************************************************************/
423 acpi_status
424 acpi_ut_update_object_reference(union acpi_operand_object *object, u16 action)
425 {
426 acpi_status status = AE_OK;
427 union acpi_generic_state *state_list = NULL;
428 union acpi_operand_object *next_object = NULL;
429 union acpi_generic_state *state;
430 acpi_native_uint i;
432 ACPI_FUNCTION_TRACE_PTR(ut_update_object_reference, object);
434 while (object) {
436 /* Make sure that this isn't a namespace handle */
438 if (ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_NAMED) {
439 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
440 "Object %p is NS handle\n", object));
441 return_ACPI_STATUS(AE_OK);
442 }
444 /*
445 * All sub-objects must have their reference count incremented also.
446 * Different object types have different subobjects.
447 */
448 switch (ACPI_GET_OBJECT_TYPE(object)) {
449 case ACPI_TYPE_DEVICE:
450 case ACPI_TYPE_PROCESSOR:
451 case ACPI_TYPE_POWER:
452 case ACPI_TYPE_THERMAL:
454 /* Update the notify objects for these types (if present) */
456 acpi_ut_update_ref_count(object->common_notify.
457 system_notify, action);
458 acpi_ut_update_ref_count(object->common_notify.
459 device_notify, action);
460 break;
462 case ACPI_TYPE_PACKAGE:
463 /*
464 * We must update all the sub-objects of the package,
465 * each of whom may have their own sub-objects.
466 */
467 for (i = 0; i < object->package.count; i++) {
468 /*
469 * Push each element onto the stack for later processing.
470 * Note: There can be null elements within the package,
471 * these are simply ignored
472 */
473 status =
474 acpi_ut_create_update_state_and_push
475 (object->package.elements[i], action,
476 &state_list);
477 if (ACPI_FAILURE(status)) {
478 goto error_exit;
479 }
480 }
481 break;
483 case ACPI_TYPE_BUFFER_FIELD:
485 next_object = object->buffer_field.buffer_obj;
486 break;
488 case ACPI_TYPE_LOCAL_REGION_FIELD:
490 next_object = object->field.region_obj;
491 break;
493 case ACPI_TYPE_LOCAL_BANK_FIELD:
495 next_object = object->bank_field.bank_obj;
496 status =
497 acpi_ut_create_update_state_and_push(object->
498 bank_field.
499 region_obj,
500 action,
501 &state_list);
502 if (ACPI_FAILURE(status)) {
503 goto error_exit;
504 }
505 break;
507 case ACPI_TYPE_LOCAL_INDEX_FIELD:
509 next_object = object->index_field.index_obj;
510 status =
511 acpi_ut_create_update_state_and_push(object->
512 index_field.
513 data_obj,
514 action,
515 &state_list);
516 if (ACPI_FAILURE(status)) {
517 goto error_exit;
518 }
519 break;
521 case ACPI_TYPE_LOCAL_REFERENCE:
522 /*
523 * The target of an Index (a package, string, or buffer) must track
524 * changes to the ref count of the index.
525 */
526 if (object->reference.opcode == AML_INDEX_OP) {
527 next_object = object->reference.object;
528 }
529 break;
531 case ACPI_TYPE_REGION:
532 default:
533 break; /* No subobjects for all other types */
534 }
536 /*
537 * Now we can update the count in the main object. This can only
538 * happen after we update the sub-objects in case this causes the
539 * main object to be deleted.
540 */
541 acpi_ut_update_ref_count(object, action);
542 object = NULL;
544 /* Move on to the next object to be updated */
546 if (next_object) {
547 object = next_object;
548 next_object = NULL;
549 } else if (state_list) {
550 state = acpi_ut_pop_generic_state(&state_list);
551 object = state->update.object;
552 acpi_ut_delete_generic_state(state);
553 }
554 }
556 return_ACPI_STATUS(AE_OK);
558 error_exit:
560 ACPI_EXCEPTION((AE_INFO, status,
561 "Could not update object reference count"));
563 return_ACPI_STATUS(status);
564 }
566 /*******************************************************************************
567 *
568 * FUNCTION: acpi_ut_add_reference
569 *
570 * PARAMETERS: Object - Object whose reference count is to be
571 * incremented
572 *
573 * RETURN: None
574 *
575 * DESCRIPTION: Add one reference to an ACPI object
576 *
577 ******************************************************************************/
579 void acpi_ut_add_reference(union acpi_operand_object *object)
580 {
582 ACPI_FUNCTION_TRACE_PTR(ut_add_reference, object);
584 /* Ensure that we have a valid object */
586 if (!acpi_ut_valid_internal_object(object)) {
587 return_VOID;
588 }
590 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
591 "Obj %p Current Refs=%X [To Be Incremented]\n",
592 object, object->common.reference_count));
594 /* Increment the reference count */
596 (void)acpi_ut_update_object_reference(object, REF_INCREMENT);
597 return_VOID;
598 }
600 /*******************************************************************************
601 *
602 * FUNCTION: acpi_ut_remove_reference
603 *
604 * PARAMETERS: Object - Object whose ref count will be decremented
605 *
606 * RETURN: None
607 *
608 * DESCRIPTION: Decrement the reference count of an ACPI internal object
609 *
610 ******************************************************************************/
612 void acpi_ut_remove_reference(union acpi_operand_object *object)
613 {
615 ACPI_FUNCTION_TRACE_PTR(ut_remove_reference, object);
617 /*
618 * Allow a NULL pointer to be passed in, just ignore it. This saves
619 * each caller from having to check. Also, ignore NS nodes.
620 *
621 */
622 if (!object ||
623 (ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_NAMED)) {
624 return_VOID;
625 }
627 /* Ensure that we have a valid object */
629 if (!acpi_ut_valid_internal_object(object)) {
630 return_VOID;
631 }
633 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
634 "Obj %p Current Refs=%X [To Be Decremented]\n",
635 object, object->common.reference_count));
637 /*
638 * Decrement the reference count, and only actually delete the object
639 * if the reference count becomes 0. (Must also decrement the ref count
640 * of all subobjects!)
641 */
642 (void)acpi_ut_update_object_reference(object, REF_DECREMENT);
643 return_VOID;
644 }