ia64/linux-2.6.18-xen.hg

view drivers/acpi/namespace/nsxfobj.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: nsxfobj - Public interfaces to the ACPI subsystem
4 * ACPI Object oriented interfaces
5 *
6 ******************************************************************************/
8 /*
9 * Copyright (C) 2000 - 2006, R. Byron Moore
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
45 #include <acpi/acpi.h>
46 #include <acpi/acnamesp.h>
48 #define _COMPONENT ACPI_NAMESPACE
49 ACPI_MODULE_NAME("nsxfobj")
51 /*******************************************************************************
52 *
53 * FUNCTION: acpi_get_type
54 *
55 * PARAMETERS: Handle - Handle of object whose type is desired
56 * ret_type - Where the type will be placed
57 *
58 * RETURN: Status
59 *
60 * DESCRIPTION: This routine returns the type associatd with a particular handle
61 *
62 ******************************************************************************/
63 acpi_status acpi_get_type(acpi_handle handle, acpi_object_type * ret_type)
64 {
65 struct acpi_namespace_node *node;
66 acpi_status status;
68 /* Parameter Validation */
70 if (!ret_type) {
71 return (AE_BAD_PARAMETER);
72 }
74 /*
75 * Special case for the predefined Root Node
76 * (return type ANY)
77 */
78 if (handle == ACPI_ROOT_OBJECT) {
79 *ret_type = ACPI_TYPE_ANY;
80 return (AE_OK);
81 }
83 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
84 if (ACPI_FAILURE(status)) {
85 return (status);
86 }
88 /* Convert and validate the handle */
90 node = acpi_ns_map_handle_to_node(handle);
91 if (!node) {
92 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
93 return (AE_BAD_PARAMETER);
94 }
96 *ret_type = node->type;
98 status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
99 return (status);
100 }
102 ACPI_EXPORT_SYMBOL(acpi_get_type)
104 /*******************************************************************************
105 *
106 * FUNCTION: acpi_get_parent
107 *
108 * PARAMETERS: Handle - Handle of object whose parent is desired
109 * ret_handle - Where the parent handle will be placed
110 *
111 * RETURN: Status
112 *
113 * DESCRIPTION: Returns a handle to the parent of the object represented by
114 * Handle.
115 *
116 ******************************************************************************/
117 acpi_status acpi_get_parent(acpi_handle handle, acpi_handle * ret_handle)
118 {
119 struct acpi_namespace_node *node;
120 acpi_status status;
122 if (!ret_handle) {
123 return (AE_BAD_PARAMETER);
124 }
126 /* Special case for the predefined Root Node (no parent) */
128 if (handle == ACPI_ROOT_OBJECT) {
129 return (AE_NULL_ENTRY);
130 }
132 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
133 if (ACPI_FAILURE(status)) {
134 return (status);
135 }
137 /* Convert and validate the handle */
139 node = acpi_ns_map_handle_to_node(handle);
140 if (!node) {
141 status = AE_BAD_PARAMETER;
142 goto unlock_and_exit;
143 }
145 /* Get the parent entry */
147 *ret_handle =
148 acpi_ns_convert_entry_to_handle(acpi_ns_get_parent_node(node));
150 /* Return exception if parent is null */
152 if (!acpi_ns_get_parent_node(node)) {
153 status = AE_NULL_ENTRY;
154 }
156 unlock_and_exit:
158 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
159 return (status);
160 }
162 ACPI_EXPORT_SYMBOL(acpi_get_parent)
164 /*******************************************************************************
165 *
166 * FUNCTION: acpi_get_next_object
167 *
168 * PARAMETERS: Type - Type of object to be searched for
169 * Parent - Parent object whose children we are getting
170 * last_child - Previous child that was found.
171 * The NEXT child will be returned
172 * ret_handle - Where handle to the next object is placed
173 *
174 * RETURN: Status
175 *
176 * DESCRIPTION: Return the next peer object within the namespace. If Handle is
177 * valid, Scope is ignored. Otherwise, the first object within
178 * Scope is returned.
179 *
180 ******************************************************************************/
181 acpi_status
182 acpi_get_next_object(acpi_object_type type,
183 acpi_handle parent,
184 acpi_handle child, acpi_handle * ret_handle)
185 {
186 acpi_status status;
187 struct acpi_namespace_node *node;
188 struct acpi_namespace_node *parent_node = NULL;
189 struct acpi_namespace_node *child_node = NULL;
191 /* Parameter validation */
193 if (type > ACPI_TYPE_EXTERNAL_MAX) {
194 return (AE_BAD_PARAMETER);
195 }
197 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
198 if (ACPI_FAILURE(status)) {
199 return (status);
200 }
202 /* If null handle, use the parent */
204 if (!child) {
206 /* Start search at the beginning of the specified scope */
208 parent_node = acpi_ns_map_handle_to_node(parent);
209 if (!parent_node) {
210 status = AE_BAD_PARAMETER;
211 goto unlock_and_exit;
212 }
213 } else {
214 /* Non-null handle, ignore the parent */
215 /* Convert and validate the handle */
217 child_node = acpi_ns_map_handle_to_node(child);
218 if (!child_node) {
219 status = AE_BAD_PARAMETER;
220 goto unlock_and_exit;
221 }
222 }
224 /* Internal function does the real work */
226 node = acpi_ns_get_next_node(type, parent_node, child_node);
227 if (!node) {
228 status = AE_NOT_FOUND;
229 goto unlock_and_exit;
230 }
232 if (ret_handle) {
233 *ret_handle = acpi_ns_convert_entry_to_handle(node);
234 }
236 unlock_and_exit:
238 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
239 return (status);
240 }
242 ACPI_EXPORT_SYMBOL(acpi_get_next_object)