ia64/linux-2.6.18-xen.hg

view drivers/acpi/namespace/nsaccess.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: nsaccess - Top-level functions for accessing ACPI namespace
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/amlcode.h>
46 #include <acpi/acnamesp.h>
47 #include <acpi/acdispat.h>
49 #define _COMPONENT ACPI_NAMESPACE
50 ACPI_MODULE_NAME("nsaccess")
52 /*******************************************************************************
53 *
54 * FUNCTION: acpi_ns_root_initialize
55 *
56 * PARAMETERS: None
57 *
58 * RETURN: Status
59 *
60 * DESCRIPTION: Allocate and initialize the default root named objects
61 *
62 * MUTEX: Locks namespace for entire execution
63 *
64 ******************************************************************************/
65 acpi_status acpi_ns_root_initialize(void)
66 {
67 acpi_status status;
68 const struct acpi_predefined_names *init_val = NULL;
69 struct acpi_namespace_node *new_node;
70 union acpi_operand_object *obj_desc;
71 acpi_string val = NULL;
73 ACPI_FUNCTION_TRACE(ns_root_initialize);
75 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
76 if (ACPI_FAILURE(status)) {
77 return_ACPI_STATUS(status);
78 }
80 /*
81 * The global root ptr is initially NULL, so a non-NULL value indicates
82 * that acpi_ns_root_initialize() has already been called; just return.
83 */
84 if (acpi_gbl_root_node) {
85 status = AE_OK;
86 goto unlock_and_exit;
87 }
89 /*
90 * Tell the rest of the subsystem that the root is initialized
91 * (This is OK because the namespace is locked)
92 */
93 acpi_gbl_root_node = &acpi_gbl_root_node_struct;
95 /* Enter the pre-defined names in the name table */
97 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
98 "Entering predefined entries into namespace\n"));
100 for (init_val = acpi_gbl_pre_defined_names; init_val->name; init_val++) {
102 /* _OSI is optional for now, will be permanent later */
104 if (!ACPI_STRCMP(init_val->name, "_OSI")
105 && !acpi_gbl_create_osi_method) {
106 continue;
107 }
109 status = acpi_ns_lookup(NULL, init_val->name, init_val->type,
110 ACPI_IMODE_LOAD_PASS2,
111 ACPI_NS_NO_UPSEARCH, NULL, &new_node);
113 if (ACPI_FAILURE(status) || (!new_node)) { /* Must be on same line for code converter */
114 ACPI_EXCEPTION((AE_INFO, status,
115 "Could not create predefined name %s",
116 init_val->name));
117 }
119 /*
120 * Name entered successfully.
121 * If entry in pre_defined_names[] specifies an
122 * initial value, create the initial value.
123 */
124 if (init_val->val) {
125 status = acpi_os_predefined_override(init_val, &val);
126 if (ACPI_FAILURE(status)) {
127 ACPI_ERROR((AE_INFO,
128 "Could not override predefined %s",
129 init_val->name));
130 }
132 if (!val) {
133 val = init_val->val;
134 }
136 /*
137 * Entry requests an initial value, allocate a
138 * descriptor for it.
139 */
140 obj_desc =
141 acpi_ut_create_internal_object(init_val->type);
142 if (!obj_desc) {
143 status = AE_NO_MEMORY;
144 goto unlock_and_exit;
145 }
147 /*
148 * Convert value string from table entry to
149 * internal representation. Only types actually
150 * used for initial values are implemented here.
151 */
152 switch (init_val->type) {
153 case ACPI_TYPE_METHOD:
154 obj_desc->method.param_count =
155 (u8) ACPI_TO_INTEGER(val);
156 obj_desc->common.flags |= AOPOBJ_DATA_VALID;
158 #if defined (ACPI_ASL_COMPILER)
160 /* Save the parameter count for the i_aSL compiler */
162 new_node->value = obj_desc->method.param_count;
163 #else
164 /* Mark this as a very SPECIAL method */
166 obj_desc->method.method_flags =
167 AML_METHOD_INTERNAL_ONLY;
169 #ifndef ACPI_DUMP_APP
170 obj_desc->method.implementation =
171 acpi_ut_osi_implementation;
172 #endif
173 #endif
174 break;
176 case ACPI_TYPE_INTEGER:
178 obj_desc->integer.value = ACPI_TO_INTEGER(val);
179 break;
181 case ACPI_TYPE_STRING:
183 /*
184 * Build an object around the static string
185 */
186 obj_desc->string.length =
187 (u32) ACPI_STRLEN(val);
188 obj_desc->string.pointer = val;
189 obj_desc->common.flags |= AOPOBJ_STATIC_POINTER;
190 break;
192 case ACPI_TYPE_MUTEX:
194 obj_desc->mutex.node = new_node;
195 obj_desc->mutex.sync_level =
196 (u8) (ACPI_TO_INTEGER(val) - 1);
198 if (ACPI_STRCMP(init_val->name, "_GL_") == 0) {
200 /* Create a counting semaphore for the global lock */
202 status =
203 acpi_os_create_semaphore
204 (ACPI_NO_UNIT_LIMIT, 1,
205 &acpi_gbl_global_lock_semaphore);
206 if (ACPI_FAILURE(status)) {
207 acpi_ut_remove_reference
208 (obj_desc);
209 goto unlock_and_exit;
210 }
212 /* Mark this mutex as very special */
214 obj_desc->mutex.os_mutex =
215 ACPI_GLOBAL_LOCK;
216 } else {
217 /* Create a mutex */
219 status =
220 acpi_os_create_mutex(&obj_desc->
221 mutex.
222 os_mutex);
223 if (ACPI_FAILURE(status)) {
224 acpi_ut_remove_reference
225 (obj_desc);
226 goto unlock_and_exit;
227 }
228 }
229 break;
231 default:
233 ACPI_ERROR((AE_INFO,
234 "Unsupported initial type value %X",
235 init_val->type));
236 acpi_ut_remove_reference(obj_desc);
237 obj_desc = NULL;
238 continue;
239 }
241 /* Store pointer to value descriptor in the Node */
243 status = acpi_ns_attach_object(new_node, obj_desc,
244 ACPI_GET_OBJECT_TYPE
245 (obj_desc));
247 /* Remove local reference to the object */
249 acpi_ut_remove_reference(obj_desc);
250 }
251 }
253 unlock_and_exit:
254 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
256 /* Save a handle to "_GPE", it is always present */
258 if (ACPI_SUCCESS(status)) {
259 status = acpi_ns_get_node(NULL, "\\_GPE", ACPI_NS_NO_UPSEARCH,
260 &acpi_gbl_fadt_gpe_device);
261 }
263 return_ACPI_STATUS(status);
264 }
266 /*******************************************************************************
267 *
268 * FUNCTION: acpi_ns_lookup
269 *
270 * PARAMETERS: scope_info - Current scope info block
271 * Pathname - Search pathname, in internal format
272 * (as represented in the AML stream)
273 * Type - Type associated with name
274 * interpreter_mode - IMODE_LOAD_PASS2 => add name if not found
275 * Flags - Flags describing the search restrictions
276 * walk_state - Current state of the walk
277 * return_node - Where the Node is placed (if found
278 * or created successfully)
279 *
280 * RETURN: Status
281 *
282 * DESCRIPTION: Find or enter the passed name in the name space.
283 * Log an error if name not found in Exec mode.
284 *
285 * MUTEX: Assumes namespace is locked.
286 *
287 ******************************************************************************/
289 acpi_status
290 acpi_ns_lookup(union acpi_generic_state *scope_info,
291 char *pathname,
292 acpi_object_type type,
293 acpi_interpreter_mode interpreter_mode,
294 u32 flags,
295 struct acpi_walk_state *walk_state,
296 struct acpi_namespace_node **return_node)
297 {
298 acpi_status status;
299 char *path = pathname;
300 struct acpi_namespace_node *prefix_node;
301 struct acpi_namespace_node *current_node = NULL;
302 struct acpi_namespace_node *this_node = NULL;
303 u32 num_segments;
304 u32 num_carats;
305 acpi_name simple_name;
306 acpi_object_type type_to_check_for;
307 acpi_object_type this_search_type;
308 u32 search_parent_flag = ACPI_NS_SEARCH_PARENT;
309 u32 local_flags;
311 ACPI_FUNCTION_TRACE(ns_lookup);
313 if (!return_node) {
314 return_ACPI_STATUS(AE_BAD_PARAMETER);
315 }
317 local_flags = flags & ~(ACPI_NS_ERROR_IF_FOUND | ACPI_NS_SEARCH_PARENT);
318 *return_node = ACPI_ENTRY_NOT_FOUND;
319 acpi_gbl_ns_lookup_count++;
321 if (!acpi_gbl_root_node) {
322 return_ACPI_STATUS(AE_NO_NAMESPACE);
323 }
325 /*
326 * Get the prefix scope.
327 * A null scope means use the root scope
328 */
329 if ((!scope_info) || (!scope_info->scope.node)) {
330 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
331 "Null scope prefix, using root node (%p)\n",
332 acpi_gbl_root_node));
334 prefix_node = acpi_gbl_root_node;
335 } else {
336 prefix_node = scope_info->scope.node;
337 if (ACPI_GET_DESCRIPTOR_TYPE(prefix_node) !=
338 ACPI_DESC_TYPE_NAMED) {
339 ACPI_ERROR((AE_INFO, "%p is not a namespace node [%s]",
340 prefix_node,
341 acpi_ut_get_descriptor_name(prefix_node)));
342 return_ACPI_STATUS(AE_AML_INTERNAL);
343 }
345 if (!(flags & ACPI_NS_PREFIX_IS_SCOPE)) {
346 /*
347 * This node might not be a actual "scope" node (such as a
348 * Device/Method, etc.) It could be a Package or other object node.
349 * Backup up the tree to find the containing scope node.
350 */
351 while (!acpi_ns_opens_scope(prefix_node->type) &&
352 prefix_node->type != ACPI_TYPE_ANY) {
353 prefix_node =
354 acpi_ns_get_parent_node(prefix_node);
355 }
356 }
357 }
359 /* Save type TBD: may be no longer necessary */
361 type_to_check_for = type;
363 /*
364 * Begin examination of the actual pathname
365 */
366 if (!pathname) {
368 /* A Null name_path is allowed and refers to the root */
370 num_segments = 0;
371 this_node = acpi_gbl_root_node;
372 path = "";
374 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
375 "Null Pathname (Zero segments), Flags=%X\n",
376 flags));
377 } else {
378 /*
379 * Name pointer is valid (and must be in internal name format)
380 *
381 * Check for scope prefixes:
382 *
383 * As represented in the AML stream, a namepath consists of an
384 * optional scope prefix followed by a name segment part.
385 *
386 * If present, the scope prefix is either a Root Prefix (in
387 * which case the name is fully qualified), or one or more
388 * Parent Prefixes (in which case the name's scope is relative
389 * to the current scope).
390 */
391 if (*path == (u8) AML_ROOT_PREFIX) {
393 /* Pathname is fully qualified, start from the root */
395 this_node = acpi_gbl_root_node;
396 search_parent_flag = ACPI_NS_NO_UPSEARCH;
398 /* Point to name segment part */
400 path++;
402 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
403 "Path is absolute from root [%p]\n",
404 this_node));
405 } else {
406 /* Pathname is relative to current scope, start there */
408 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
409 "Searching relative to prefix scope [%4.4s] (%p)\n",
410 acpi_ut_get_node_name(prefix_node),
411 prefix_node));
413 /*
414 * Handle multiple Parent Prefixes (carat) by just getting
415 * the parent node for each prefix instance.
416 */
417 this_node = prefix_node;
418 num_carats = 0;
419 while (*path == (u8) AML_PARENT_PREFIX) {
421 /* Name is fully qualified, no search rules apply */
423 search_parent_flag = ACPI_NS_NO_UPSEARCH;
424 /*
425 * Point past this prefix to the name segment
426 * part or the next Parent Prefix
427 */
428 path++;
430 /* Backup to the parent node */
432 num_carats++;
433 this_node = acpi_ns_get_parent_node(this_node);
434 if (!this_node) {
436 /* Current scope has no parent scope */
438 ACPI_ERROR((AE_INFO,
439 "ACPI path has too many parent prefixes (^) - reached beyond root node"));
440 return_ACPI_STATUS(AE_NOT_FOUND);
441 }
442 }
444 if (search_parent_flag == ACPI_NS_NO_UPSEARCH) {
445 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
446 "Search scope is [%4.4s], path has %d carat(s)\n",
447 acpi_ut_get_node_name
448 (this_node), num_carats));
449 }
450 }
452 /*
453 * Determine the number of ACPI name segments in this pathname.
454 *
455 * The segment part consists of either:
456 * - A Null name segment (0)
457 * - A dual_name_prefix followed by two 4-byte name segments
458 * - A multi_name_prefix followed by a byte indicating the
459 * number of segments and the segments themselves.
460 * - A single 4-byte name segment
461 *
462 * Examine the name prefix opcode, if any, to determine the number of
463 * segments.
464 */
465 switch (*path) {
466 case 0:
467 /*
468 * Null name after a root or parent prefixes. We already
469 * have the correct target node and there are no name segments.
470 */
471 num_segments = 0;
472 type = this_node->type;
474 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
475 "Prefix-only Pathname (Zero name segments), Flags=%X\n",
476 flags));
477 break;
479 case AML_DUAL_NAME_PREFIX:
481 /* More than one name_seg, search rules do not apply */
483 search_parent_flag = ACPI_NS_NO_UPSEARCH;
485 /* Two segments, point to first name segment */
487 num_segments = 2;
488 path++;
490 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
491 "Dual Pathname (2 segments, Flags=%X)\n",
492 flags));
493 break;
495 case AML_MULTI_NAME_PREFIX_OP:
497 /* More than one name_seg, search rules do not apply */
499 search_parent_flag = ACPI_NS_NO_UPSEARCH;
501 /* Extract segment count, point to first name segment */
503 path++;
504 num_segments = (u32) (u8) * path;
505 path++;
507 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
508 "Multi Pathname (%d Segments, Flags=%X)\n",
509 num_segments, flags));
510 break;
512 default:
513 /*
514 * Not a Null name, no Dual or Multi prefix, hence there is
515 * only one name segment and Pathname is already pointing to it.
516 */
517 num_segments = 1;
519 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
520 "Simple Pathname (1 segment, Flags=%X)\n",
521 flags));
522 break;
523 }
525 ACPI_DEBUG_EXEC(acpi_ns_print_pathname(num_segments, path));
526 }
528 /*
529 * Search namespace for each segment of the name. Loop through and
530 * verify (or add to the namespace) each name segment.
531 *
532 * The object type is significant only at the last name
533 * segment. (We don't care about the types along the path, only
534 * the type of the final target object.)
535 */
536 this_search_type = ACPI_TYPE_ANY;
537 current_node = this_node;
538 while (num_segments && current_node) {
539 num_segments--;
540 if (!num_segments) {
541 /*
542 * This is the last segment, enable typechecking
543 */
544 this_search_type = type;
546 /*
547 * Only allow automatic parent search (search rules) if the caller
548 * requested it AND we have a single, non-fully-qualified name_seg
549 */
550 if ((search_parent_flag != ACPI_NS_NO_UPSEARCH) &&
551 (flags & ACPI_NS_SEARCH_PARENT)) {
552 local_flags |= ACPI_NS_SEARCH_PARENT;
553 }
555 /* Set error flag according to caller */
557 if (flags & ACPI_NS_ERROR_IF_FOUND) {
558 local_flags |= ACPI_NS_ERROR_IF_FOUND;
559 }
560 }
562 /* Extract one ACPI name from the front of the pathname */
564 ACPI_MOVE_32_TO_32(&simple_name, path);
566 /* Try to find the single (4 character) ACPI name */
568 status =
569 acpi_ns_search_and_enter(simple_name, walk_state,
570 current_node, interpreter_mode,
571 this_search_type, local_flags,
572 &this_node);
573 if (ACPI_FAILURE(status)) {
574 if (status == AE_NOT_FOUND) {
576 /* Name not found in ACPI namespace */
578 ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
579 "Name [%4.4s] not found in scope [%4.4s] %p\n",
580 (char *)&simple_name,
581 (char *)&current_node->name,
582 current_node));
583 }
585 *return_node = this_node;
586 return_ACPI_STATUS(status);
587 }
589 /*
590 * Sanity typecheck of the target object:
591 *
592 * If 1) This is the last segment (num_segments == 0)
593 * 2) And we are looking for a specific type
594 * (Not checking for TYPE_ANY)
595 * 3) Which is not an alias
596 * 4) Which is not a local type (TYPE_SCOPE)
597 * 5) And the type of target object is known (not TYPE_ANY)
598 * 6) And target object does not match what we are looking for
599 *
600 * Then we have a type mismatch. Just warn and ignore it.
601 */
602 if ((num_segments == 0) &&
603 (type_to_check_for != ACPI_TYPE_ANY) &&
604 (type_to_check_for != ACPI_TYPE_LOCAL_ALIAS) &&
605 (type_to_check_for != ACPI_TYPE_LOCAL_METHOD_ALIAS) &&
606 (type_to_check_for != ACPI_TYPE_LOCAL_SCOPE) &&
607 (this_node->type != ACPI_TYPE_ANY) &&
608 (this_node->type != type_to_check_for)) {
610 /* Complain about a type mismatch */
612 ACPI_WARNING((AE_INFO,
613 "NsLookup: Type mismatch on %4.4s (%s), searching for (%s)",
614 ACPI_CAST_PTR(char, &simple_name),
615 acpi_ut_get_type_name(this_node->type),
616 acpi_ut_get_type_name
617 (type_to_check_for)));
618 }
620 /*
621 * If this is the last name segment and we are not looking for a
622 * specific type, but the type of found object is known, use that type
623 * to see if it opens a scope.
624 */
625 if ((num_segments == 0) && (type == ACPI_TYPE_ANY)) {
626 type = this_node->type;
627 }
629 /* Point to next name segment and make this node current */
631 path += ACPI_NAME_SIZE;
632 current_node = this_node;
633 }
635 /*
636 * Always check if we need to open a new scope
637 */
638 if (!(flags & ACPI_NS_DONT_OPEN_SCOPE) && (walk_state)) {
639 /*
640 * If entry is a type which opens a scope, push the new scope on the
641 * scope stack.
642 */
643 if (acpi_ns_opens_scope(type)) {
644 status =
645 acpi_ds_scope_stack_push(this_node, type,
646 walk_state);
647 if (ACPI_FAILURE(status)) {
648 return_ACPI_STATUS(status);
649 }
650 }
651 }
653 *return_node = this_node;
654 return_ACPI_STATUS(AE_OK);
655 }