ia64/linux-2.6.18-xen.hg

view drivers/acpi/namespace/nsdump.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: nsdump - table dumping routines for debug
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/acparser.h>
48 #define _COMPONENT ACPI_NAMESPACE
49 ACPI_MODULE_NAME("nsdump")
51 /* Local prototypes */
52 #ifdef ACPI_OBSOLETE_FUNCTIONS
53 void acpi_ns_dump_root_devices(void);
55 static acpi_status
56 acpi_ns_dump_one_device(acpi_handle obj_handle,
57 u32 level, void *context, void **return_value);
58 #endif
60 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
61 /*******************************************************************************
62 *
63 * FUNCTION: acpi_ns_print_pathname
64 *
65 * PARAMETERS: num_segments - Number of ACPI name segments
66 * Pathname - The compressed (internal) path
67 *
68 * RETURN: None
69 *
70 * DESCRIPTION: Print an object's full namespace pathname
71 *
72 ******************************************************************************/
74 void acpi_ns_print_pathname(u32 num_segments, char *pathname)
75 {
76 acpi_native_uint i;
78 ACPI_FUNCTION_NAME(ns_print_pathname);
80 if (!(acpi_dbg_level & ACPI_LV_NAMES)
81 || !(acpi_dbg_layer & ACPI_NAMESPACE)) {
82 return;
83 }
85 /* Print the entire name */
87 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, "["));
89 while (num_segments) {
90 for (i = 0; i < 4; i++) {
91 ACPI_IS_PRINT(pathname[i]) ?
92 acpi_os_printf("%c", pathname[i]) :
93 acpi_os_printf("?");
94 }
96 pathname += ACPI_NAME_SIZE;
97 num_segments--;
98 if (num_segments) {
99 acpi_os_printf(".");
100 }
101 }
103 acpi_os_printf("]\n");
104 }
106 /*******************************************************************************
107 *
108 * FUNCTION: acpi_ns_dump_pathname
109 *
110 * PARAMETERS: Handle - Object
111 * Msg - Prefix message
112 * Level - Desired debug level
113 * Component - Caller's component ID
114 *
115 * RETURN: None
116 *
117 * DESCRIPTION: Print an object's full namespace pathname
118 * Manages allocation/freeing of a pathname buffer
119 *
120 ******************************************************************************/
122 void
123 acpi_ns_dump_pathname(acpi_handle handle, char *msg, u32 level, u32 component)
124 {
126 ACPI_FUNCTION_TRACE(ns_dump_pathname);
128 /* Do this only if the requested debug level and component are enabled */
130 if (!(acpi_dbg_level & level) || !(acpi_dbg_layer & component)) {
131 return_VOID;
132 }
134 /* Convert handle to a full pathname and print it (with supplied message) */
136 acpi_ns_print_node_pathname(handle, msg);
137 acpi_os_printf("\n");
138 return_VOID;
139 }
141 /*******************************************************************************
142 *
143 * FUNCTION: acpi_ns_dump_one_object
144 *
145 * PARAMETERS: obj_handle - Node to be dumped
146 * Level - Nesting level of the handle
147 * Context - Passed into walk_namespace
148 * return_value - Not used
149 *
150 * RETURN: Status
151 *
152 * DESCRIPTION: Dump a single Node
153 * This procedure is a user_function called by acpi_ns_walk_namespace.
154 *
155 ******************************************************************************/
157 acpi_status
158 acpi_ns_dump_one_object(acpi_handle obj_handle,
159 u32 level, void *context, void **return_value)
160 {
161 struct acpi_walk_info *info = (struct acpi_walk_info *)context;
162 struct acpi_namespace_node *this_node;
163 union acpi_operand_object *obj_desc = NULL;
164 acpi_object_type obj_type;
165 acpi_object_type type;
166 u32 bytes_to_dump;
167 u32 dbg_level;
168 u32 i;
170 ACPI_FUNCTION_NAME(ns_dump_one_object);
172 /* Is output enabled? */
174 if (!(acpi_dbg_level & info->debug_level)) {
175 return (AE_OK);
176 }
178 if (!obj_handle) {
179 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Null object handle\n"));
180 return (AE_OK);
181 }
183 this_node = acpi_ns_map_handle_to_node(obj_handle);
184 type = this_node->type;
186 /* Check if the owner matches */
188 if ((info->owner_id != ACPI_OWNER_ID_MAX) &&
189 (info->owner_id != this_node->owner_id)) {
190 return (AE_OK);
191 }
193 if (!(info->display_type & ACPI_DISPLAY_SHORT)) {
195 /* Indent the object according to the level */
197 acpi_os_printf("%2d%*s", (u32) level - 1, (int)level * 2, " ");
199 /* Check the node type and name */
201 if (type > ACPI_TYPE_LOCAL_MAX) {
202 ACPI_WARNING((AE_INFO, "Invalid ACPI Object Type %08X",
203 type));
204 }
206 if (!acpi_ut_valid_acpi_name(this_node->name.integer)) {
207 this_node->name.integer =
208 acpi_ut_repair_name(this_node->name.integer);
210 ACPI_WARNING((AE_INFO, "Invalid ACPI Name %08X",
211 this_node->name.integer));
212 }
214 acpi_os_printf("%4.4s", acpi_ut_get_node_name(this_node));
215 }
217 /*
218 * Now we can print out the pertinent information
219 */
220 acpi_os_printf(" %-12s %p %2.2X ",
221 acpi_ut_get_type_name(type), this_node,
222 this_node->owner_id);
224 dbg_level = acpi_dbg_level;
225 acpi_dbg_level = 0;
226 obj_desc = acpi_ns_get_attached_object(this_node);
227 acpi_dbg_level = dbg_level;
229 switch (info->display_type & ACPI_DISPLAY_MASK) {
230 case ACPI_DISPLAY_SUMMARY:
232 if (!obj_desc) {
234 /* No attached object, we are done */
236 acpi_os_printf("\n");
237 return (AE_OK);
238 }
240 switch (type) {
241 case ACPI_TYPE_PROCESSOR:
243 acpi_os_printf("ID %X Len %.4X Addr %p\n",
244 obj_desc->processor.proc_id,
245 obj_desc->processor.length,
246 (char *)obj_desc->processor.address);
247 break;
249 case ACPI_TYPE_DEVICE:
251 acpi_os_printf("Notify Object: %p\n", obj_desc);
252 break;
254 case ACPI_TYPE_METHOD:
256 acpi_os_printf("Args %X Len %.4X Aml %p\n",
257 (u32) obj_desc->method.param_count,
258 obj_desc->method.aml_length,
259 obj_desc->method.aml_start);
260 break;
262 case ACPI_TYPE_INTEGER:
264 acpi_os_printf("= %8.8X%8.8X\n",
265 ACPI_FORMAT_UINT64(obj_desc->integer.
266 value));
267 break;
269 case ACPI_TYPE_PACKAGE:
271 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
272 acpi_os_printf("Elements %.2X\n",
273 obj_desc->package.count);
274 } else {
275 acpi_os_printf("[Length not yet evaluated]\n");
276 }
277 break;
279 case ACPI_TYPE_BUFFER:
281 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
282 acpi_os_printf("Len %.2X",
283 obj_desc->buffer.length);
285 /* Dump some of the buffer */
287 if (obj_desc->buffer.length > 0) {
288 acpi_os_printf(" =");
289 for (i = 0;
290 (i < obj_desc->buffer.length
291 && i < 12); i++) {
292 acpi_os_printf(" %.2hX",
293 obj_desc->buffer.
294 pointer[i]);
295 }
296 }
297 acpi_os_printf("\n");
298 } else {
299 acpi_os_printf("[Length not yet evaluated]\n");
300 }
301 break;
303 case ACPI_TYPE_STRING:
305 acpi_os_printf("Len %.2X ", obj_desc->string.length);
306 acpi_ut_print_string(obj_desc->string.pointer, 32);
307 acpi_os_printf("\n");
308 break;
310 case ACPI_TYPE_REGION:
312 acpi_os_printf("[%s]",
313 acpi_ut_get_region_name(obj_desc->region.
314 space_id));
315 if (obj_desc->region.flags & AOPOBJ_DATA_VALID) {
316 acpi_os_printf(" Addr %8.8X%8.8X Len %.4X\n",
317 ACPI_FORMAT_UINT64(obj_desc->
318 region.
319 address),
320 obj_desc->region.length);
321 } else {
322 acpi_os_printf
323 (" [Address/Length not yet evaluated]\n");
324 }
325 break;
327 case ACPI_TYPE_LOCAL_REFERENCE:
329 acpi_os_printf("[%s]\n",
330 acpi_ps_get_opcode_name(obj_desc->
331 reference.
332 opcode));
333 break;
335 case ACPI_TYPE_BUFFER_FIELD:
337 if (obj_desc->buffer_field.buffer_obj &&
338 obj_desc->buffer_field.buffer_obj->buffer.node) {
339 acpi_os_printf("Buf [%4.4s]",
340 acpi_ut_get_node_name(obj_desc->
341 buffer_field.
342 buffer_obj->
343 buffer.
344 node));
345 }
346 break;
348 case ACPI_TYPE_LOCAL_REGION_FIELD:
350 acpi_os_printf("Rgn [%4.4s]",
351 acpi_ut_get_node_name(obj_desc->
352 common_field.
353 region_obj->region.
354 node));
355 break;
357 case ACPI_TYPE_LOCAL_BANK_FIELD:
359 acpi_os_printf("Rgn [%4.4s] Bnk [%4.4s]",
360 acpi_ut_get_node_name(obj_desc->
361 common_field.
362 region_obj->region.
363 node),
364 acpi_ut_get_node_name(obj_desc->
365 bank_field.
366 bank_obj->
367 common_field.
368 node));
369 break;
371 case ACPI_TYPE_LOCAL_INDEX_FIELD:
373 acpi_os_printf("Idx [%4.4s] Dat [%4.4s]",
374 acpi_ut_get_node_name(obj_desc->
375 index_field.
376 index_obj->
377 common_field.node),
378 acpi_ut_get_node_name(obj_desc->
379 index_field.
380 data_obj->
381 common_field.
382 node));
383 break;
385 case ACPI_TYPE_LOCAL_ALIAS:
386 case ACPI_TYPE_LOCAL_METHOD_ALIAS:
388 acpi_os_printf("Target %4.4s (%p)\n",
389 acpi_ut_get_node_name(obj_desc),
390 obj_desc);
391 break;
393 default:
395 acpi_os_printf("Object %p\n", obj_desc);
396 break;
397 }
399 /* Common field handling */
401 switch (type) {
402 case ACPI_TYPE_BUFFER_FIELD:
403 case ACPI_TYPE_LOCAL_REGION_FIELD:
404 case ACPI_TYPE_LOCAL_BANK_FIELD:
405 case ACPI_TYPE_LOCAL_INDEX_FIELD:
407 acpi_os_printf(" Off %.3X Len %.2X Acc %.2hd\n",
408 (obj_desc->common_field.
409 base_byte_offset * 8)
410 +
411 obj_desc->common_field.
412 start_field_bit_offset,
413 obj_desc->common_field.bit_length,
414 obj_desc->common_field.
415 access_byte_width);
416 break;
418 default:
419 break;
420 }
421 break;
423 case ACPI_DISPLAY_OBJECTS:
425 acpi_os_printf("O:%p", obj_desc);
426 if (!obj_desc) {
428 /* No attached object, we are done */
430 acpi_os_printf("\n");
431 return (AE_OK);
432 }
434 acpi_os_printf("(R%d)", obj_desc->common.reference_count);
436 switch (type) {
437 case ACPI_TYPE_METHOD:
439 /* Name is a Method and its AML offset/length are set */
441 acpi_os_printf(" M:%p-%X\n", obj_desc->method.aml_start,
442 obj_desc->method.aml_length);
443 break;
445 case ACPI_TYPE_INTEGER:
447 acpi_os_printf(" I:%8.8X8.8%X\n",
448 ACPI_FORMAT_UINT64(obj_desc->integer.
449 value));
450 break;
452 case ACPI_TYPE_STRING:
454 acpi_os_printf(" S:%p-%X\n", obj_desc->string.pointer,
455 obj_desc->string.length);
456 break;
458 case ACPI_TYPE_BUFFER:
460 acpi_os_printf(" B:%p-%X\n", obj_desc->buffer.pointer,
461 obj_desc->buffer.length);
462 break;
464 default:
466 acpi_os_printf("\n");
467 break;
468 }
469 break;
471 default:
472 acpi_os_printf("\n");
473 break;
474 }
476 /* If debug turned off, done */
478 if (!(acpi_dbg_level & ACPI_LV_VALUES)) {
479 return (AE_OK);
480 }
482 /* If there is an attached object, display it */
484 dbg_level = acpi_dbg_level;
485 acpi_dbg_level = 0;
486 obj_desc = acpi_ns_get_attached_object(this_node);
487 acpi_dbg_level = dbg_level;
489 /* Dump attached objects */
491 while (obj_desc) {
492 obj_type = ACPI_TYPE_INVALID;
493 acpi_os_printf("Attached Object %p: ", obj_desc);
495 /* Decode the type of attached object and dump the contents */
497 switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) {
498 case ACPI_DESC_TYPE_NAMED:
500 acpi_os_printf("(Ptr to Node)\n");
501 bytes_to_dump = sizeof(struct acpi_namespace_node);
502 ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump);
503 break;
505 case ACPI_DESC_TYPE_OPERAND:
507 obj_type = ACPI_GET_OBJECT_TYPE(obj_desc);
509 if (obj_type > ACPI_TYPE_LOCAL_MAX) {
510 acpi_os_printf
511 ("(Ptr to ACPI Object type %X [UNKNOWN])\n",
512 obj_type);
513 bytes_to_dump = 32;
514 } else {
515 acpi_os_printf
516 ("(Ptr to ACPI Object type %X [%s])\n",
517 obj_type, acpi_ut_get_type_name(obj_type));
518 bytes_to_dump =
519 sizeof(union acpi_operand_object);
520 }
522 ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump);
523 break;
525 default:
527 break;
528 }
530 /* If value is NOT an internal object, we are done */
532 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) !=
533 ACPI_DESC_TYPE_OPERAND) {
534 goto cleanup;
535 }
537 /*
538 * Valid object, get the pointer to next level, if any
539 */
540 switch (obj_type) {
541 case ACPI_TYPE_BUFFER:
542 case ACPI_TYPE_STRING:
543 /*
544 * NOTE: takes advantage of common fields between string/buffer
545 */
546 bytes_to_dump = obj_desc->string.length;
547 obj_desc = (void *)obj_desc->string.pointer;
548 acpi_os_printf("(Buffer/String pointer %p length %X)\n",
549 obj_desc, bytes_to_dump);
550 ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump);
551 goto cleanup;
553 case ACPI_TYPE_BUFFER_FIELD:
554 obj_desc =
555 (union acpi_operand_object *)obj_desc->buffer_field.
556 buffer_obj;
557 break;
559 case ACPI_TYPE_PACKAGE:
560 obj_desc = (void *)obj_desc->package.elements;
561 break;
563 case ACPI_TYPE_METHOD:
564 obj_desc = (void *)obj_desc->method.aml_start;
565 break;
567 case ACPI_TYPE_LOCAL_REGION_FIELD:
568 obj_desc = (void *)obj_desc->field.region_obj;
569 break;
571 case ACPI_TYPE_LOCAL_BANK_FIELD:
572 obj_desc = (void *)obj_desc->bank_field.region_obj;
573 break;
575 case ACPI_TYPE_LOCAL_INDEX_FIELD:
576 obj_desc = (void *)obj_desc->index_field.index_obj;
577 break;
579 default:
580 goto cleanup;
581 }
583 obj_type = ACPI_TYPE_INVALID; /* Terminate loop after next pass */
584 }
586 cleanup:
587 acpi_os_printf("\n");
588 return (AE_OK);
589 }
591 #ifdef ACPI_FUTURE_USAGE
592 /*******************************************************************************
593 *
594 * FUNCTION: acpi_ns_dump_objects
595 *
596 * PARAMETERS: Type - Object type to be dumped
597 * display_type - 0 or ACPI_DISPLAY_SUMMARY
598 * max_depth - Maximum depth of dump. Use ACPI_UINT32_MAX
599 * for an effectively unlimited depth.
600 * owner_id - Dump only objects owned by this ID. Use
601 * ACPI_UINT32_MAX to match all owners.
602 * start_handle - Where in namespace to start/end search
603 *
604 * RETURN: None
605 *
606 * DESCRIPTION: Dump typed objects within the loaded namespace.
607 * Uses acpi_ns_walk_namespace in conjunction with acpi_ns_dump_one_object.
608 *
609 ******************************************************************************/
611 void
612 acpi_ns_dump_objects(acpi_object_type type,
613 u8 display_type,
614 u32 max_depth,
615 acpi_owner_id owner_id, acpi_handle start_handle)
616 {
617 struct acpi_walk_info info;
619 ACPI_FUNCTION_ENTRY();
621 info.debug_level = ACPI_LV_TABLES;
622 info.owner_id = owner_id;
623 info.display_type = display_type;
625 (void)acpi_ns_walk_namespace(type, start_handle, max_depth,
626 ACPI_NS_WALK_NO_UNLOCK,
627 acpi_ns_dump_one_object, (void *)&info,
628 NULL);
629 }
630 #endif /* ACPI_FUTURE_USAGE */
632 /*******************************************************************************
633 *
634 * FUNCTION: acpi_ns_dump_entry
635 *
636 * PARAMETERS: Handle - Node to be dumped
637 * debug_level - Output level
638 *
639 * RETURN: None
640 *
641 * DESCRIPTION: Dump a single Node
642 *
643 ******************************************************************************/
645 void acpi_ns_dump_entry(acpi_handle handle, u32 debug_level)
646 {
647 struct acpi_walk_info info;
649 ACPI_FUNCTION_ENTRY();
651 info.debug_level = debug_level;
652 info.owner_id = ACPI_OWNER_ID_MAX;
653 info.display_type = ACPI_DISPLAY_SUMMARY;
655 (void)acpi_ns_dump_one_object(handle, 1, &info, NULL);
656 }
658 #ifdef ACPI_ASL_COMPILER
659 /*******************************************************************************
660 *
661 * FUNCTION: acpi_ns_dump_tables
662 *
663 * PARAMETERS: search_base - Root of subtree to be dumped, or
664 * NS_ALL to dump the entire namespace
665 * max_depth - Maximum depth of dump. Use INT_MAX
666 * for an effectively unlimited depth.
667 *
668 * RETURN: None
669 *
670 * DESCRIPTION: Dump the name space, or a portion of it.
671 *
672 ******************************************************************************/
674 void acpi_ns_dump_tables(acpi_handle search_base, u32 max_depth)
675 {
676 acpi_handle search_handle = search_base;
678 ACPI_FUNCTION_TRACE(ns_dump_tables);
680 if (!acpi_gbl_root_node) {
681 /*
682 * If the name space has not been initialized,
683 * there is nothing to dump.
684 */
685 ACPI_DEBUG_PRINT((ACPI_DB_TABLES,
686 "namespace not initialized!\n"));
687 return_VOID;
688 }
690 if (ACPI_NS_ALL == search_base) {
692 /* Entire namespace */
694 search_handle = acpi_gbl_root_node;
695 ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "\\\n"));
696 }
698 acpi_ns_dump_objects(ACPI_TYPE_ANY, ACPI_DISPLAY_OBJECTS, max_depth,
699 ACPI_OWNER_ID_MAX, search_handle);
700 return_VOID;
701 }
702 #endif /* _ACPI_ASL_COMPILER */
703 #endif /* defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) */