ia64/linux-2.6.18-xen.hg

view drivers/acpi/utilities/utdebug.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: utdebug - Debug print 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>
46 #define _COMPONENT ACPI_UTILITIES
47 ACPI_MODULE_NAME("utdebug")
49 #ifdef ACPI_DEBUG_OUTPUT
50 static acpi_thread_id acpi_gbl_prev_thread_id;
51 static char *acpi_gbl_fn_entry_str = "----Entry";
52 static char *acpi_gbl_fn_exit_str = "----Exit-";
54 /* Local prototypes */
56 static const char *acpi_ut_trim_function_name(const char *function_name);
58 /*******************************************************************************
59 *
60 * FUNCTION: acpi_ut_init_stack_ptr_trace
61 *
62 * PARAMETERS: None
63 *
64 * RETURN: None
65 *
66 * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
67 *
68 ******************************************************************************/
70 void acpi_ut_init_stack_ptr_trace(void)
71 {
72 u32 current_sp;
74 acpi_gbl_entry_stack_pointer = ACPI_PTR_DIFF(&current_sp, NULL);
75 }
77 /*******************************************************************************
78 *
79 * FUNCTION: acpi_ut_track_stack_ptr
80 *
81 * PARAMETERS: None
82 *
83 * RETURN: None
84 *
85 * DESCRIPTION: Save the current CPU stack pointer
86 *
87 ******************************************************************************/
89 void acpi_ut_track_stack_ptr(void)
90 {
91 acpi_size current_sp;
93 current_sp = ACPI_PTR_DIFF(&current_sp, NULL);
95 if (current_sp < acpi_gbl_lowest_stack_pointer) {
96 acpi_gbl_lowest_stack_pointer = current_sp;
97 }
99 if (acpi_gbl_nesting_level > acpi_gbl_deepest_nesting) {
100 acpi_gbl_deepest_nesting = acpi_gbl_nesting_level;
101 }
102 }
104 /*******************************************************************************
105 *
106 * FUNCTION: acpi_ut_trim_function_name
107 *
108 * PARAMETERS: function_name - Ascii string containing a procedure name
109 *
110 * RETURN: Updated pointer to the function name
111 *
112 * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
113 * This allows compiler macros such as __FUNCTION__ to be used
114 * with no change to the debug output.
115 *
116 ******************************************************************************/
118 static const char *acpi_ut_trim_function_name(const char *function_name)
119 {
121 /* All Function names are longer than 4 chars, check is safe */
123 if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_MIXED) {
125 /* This is the case where the original source has not been modified */
127 return (function_name + 4);
128 }
130 if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_LOWER) {
132 /* This is the case where the source has been 'linuxized' */
134 return (function_name + 5);
135 }
137 return (function_name);
138 }
140 /*******************************************************************************
141 *
142 * FUNCTION: acpi_ut_debug_print
143 *
144 * PARAMETERS: requested_debug_level - Requested debug print level
145 * line_number - Caller's line number (for error output)
146 * function_name - Caller's procedure name
147 * module_name - Caller's module name
148 * component_id - Caller's component ID
149 * Format - Printf format field
150 * ... - Optional printf arguments
151 *
152 * RETURN: None
153 *
154 * DESCRIPTION: Print error message with prefix consisting of the module name,
155 * line number, and component ID.
156 *
157 ******************************************************************************/
159 void ACPI_INTERNAL_VAR_XFACE
160 acpi_ut_debug_print(u32 requested_debug_level,
161 u32 line_number,
162 const char *function_name,
163 char *module_name, u32 component_id, char *format, ...)
164 {
165 acpi_thread_id thread_id;
166 va_list args;
168 /*
169 * Stay silent if the debug level or component ID is disabled
170 */
171 if (!(requested_debug_level & acpi_dbg_level) ||
172 !(component_id & acpi_dbg_layer)) {
173 return;
174 }
176 /*
177 * Thread tracking and context switch notification
178 */
179 thread_id = acpi_os_get_thread_id();
180 if (thread_id != acpi_gbl_prev_thread_id) {
181 if (ACPI_LV_THREADS & acpi_dbg_level) {
182 acpi_os_printf
183 ("\n**** Context Switch from TID %X to TID %X ****\n\n",
184 (u32) acpi_gbl_prev_thread_id, (u32) thread_id);
185 }
187 acpi_gbl_prev_thread_id = thread_id;
188 }
190 /*
191 * Display the module name, current line number, thread ID (if requested),
192 * current procedure nesting level, and the current procedure name
193 */
194 acpi_os_printf("%8s-%04ld ", module_name, line_number);
196 if (ACPI_LV_THREADS & acpi_dbg_level) {
197 acpi_os_printf("[%04lX] ", thread_id);
198 }
200 acpi_os_printf("[%02ld] %-22.22s: ",
201 acpi_gbl_nesting_level,
202 acpi_ut_trim_function_name(function_name));
204 va_start(args, format);
205 acpi_os_vprintf(format, args);
206 }
208 ACPI_EXPORT_SYMBOL(acpi_ut_debug_print)
210 /*******************************************************************************
211 *
212 * FUNCTION: acpi_ut_debug_print_raw
213 *
214 * PARAMETERS: requested_debug_level - Requested debug print level
215 * line_number - Caller's line number
216 * function_name - Caller's procedure name
217 * module_name - Caller's module name
218 * component_id - Caller's component ID
219 * Format - Printf format field
220 * ... - Optional printf arguments
221 *
222 * RETURN: None
223 *
224 * DESCRIPTION: Print message with no headers. Has same interface as
225 * debug_print so that the same macros can be used.
226 *
227 ******************************************************************************/
228 void ACPI_INTERNAL_VAR_XFACE
229 acpi_ut_debug_print_raw(u32 requested_debug_level,
230 u32 line_number,
231 const char *function_name,
232 char *module_name, u32 component_id, char *format, ...)
233 {
234 va_list args;
236 if (!(requested_debug_level & acpi_dbg_level) ||
237 !(component_id & acpi_dbg_layer)) {
238 return;
239 }
241 va_start(args, format);
242 acpi_os_vprintf(format, args);
243 }
245 ACPI_EXPORT_SYMBOL(acpi_ut_debug_print_raw)
247 /*******************************************************************************
248 *
249 * FUNCTION: acpi_ut_trace
250 *
251 * PARAMETERS: line_number - Caller's line number
252 * function_name - Caller's procedure name
253 * module_name - Caller's module name
254 * component_id - Caller's component ID
255 *
256 * RETURN: None
257 *
258 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
259 * set in debug_level
260 *
261 ******************************************************************************/
262 void
263 acpi_ut_trace(u32 line_number,
264 const char *function_name, char *module_name, u32 component_id)
265 {
267 acpi_gbl_nesting_level++;
268 acpi_ut_track_stack_ptr();
270 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
271 line_number, function_name, module_name,
272 component_id, "%s\n", acpi_gbl_fn_entry_str);
273 }
275 ACPI_EXPORT_SYMBOL(acpi_ut_trace)
277 /*******************************************************************************
278 *
279 * FUNCTION: acpi_ut_trace_ptr
280 *
281 * PARAMETERS: line_number - Caller's line number
282 * function_name - Caller's procedure name
283 * module_name - Caller's module name
284 * component_id - Caller's component ID
285 * Pointer - Pointer to display
286 *
287 * RETURN: None
288 *
289 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
290 * set in debug_level
291 *
292 ******************************************************************************/
293 void
294 acpi_ut_trace_ptr(u32 line_number,
295 const char *function_name,
296 char *module_name, u32 component_id, void *pointer)
297 {
298 acpi_gbl_nesting_level++;
299 acpi_ut_track_stack_ptr();
301 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
302 line_number, function_name, module_name,
303 component_id, "%s %p\n", acpi_gbl_fn_entry_str,
304 pointer);
305 }
307 /*******************************************************************************
308 *
309 * FUNCTION: acpi_ut_trace_str
310 *
311 * PARAMETERS: line_number - Caller's line number
312 * function_name - Caller's procedure name
313 * module_name - Caller's module name
314 * component_id - Caller's component ID
315 * String - Additional string to display
316 *
317 * RETURN: None
318 *
319 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
320 * set in debug_level
321 *
322 ******************************************************************************/
324 void
325 acpi_ut_trace_str(u32 line_number,
326 const char *function_name,
327 char *module_name, u32 component_id, char *string)
328 {
330 acpi_gbl_nesting_level++;
331 acpi_ut_track_stack_ptr();
333 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
334 line_number, function_name, module_name,
335 component_id, "%s %s\n", acpi_gbl_fn_entry_str,
336 string);
337 }
339 /*******************************************************************************
340 *
341 * FUNCTION: acpi_ut_trace_u32
342 *
343 * PARAMETERS: line_number - Caller's line number
344 * function_name - Caller's procedure name
345 * module_name - Caller's module name
346 * component_id - Caller's component ID
347 * Integer - Integer to display
348 *
349 * RETURN: None
350 *
351 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
352 * set in debug_level
353 *
354 ******************************************************************************/
356 void
357 acpi_ut_trace_u32(u32 line_number,
358 const char *function_name,
359 char *module_name, u32 component_id, u32 integer)
360 {
362 acpi_gbl_nesting_level++;
363 acpi_ut_track_stack_ptr();
365 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
366 line_number, function_name, module_name,
367 component_id, "%s %08X\n", acpi_gbl_fn_entry_str,
368 integer);
369 }
371 /*******************************************************************************
372 *
373 * FUNCTION: acpi_ut_exit
374 *
375 * PARAMETERS: line_number - Caller's line number
376 * function_name - Caller's procedure name
377 * module_name - Caller's module name
378 * component_id - Caller's component ID
379 *
380 * RETURN: None
381 *
382 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
383 * set in debug_level
384 *
385 ******************************************************************************/
387 void
388 acpi_ut_exit(u32 line_number,
389 const char *function_name, char *module_name, u32 component_id)
390 {
392 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
393 line_number, function_name, module_name,
394 component_id, "%s\n", acpi_gbl_fn_exit_str);
396 acpi_gbl_nesting_level--;
397 }
399 ACPI_EXPORT_SYMBOL(acpi_ut_exit)
401 /*******************************************************************************
402 *
403 * FUNCTION: acpi_ut_status_exit
404 *
405 * PARAMETERS: line_number - Caller's line number
406 * function_name - Caller's procedure name
407 * module_name - Caller's module name
408 * component_id - Caller's component ID
409 * Status - Exit status code
410 *
411 * RETURN: None
412 *
413 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
414 * set in debug_level. Prints exit status also.
415 *
416 ******************************************************************************/
417 void
418 acpi_ut_status_exit(u32 line_number,
419 const char *function_name,
420 char *module_name, u32 component_id, acpi_status status)
421 {
423 if (ACPI_SUCCESS(status)) {
424 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
425 line_number, function_name, module_name,
426 component_id, "%s %s\n",
427 acpi_gbl_fn_exit_str,
428 acpi_format_exception(status));
429 } else {
430 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
431 line_number, function_name, module_name,
432 component_id, "%s ****Exception****: %s\n",
433 acpi_gbl_fn_exit_str,
434 acpi_format_exception(status));
435 }
437 acpi_gbl_nesting_level--;
438 }
440 ACPI_EXPORT_SYMBOL(acpi_ut_status_exit)
442 /*******************************************************************************
443 *
444 * FUNCTION: acpi_ut_value_exit
445 *
446 * PARAMETERS: line_number - Caller's line number
447 * function_name - Caller's procedure name
448 * module_name - Caller's module name
449 * component_id - Caller's component ID
450 * Value - Value to be printed with exit msg
451 *
452 * RETURN: None
453 *
454 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
455 * set in debug_level. Prints exit value also.
456 *
457 ******************************************************************************/
458 void
459 acpi_ut_value_exit(u32 line_number,
460 const char *function_name,
461 char *module_name, u32 component_id, acpi_integer value)
462 {
464 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
465 line_number, function_name, module_name,
466 component_id, "%s %8.8X%8.8X\n",
467 acpi_gbl_fn_exit_str, ACPI_FORMAT_UINT64(value));
469 acpi_gbl_nesting_level--;
470 }
472 ACPI_EXPORT_SYMBOL(acpi_ut_value_exit)
474 /*******************************************************************************
475 *
476 * FUNCTION: acpi_ut_ptr_exit
477 *
478 * PARAMETERS: line_number - Caller's line number
479 * function_name - Caller's procedure name
480 * module_name - Caller's module name
481 * component_id - Caller's component ID
482 * Ptr - Pointer to display
483 *
484 * RETURN: None
485 *
486 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
487 * set in debug_level. Prints exit value also.
488 *
489 ******************************************************************************/
490 void
491 acpi_ut_ptr_exit(u32 line_number,
492 const char *function_name,
493 char *module_name, u32 component_id, u8 * ptr)
494 {
496 acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
497 line_number, function_name, module_name,
498 component_id, "%s %p\n", acpi_gbl_fn_exit_str, ptr);
500 acpi_gbl_nesting_level--;
501 }
503 #endif
505 /*******************************************************************************
506 *
507 * FUNCTION: acpi_ut_dump_buffer
508 *
509 * PARAMETERS: Buffer - Buffer to dump
510 * Count - Amount to dump, in bytes
511 * Display - BYTE, WORD, DWORD, or QWORD display
512 * component_iD - Caller's component ID
513 *
514 * RETURN: None
515 *
516 * DESCRIPTION: Generic dump buffer in both hex and ascii.
517 *
518 ******************************************************************************/
520 void acpi_ut_dump_buffer2(u8 * buffer, u32 count, u32 display)
521 {
522 acpi_native_uint i = 0;
523 acpi_native_uint j;
524 u32 temp32;
525 u8 buf_char;
527 if ((count < 4) || (count & 0x01)) {
528 display = DB_BYTE_DISPLAY;
529 }
531 /* Nasty little dump buffer routine! */
533 while (i < count) {
535 /* Print current offset */
537 acpi_os_printf("%6.4X: ", (u32) i);
539 /* Print 16 hex chars */
541 for (j = 0; j < 16;) {
542 if (i + j >= count) {
544 /* Dump fill spaces */
546 acpi_os_printf("%*s", ((display * 2) + 1), " ");
547 j += (acpi_native_uint) display;
548 continue;
549 }
551 switch (display) {
552 case DB_BYTE_DISPLAY:
553 default: /* Default is BYTE display */
555 acpi_os_printf("%02X ", buffer[i + j]);
556 break;
558 case DB_WORD_DISPLAY:
560 ACPI_MOVE_16_TO_32(&temp32, &buffer[i + j]);
561 acpi_os_printf("%04X ", temp32);
562 break;
564 case DB_DWORD_DISPLAY:
566 ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j]);
567 acpi_os_printf("%08X ", temp32);
568 break;
570 case DB_QWORD_DISPLAY:
572 ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j]);
573 acpi_os_printf("%08X", temp32);
575 ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j + 4]);
576 acpi_os_printf("%08X ", temp32);
577 break;
578 }
580 j += (acpi_native_uint) display;
581 }
583 /*
584 * Print the ASCII equivalent characters but watch out for the bad
585 * unprintable ones (printable chars are 0x20 through 0x7E)
586 */
587 acpi_os_printf(" ");
588 for (j = 0; j < 16; j++) {
589 if (i + j >= count) {
590 acpi_os_printf("\n");
591 return;
592 }
594 buf_char = buffer[i + j];
595 if (ACPI_IS_PRINT(buf_char)) {
596 acpi_os_printf("%c", buf_char);
597 } else {
598 acpi_os_printf(".");
599 }
600 }
602 /* Done with that line. */
604 acpi_os_printf("\n");
605 i += 16;
606 }
608 return;
609 }
611 /*******************************************************************************
612 *
613 * FUNCTION: acpi_ut_dump_buffer
614 *
615 * PARAMETERS: Buffer - Buffer to dump
616 * Count - Amount to dump, in bytes
617 * Display - BYTE, WORD, DWORD, or QWORD display
618 * component_iD - Caller's component ID
619 *
620 * RETURN: None
621 *
622 * DESCRIPTION: Generic dump buffer in both hex and ascii.
623 *
624 ******************************************************************************/
626 void acpi_ut_dump_buffer(u8 * buffer, u32 count, u32 display, u32 component_id)
627 {
629 /* Only dump the buffer if tracing is enabled */
631 if (!((ACPI_LV_TABLES & acpi_dbg_level) &&
632 (component_id & acpi_dbg_layer))) {
633 return;
634 }
636 acpi_ut_dump_buffer2(buffer, count, display);
637 }