ia64/linux-2.6.18-xen.hg

view drivers/acpi/utilities/utxface.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: utxface - External interfaces for "global" ACPI functions
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/acevents.h>
46 #include <acpi/acnamesp.h>
47 #include <acpi/acdebug.h>
49 #define _COMPONENT ACPI_UTILITIES
50 ACPI_MODULE_NAME("utxface")
52 /*******************************************************************************
53 *
54 * FUNCTION: acpi_initialize_subsystem
55 *
56 * PARAMETERS: None
57 *
58 * RETURN: Status
59 *
60 * DESCRIPTION: Initializes all global variables. This is the first function
61 * called, so any early initialization belongs here.
62 *
63 ******************************************************************************/
64 acpi_status acpi_initialize_subsystem(void)
65 {
66 acpi_status status;
68 ACPI_FUNCTION_TRACE(acpi_initialize_subsystem);
70 ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr_trace());
72 /* Initialize the OS-Dependent layer */
74 status = acpi_os_initialize();
75 if (ACPI_FAILURE(status)) {
76 ACPI_EXCEPTION((AE_INFO, status, "During OSL initialization"));
77 return_ACPI_STATUS(status);
78 }
80 /* Initialize all globals used by the subsystem */
82 acpi_ut_init_globals();
84 /* Create the default mutex objects */
86 status = acpi_ut_mutex_initialize();
87 if (ACPI_FAILURE(status)) {
88 ACPI_EXCEPTION((AE_INFO, status,
89 "During Global Mutex creation"));
90 return_ACPI_STATUS(status);
91 }
93 /*
94 * Initialize the namespace manager and
95 * the root of the namespace tree
96 */
97 status = acpi_ns_root_initialize();
98 if (ACPI_FAILURE(status)) {
99 ACPI_EXCEPTION((AE_INFO, status,
100 "During Namespace initialization"));
101 return_ACPI_STATUS(status);
102 }
104 /* If configured, initialize the AML debugger */
106 ACPI_DEBUGGER_EXEC(status = acpi_db_initialize());
107 return_ACPI_STATUS(status);
108 }
110 ACPI_EXPORT_SYMBOL(acpi_initialize_subsystem)
112 /*******************************************************************************
113 *
114 * FUNCTION: acpi_enable_subsystem
115 *
116 * PARAMETERS: Flags - Init/enable Options
117 *
118 * RETURN: Status
119 *
120 * DESCRIPTION: Completes the subsystem initialization including hardware.
121 * Puts system into ACPI mode if it isn't already.
122 *
123 ******************************************************************************/
124 acpi_status acpi_enable_subsystem(u32 flags)
125 {
126 acpi_status status = AE_OK;
128 ACPI_FUNCTION_TRACE(acpi_enable_subsystem);
130 /*
131 * We must initialize the hardware before we can enable ACPI.
132 * The values from the FADT are validated here.
133 */
134 if (!(flags & ACPI_NO_HARDWARE_INIT)) {
135 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
136 "[Init] Initializing ACPI hardware\n"));
138 status = acpi_hw_initialize();
139 if (ACPI_FAILURE(status)) {
140 return_ACPI_STATUS(status);
141 }
142 }
144 /* Enable ACPI mode */
146 if (!(flags & ACPI_NO_ACPI_ENABLE)) {
147 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
148 "[Init] Going into ACPI mode\n"));
150 acpi_gbl_original_mode = acpi_hw_get_mode();
152 status = acpi_enable();
153 if (ACPI_FAILURE(status)) {
154 ACPI_WARNING((AE_INFO, "AcpiEnable failed"));
155 return_ACPI_STATUS(status);
156 }
157 }
159 /*
160 * Install the default op_region handlers. These are installed unless
161 * other handlers have already been installed via the
162 * install_address_space_handler interface.
163 */
164 if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
165 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
166 "[Init] Installing default address space handlers\n"));
168 status = acpi_ev_install_region_handlers();
169 if (ACPI_FAILURE(status)) {
170 return_ACPI_STATUS(status);
171 }
172 }
174 /*
175 * Initialize ACPI Event handling (Fixed and General Purpose)
176 *
177 * Note1: We must have the hardware and events initialized before we can
178 * execute any control methods safely. Any control method can require
179 * ACPI hardware support, so the hardware must be fully initialized before
180 * any method execution!
181 *
182 * Note2: Fixed events are initialized and enabled here. GPEs are
183 * initialized, but cannot be enabled until after the hardware is
184 * completely initialized (SCI and global_lock activated)
185 */
186 if (!(flags & ACPI_NO_EVENT_INIT)) {
187 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
188 "[Init] Initializing ACPI events\n"));
190 status = acpi_ev_initialize_events();
191 if (ACPI_FAILURE(status)) {
192 return_ACPI_STATUS(status);
193 }
194 }
196 /*
197 * Install the SCI handler and Global Lock handler. This completes the
198 * hardware initialization.
199 */
200 if (!(flags & ACPI_NO_HANDLER_INIT)) {
201 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
202 "[Init] Installing SCI/GL handlers\n"));
204 status = acpi_ev_install_xrupt_handlers();
205 if (ACPI_FAILURE(status)) {
206 return_ACPI_STATUS(status);
207 }
208 }
210 /*
211 * Complete the GPE initialization for the GPE blocks defined in the FADT
212 * (GPE block 0 and 1).
213 *
214 * Note1: This is where the _PRW methods are executed for the GPEs. These
215 * methods can only be executed after the SCI and Global Lock handlers are
216 * installed and initialized.
217 *
218 * Note2: Currently, there seems to be no need to run the _REG methods
219 * before execution of the _PRW methods and enabling of the GPEs.
220 */
221 if (!(flags & ACPI_NO_EVENT_INIT)) {
222 status = acpi_ev_install_fadt_gpes();
223 if (ACPI_FAILURE(status)) {
224 return (status);
225 }
226 }
228 return_ACPI_STATUS(status);
229 }
231 ACPI_EXPORT_SYMBOL(acpi_enable_subsystem)
233 /*******************************************************************************
234 *
235 * FUNCTION: acpi_initialize_objects
236 *
237 * PARAMETERS: Flags - Init/enable Options
238 *
239 * RETURN: Status
240 *
241 * DESCRIPTION: Completes namespace initialization by initializing device
242 * objects and executing AML code for Regions, buffers, etc.
243 *
244 ******************************************************************************/
245 acpi_status acpi_initialize_objects(u32 flags)
246 {
247 acpi_status status = AE_OK;
249 ACPI_FUNCTION_TRACE(acpi_initialize_objects);
251 /*
252 * Run all _REG methods
253 *
254 * Note: Any objects accessed by the _REG methods will be automatically
255 * initialized, even if they contain executable AML (see the call to
256 * acpi_ns_initialize_objects below).
257 */
258 if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
259 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
260 "[Init] Executing _REG OpRegion methods\n"));
262 status = acpi_ev_initialize_op_regions();
263 if (ACPI_FAILURE(status)) {
264 return_ACPI_STATUS(status);
265 }
266 }
268 /*
269 * Initialize the objects that remain uninitialized. This runs the
270 * executable AML that may be part of the declaration of these objects:
271 * operation_regions, buffer_fields, Buffers, and Packages.
272 */
273 if (!(flags & ACPI_NO_OBJECT_INIT)) {
274 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
275 "[Init] Completing Initialization of ACPI Objects\n"));
277 status = acpi_ns_initialize_objects();
278 if (ACPI_FAILURE(status)) {
279 return_ACPI_STATUS(status);
280 }
281 }
283 /*
284 * Initialize all device objects in the namespace. This runs the device
285 * _STA and _INI methods.
286 */
287 if (!(flags & ACPI_NO_DEVICE_INIT)) {
288 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
289 "[Init] Initializing ACPI Devices\n"));
291 status = acpi_ns_initialize_devices();
292 if (ACPI_FAILURE(status)) {
293 return_ACPI_STATUS(status);
294 }
295 }
297 /*
298 * Empty the caches (delete the cached objects) on the assumption that
299 * the table load filled them up more than they will be at runtime --
300 * thus wasting non-paged memory.
301 */
302 status = acpi_purge_cached_objects();
304 acpi_gbl_startup_flags |= ACPI_INITIALIZED_OK;
305 return_ACPI_STATUS(status);
306 }
308 ACPI_EXPORT_SYMBOL(acpi_initialize_objects)
310 /*******************************************************************************
311 *
312 * FUNCTION: acpi_terminate
313 *
314 * PARAMETERS: None
315 *
316 * RETURN: Status
317 *
318 * DESCRIPTION: Shutdown the ACPI subsystem. Release all resources.
319 *
320 ******************************************************************************/
321 acpi_status acpi_terminate(void)
322 {
323 acpi_status status;
325 ACPI_FUNCTION_TRACE(acpi_terminate);
327 /* Terminate the AML Debugger if present */
329 ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE);
331 /* Shutdown and free all resources */
333 acpi_ut_subsystem_shutdown();
335 /* Free the mutex objects */
337 acpi_ut_mutex_terminate();
339 #ifdef ACPI_DEBUGGER
341 /* Shut down the debugger */
343 acpi_db_terminate();
344 #endif
346 /* Now we can shutdown the OS-dependent layer */
348 status = acpi_os_terminate();
349 return_ACPI_STATUS(status);
350 }
352 ACPI_EXPORT_SYMBOL(acpi_terminate)
354 #ifdef ACPI_FUTURE_USAGE
355 /*******************************************************************************
356 *
357 * FUNCTION: acpi_subsystem_status
358 *
359 * PARAMETERS: None
360 *
361 * RETURN: Status of the ACPI subsystem
362 *
363 * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
364 * before making any other calls, to ensure the subsystem
365 * initialized successfully.
366 *
367 ******************************************************************************/
368 acpi_status acpi_subsystem_status(void)
369 {
371 if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) {
372 return (AE_OK);
373 } else {
374 return (AE_ERROR);
375 }
376 }
378 ACPI_EXPORT_SYMBOL(acpi_subsystem_status)
380 /*******************************************************************************
381 *
382 * FUNCTION: acpi_get_system_info
383 *
384 * PARAMETERS: out_buffer - A buffer to receive the resources for the
385 * device
386 *
387 * RETURN: Status - the status of the call
388 *
389 * DESCRIPTION: This function is called to get information about the current
390 * state of the ACPI subsystem. It will return system information
391 * in the out_buffer.
392 *
393 * If the function fails an appropriate status will be returned
394 * and the value of out_buffer is undefined.
395 *
396 ******************************************************************************/
397 acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
398 {
399 struct acpi_system_info *info_ptr;
400 acpi_status status;
401 u32 i;
403 ACPI_FUNCTION_TRACE(acpi_get_system_info);
405 /* Parameter validation */
407 status = acpi_ut_validate_buffer(out_buffer);
408 if (ACPI_FAILURE(status)) {
409 return_ACPI_STATUS(status);
410 }
412 /* Validate/Allocate/Clear caller buffer */
414 status =
415 acpi_ut_initialize_buffer(out_buffer,
416 sizeof(struct acpi_system_info));
417 if (ACPI_FAILURE(status)) {
418 return_ACPI_STATUS(status);
419 }
421 /*
422 * Populate the return buffer
423 */
424 info_ptr = (struct acpi_system_info *)out_buffer->pointer;
426 info_ptr->acpi_ca_version = ACPI_CA_VERSION;
428 /* System flags (ACPI capabilities) */
430 info_ptr->flags = ACPI_SYS_MODE_ACPI;
432 /* Timer resolution - 24 or 32 bits */
434 if (!acpi_gbl_FADT) {
435 info_ptr->timer_resolution = 0;
436 } else if (acpi_gbl_FADT->tmr_val_ext == 0) {
437 info_ptr->timer_resolution = 24;
438 } else {
439 info_ptr->timer_resolution = 32;
440 }
442 /* Clear the reserved fields */
444 info_ptr->reserved1 = 0;
445 info_ptr->reserved2 = 0;
447 /* Current debug levels */
449 info_ptr->debug_layer = acpi_dbg_layer;
450 info_ptr->debug_level = acpi_dbg_level;
452 /* Current status of the ACPI tables, per table type */
454 info_ptr->num_table_types = ACPI_TABLE_ID_MAX + 1;
455 for (i = 0; i < (ACPI_TABLE_ID_MAX + 1); i++) {
456 info_ptr->table_info[i].count = acpi_gbl_table_lists[i].count;
457 }
459 return_ACPI_STATUS(AE_OK);
460 }
462 ACPI_EXPORT_SYMBOL(acpi_get_system_info)
464 /*****************************************************************************
465 *
466 * FUNCTION: acpi_install_initialization_handler
467 *
468 * PARAMETERS: Handler - Callback procedure
469 * Function - Not (currently) used, see below
470 *
471 * RETURN: Status
472 *
473 * DESCRIPTION: Install an initialization handler
474 *
475 * TBD: When a second function is added, must save the Function also.
476 *
477 ****************************************************************************/
478 acpi_status
479 acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
480 {
482 if (!handler) {
483 return (AE_BAD_PARAMETER);
484 }
486 if (acpi_gbl_init_handler) {
487 return (AE_ALREADY_EXISTS);
488 }
490 acpi_gbl_init_handler = handler;
491 return AE_OK;
492 }
494 ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler)
495 #endif /* ACPI_FUTURE_USAGE */
497 /*****************************************************************************
498 *
499 * FUNCTION: acpi_purge_cached_objects
500 *
501 * PARAMETERS: None
502 *
503 * RETURN: Status
504 *
505 * DESCRIPTION: Empty all caches (delete the cached objects)
506 *
507 ****************************************************************************/
508 acpi_status acpi_purge_cached_objects(void)
509 {
510 ACPI_FUNCTION_TRACE(acpi_purge_cached_objects);
512 (void)acpi_os_purge_cache(acpi_gbl_state_cache);
513 (void)acpi_os_purge_cache(acpi_gbl_operand_cache);
514 (void)acpi_os_purge_cache(acpi_gbl_ps_node_cache);
515 (void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);
516 return_ACPI_STATUS(AE_OK);
517 }
519 ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects)