ia64/linux-2.6.18-xen.hg

view drivers/acpi/utilities/utalloc.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: utalloc - local memory allocation 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("utalloc")
49 /*******************************************************************************
50 *
51 * FUNCTION: acpi_ut_create_caches
52 *
53 * PARAMETERS: None
54 *
55 * RETURN: Status
56 *
57 * DESCRIPTION: Create all local caches
58 *
59 ******************************************************************************/
60 acpi_status acpi_ut_create_caches(void)
61 {
62 acpi_status status;
64 /* Object Caches, for frequently used objects */
66 status =
67 acpi_os_create_cache("Acpi-Namespace",
68 sizeof(struct acpi_namespace_node),
69 ACPI_MAX_NAMESPACE_CACHE_DEPTH,
70 &acpi_gbl_namespace_cache);
71 if (ACPI_FAILURE(status)) {
72 return (status);
73 }
75 status =
76 acpi_os_create_cache("Acpi-State", sizeof(union acpi_generic_state),
77 ACPI_MAX_STATE_CACHE_DEPTH,
78 &acpi_gbl_state_cache);
79 if (ACPI_FAILURE(status)) {
80 return (status);
81 }
83 status =
84 acpi_os_create_cache("Acpi-Parse",
85 sizeof(struct acpi_parse_obj_common),
86 ACPI_MAX_PARSE_CACHE_DEPTH,
87 &acpi_gbl_ps_node_cache);
88 if (ACPI_FAILURE(status)) {
89 return (status);
90 }
92 status =
93 acpi_os_create_cache("Acpi-ParseExt",
94 sizeof(struct acpi_parse_obj_named),
95 ACPI_MAX_EXTPARSE_CACHE_DEPTH,
96 &acpi_gbl_ps_node_ext_cache);
97 if (ACPI_FAILURE(status)) {
98 return (status);
99 }
101 status =
102 acpi_os_create_cache("Acpi-Operand",
103 sizeof(union acpi_operand_object),
104 ACPI_MAX_OBJECT_CACHE_DEPTH,
105 &acpi_gbl_operand_cache);
106 if (ACPI_FAILURE(status)) {
107 return (status);
108 }
110 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
112 /* Memory allocation lists */
114 status = acpi_ut_create_list("Acpi-Global", 0, &acpi_gbl_global_list);
115 if (ACPI_FAILURE(status)) {
116 return (status);
117 }
119 status =
120 acpi_ut_create_list("Acpi-Namespace",
121 sizeof(struct acpi_namespace_node),
122 &acpi_gbl_ns_node_list);
123 if (ACPI_FAILURE(status)) {
124 return (status);
125 }
126 #endif
128 return (AE_OK);
129 }
131 /*******************************************************************************
132 *
133 * FUNCTION: acpi_ut_delete_caches
134 *
135 * PARAMETERS: None
136 *
137 * RETURN: Status
138 *
139 * DESCRIPTION: Purge and delete all local caches
140 *
141 ******************************************************************************/
143 acpi_status acpi_ut_delete_caches(void)
144 {
146 (void)acpi_os_delete_cache(acpi_gbl_namespace_cache);
147 acpi_gbl_namespace_cache = NULL;
149 (void)acpi_os_delete_cache(acpi_gbl_state_cache);
150 acpi_gbl_state_cache = NULL;
152 (void)acpi_os_delete_cache(acpi_gbl_operand_cache);
153 acpi_gbl_operand_cache = NULL;
155 (void)acpi_os_delete_cache(acpi_gbl_ps_node_cache);
156 acpi_gbl_ps_node_cache = NULL;
158 (void)acpi_os_delete_cache(acpi_gbl_ps_node_ext_cache);
159 acpi_gbl_ps_node_ext_cache = NULL;
161 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
163 /* Debug only - display leftover memory allocation, if any */
165 acpi_ut_dump_allocations(ACPI_UINT32_MAX, NULL);
167 /* Free memory lists */
169 ACPI_FREE(acpi_gbl_global_list);
170 acpi_gbl_global_list = NULL;
172 ACPI_FREE(acpi_gbl_ns_node_list);
173 acpi_gbl_ns_node_list = NULL;
174 #endif
176 return (AE_OK);
177 }
179 /*******************************************************************************
180 *
181 * FUNCTION: acpi_ut_validate_buffer
182 *
183 * PARAMETERS: Buffer - Buffer descriptor to be validated
184 *
185 * RETURN: Status
186 *
187 * DESCRIPTION: Perform parameter validation checks on an struct acpi_buffer
188 *
189 ******************************************************************************/
191 acpi_status acpi_ut_validate_buffer(struct acpi_buffer * buffer)
192 {
194 /* Obviously, the structure pointer must be valid */
196 if (!buffer) {
197 return (AE_BAD_PARAMETER);
198 }
200 /* Special semantics for the length */
202 if ((buffer->length == ACPI_NO_BUFFER) ||
203 (buffer->length == ACPI_ALLOCATE_BUFFER) ||
204 (buffer->length == ACPI_ALLOCATE_LOCAL_BUFFER)) {
205 return (AE_OK);
206 }
208 /* Length is valid, the buffer pointer must be also */
210 if (!buffer->pointer) {
211 return (AE_BAD_PARAMETER);
212 }
214 return (AE_OK);
215 }
217 /*******************************************************************************
218 *
219 * FUNCTION: acpi_ut_initialize_buffer
220 *
221 * PARAMETERS: Buffer - Buffer to be validated
222 * required_length - Length needed
223 *
224 * RETURN: Status
225 *
226 * DESCRIPTION: Validate that the buffer is of the required length or
227 * allocate a new buffer. Returned buffer is always zeroed.
228 *
229 ******************************************************************************/
231 acpi_status
232 acpi_ut_initialize_buffer(struct acpi_buffer * buffer,
233 acpi_size required_length)
234 {
235 acpi_status status = AE_OK;
237 switch (buffer->length) {
238 case ACPI_NO_BUFFER:
240 /* Set the exception and returned the required length */
242 status = AE_BUFFER_OVERFLOW;
243 break;
245 case ACPI_ALLOCATE_BUFFER:
247 /* Allocate a new buffer */
249 buffer->pointer = acpi_os_allocate(required_length);
250 if (!buffer->pointer) {
251 return (AE_NO_MEMORY);
252 }
254 /* Clear the buffer */
256 ACPI_MEMSET(buffer->pointer, 0, required_length);
257 break;
259 case ACPI_ALLOCATE_LOCAL_BUFFER:
261 /* Allocate a new buffer with local interface to allow tracking */
263 buffer->pointer = ACPI_ALLOCATE_ZEROED(required_length);
264 if (!buffer->pointer) {
265 return (AE_NO_MEMORY);
266 }
267 break;
269 default:
271 /* Existing buffer: Validate the size of the buffer */
273 if (buffer->length < required_length) {
274 status = AE_BUFFER_OVERFLOW;
275 break;
276 }
278 /* Clear the buffer */
280 ACPI_MEMSET(buffer->pointer, 0, required_length);
281 break;
282 }
284 buffer->length = required_length;
285 return (status);
286 }
288 #ifdef NOT_USED_BY_LINUX
289 /*******************************************************************************
290 *
291 * FUNCTION: acpi_ut_allocate
292 *
293 * PARAMETERS: Size - Size of the allocation
294 * Component - Component type of caller
295 * Module - Source file name of caller
296 * Line - Line number of caller
297 *
298 * RETURN: Address of the allocated memory on success, NULL on failure.
299 *
300 * DESCRIPTION: Subsystem equivalent of malloc.
301 *
302 ******************************************************************************/
304 void *acpi_ut_allocate(acpi_size size, u32 component, char *module, u32 line)
305 {
306 void *allocation;
308 ACPI_FUNCTION_TRACE_U32(ut_allocate, size);
310 /* Check for an inadvertent size of zero bytes */
312 if (!size) {
313 ACPI_WARNING((module, line,
314 "Attempt to allocate zero bytes, allocating 1 byte"));
315 size = 1;
316 }
318 allocation = acpi_os_allocate(size);
319 if (!allocation) {
321 /* Report allocation error */
323 ACPI_WARNING((module, line,
324 "Could not allocate size %X", (u32) size));
326 return_PTR(NULL);
327 }
329 return_PTR(allocation);
330 }
332 /*******************************************************************************
333 *
334 * FUNCTION: acpi_ut_allocate_zeroed
335 *
336 * PARAMETERS: Size - Size of the allocation
337 * Component - Component type of caller
338 * Module - Source file name of caller
339 * Line - Line number of caller
340 *
341 * RETURN: Address of the allocated memory on success, NULL on failure.
342 *
343 * DESCRIPTION: Subsystem equivalent of calloc. Allocate and zero memory.
344 *
345 ******************************************************************************/
347 void *acpi_ut_allocate_zeroed(acpi_size size,
348 u32 component, char *module, u32 line)
349 {
350 void *allocation;
352 ACPI_FUNCTION_ENTRY();
354 allocation = acpi_ut_allocate(size, component, module, line);
355 if (allocation) {
357 /* Clear the memory block */
359 ACPI_MEMSET(allocation, 0, size);
360 }
362 return (allocation);
363 }
364 #endif