ia64/linux-2.6.18-xen.hg

view drivers/acpi/tables.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 * acpi_tables.c - ACPI Boot-Time Table Parsing
3 *
4 * Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
5 *
6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23 *
24 */
26 #include <linux/init.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/smp.h>
30 #include <linux/string.h>
31 #include <linux/types.h>
32 #include <linux/irq.h>
33 #include <linux/errno.h>
34 #include <linux/acpi.h>
35 #include <linux/bootmem.h>
37 #define PREFIX "ACPI: "
39 #define ACPI_MAX_TABLES 128
41 static char *acpi_table_signatures[ACPI_TABLE_COUNT] = {
42 [ACPI_TABLE_UNKNOWN] = "????",
43 [ACPI_APIC] = "APIC",
44 [ACPI_BOOT] = "BOOT",
45 [ACPI_DBGP] = "DBGP",
46 [ACPI_DSDT] = "DSDT",
47 [ACPI_ECDT] = "ECDT",
48 [ACPI_ETDT] = "ETDT",
49 [ACPI_FADT] = "FACP",
50 [ACPI_FACS] = "FACS",
51 [ACPI_OEMX] = "OEM",
52 [ACPI_PSDT] = "PSDT",
53 [ACPI_SBST] = "SBST",
54 [ACPI_SLIT] = "SLIT",
55 [ACPI_SPCR] = "SPCR",
56 [ACPI_SRAT] = "SRAT",
57 [ACPI_SSDT] = "SSDT",
58 [ACPI_SPMI] = "SPMI",
59 [ACPI_HPET] = "HPET",
60 [ACPI_MCFG] = "MCFG",
61 };
63 static char *mps_inti_flags_polarity[] = { "dfl", "high", "res", "low" };
64 static char *mps_inti_flags_trigger[] = { "dfl", "edge", "res", "level" };
66 /* System Description Table (RSDT/XSDT) */
67 struct acpi_table_sdt {
68 unsigned long pa;
69 enum acpi_table_id id;
70 unsigned long size;
71 } __attribute__ ((packed));
73 static unsigned long sdt_pa; /* Physical Address */
74 static unsigned long sdt_count; /* Table count */
76 static struct acpi_table_sdt sdt_entry[ACPI_MAX_TABLES] __initdata;
78 void acpi_table_print(struct acpi_table_header *header, unsigned long phys_addr)
79 {
80 char *name = NULL;
82 if (!header)
83 return;
85 /* Some table signatures aren't good table names */
87 if (!strncmp((char *)&header->signature,
88 acpi_table_signatures[ACPI_APIC],
89 sizeof(header->signature))) {
90 name = "MADT";
91 } else if (!strncmp((char *)&header->signature,
92 acpi_table_signatures[ACPI_FADT],
93 sizeof(header->signature))) {
94 name = "FADT";
95 } else
96 name = header->signature;
98 printk(KERN_DEBUG PREFIX
99 "%.4s (v%3.3d %6.6s %8.8s 0x%08x %.4s 0x%08x) @ 0x%p\n", name,
100 header->revision, header->oem_id, header->oem_table_id,
101 header->oem_revision, header->asl_compiler_id,
102 header->asl_compiler_revision, (void *)phys_addr);
103 }
105 void acpi_table_print_madt_entry(acpi_table_entry_header * header)
106 {
107 if (!header)
108 return;
110 switch (header->type) {
112 case ACPI_MADT_LAPIC:
113 {
114 struct acpi_table_lapic *p =
115 (struct acpi_table_lapic *)header;
116 printk(KERN_INFO PREFIX
117 "LAPIC (acpi_id[0x%02x] lapic_id[0x%02x] %s)\n",
118 p->acpi_id, p->id,
119 p->flags.enabled ? "enabled" : "disabled");
120 }
121 break;
123 case ACPI_MADT_IOAPIC:
124 {
125 struct acpi_table_ioapic *p =
126 (struct acpi_table_ioapic *)header;
127 printk(KERN_INFO PREFIX
128 "IOAPIC (id[0x%02x] address[0x%08x] gsi_base[%d])\n",
129 p->id, p->address, p->global_irq_base);
130 }
131 break;
133 case ACPI_MADT_INT_SRC_OVR:
134 {
135 struct acpi_table_int_src_ovr *p =
136 (struct acpi_table_int_src_ovr *)header;
137 printk(KERN_INFO PREFIX
138 "INT_SRC_OVR (bus %d bus_irq %d global_irq %d %s %s)\n",
139 p->bus, p->bus_irq, p->global_irq,
140 mps_inti_flags_polarity[p->flags.polarity],
141 mps_inti_flags_trigger[p->flags.trigger]);
142 if (p->flags.reserved)
143 printk(KERN_INFO PREFIX
144 "INT_SRC_OVR unexpected reserved flags: 0x%x\n",
145 p->flags.reserved);
147 }
148 break;
150 case ACPI_MADT_NMI_SRC:
151 {
152 struct acpi_table_nmi_src *p =
153 (struct acpi_table_nmi_src *)header;
154 printk(KERN_INFO PREFIX
155 "NMI_SRC (%s %s global_irq %d)\n",
156 mps_inti_flags_polarity[p->flags.polarity],
157 mps_inti_flags_trigger[p->flags.trigger],
158 p->global_irq);
159 }
160 break;
162 case ACPI_MADT_LAPIC_NMI:
163 {
164 struct acpi_table_lapic_nmi *p =
165 (struct acpi_table_lapic_nmi *)header;
166 printk(KERN_INFO PREFIX
167 "LAPIC_NMI (acpi_id[0x%02x] %s %s lint[0x%x])\n",
168 p->acpi_id,
169 mps_inti_flags_polarity[p->flags.polarity],
170 mps_inti_flags_trigger[p->flags.trigger],
171 p->lint);
172 }
173 break;
175 case ACPI_MADT_LAPIC_ADDR_OVR:
176 {
177 struct acpi_table_lapic_addr_ovr *p =
178 (struct acpi_table_lapic_addr_ovr *)header;
179 printk(KERN_INFO PREFIX
180 "LAPIC_ADDR_OVR (address[%p])\n",
181 (void *)(unsigned long)p->address);
182 }
183 break;
185 case ACPI_MADT_IOSAPIC:
186 {
187 struct acpi_table_iosapic *p =
188 (struct acpi_table_iosapic *)header;
189 printk(KERN_INFO PREFIX
190 "IOSAPIC (id[0x%x] address[%p] gsi_base[%d])\n",
191 p->id, (void *)(unsigned long)p->address,
192 p->global_irq_base);
193 }
194 break;
196 case ACPI_MADT_LSAPIC:
197 {
198 struct acpi_table_lsapic *p =
199 (struct acpi_table_lsapic *)header;
200 printk(KERN_INFO PREFIX
201 "LSAPIC (acpi_id[0x%02x] lsapic_id[0x%02x] lsapic_eid[0x%02x] %s)\n",
202 p->acpi_id, p->id, p->eid,
203 p->flags.enabled ? "enabled" : "disabled");
204 }
205 break;
207 case ACPI_MADT_PLAT_INT_SRC:
208 {
209 struct acpi_table_plat_int_src *p =
210 (struct acpi_table_plat_int_src *)header;
211 printk(KERN_INFO PREFIX
212 "PLAT_INT_SRC (%s %s type[0x%x] id[0x%04x] eid[0x%x] iosapic_vector[0x%x] global_irq[0x%x]\n",
213 mps_inti_flags_polarity[p->flags.polarity],
214 mps_inti_flags_trigger[p->flags.trigger],
215 p->type, p->id, p->eid, p->iosapic_vector,
216 p->global_irq);
217 }
218 break;
220 default:
221 printk(KERN_WARNING PREFIX
222 "Found unsupported MADT entry (type = 0x%x)\n",
223 header->type);
224 break;
225 }
226 }
228 static int
229 acpi_table_compute_checksum(void *table_pointer, unsigned long length)
230 {
231 u8 *p = (u8 *) table_pointer;
232 unsigned long remains = length;
233 unsigned long sum = 0;
235 if (!p || !length)
236 return -EINVAL;
238 while (remains--)
239 sum += *p++;
241 return (sum & 0xFF);
242 }
244 /*
245 * acpi_get_table_header_early()
246 * for acpi_blacklisted(), acpi_table_get_sdt()
247 */
248 int __init
249 acpi_get_table_header_early(enum acpi_table_id id,
250 struct acpi_table_header **header)
251 {
252 unsigned int i;
253 enum acpi_table_id temp_id;
255 /* DSDT is different from the rest */
256 if (id == ACPI_DSDT)
257 temp_id = ACPI_FADT;
258 else
259 temp_id = id;
261 /* Locate the table. */
263 for (i = 0; i < sdt_count; i++) {
264 if (sdt_entry[i].id != temp_id)
265 continue;
266 *header = (void *)
267 __acpi_map_table(sdt_entry[i].pa, sdt_entry[i].size);
268 if (!*header) {
269 printk(KERN_WARNING PREFIX "Unable to map %s\n",
270 acpi_table_signatures[temp_id]);
271 return -ENODEV;
272 }
273 break;
274 }
276 if (!*header) {
277 printk(KERN_WARNING PREFIX "%s not present\n",
278 acpi_table_signatures[id]);
279 return -ENODEV;
280 }
282 /* Map the DSDT header via the pointer in the FADT */
283 if (id == ACPI_DSDT) {
284 struct fadt_descriptor *fadt =
285 (struct fadt_descriptor *)*header;
287 if (fadt->revision == 3 && fadt->Xdsdt) {
288 *header = (void *)__acpi_map_table(fadt->Xdsdt,
289 sizeof(struct
290 acpi_table_header));
291 } else if (fadt->V1_dsdt) {
292 *header = (void *)__acpi_map_table(fadt->V1_dsdt,
293 sizeof(struct
294 acpi_table_header));
295 } else
296 *header = NULL;
298 if (!*header) {
299 printk(KERN_WARNING PREFIX "Unable to map DSDT\n");
300 return -ENODEV;
301 }
302 }
304 return 0;
305 }
307 int __init
308 acpi_table_parse_madt_family(enum acpi_table_id id,
309 unsigned long madt_size,
310 int entry_id,
311 acpi_madt_entry_handler handler,
312 unsigned int max_entries)
313 {
314 void *madt = NULL;
315 acpi_table_entry_header *entry;
316 unsigned int count = 0;
317 unsigned long madt_end;
318 unsigned int i;
320 if (!handler)
321 return -EINVAL;
323 /* Locate the MADT (if exists). There should only be one. */
325 for (i = 0; i < sdt_count; i++) {
326 if (sdt_entry[i].id != id)
327 continue;
328 madt = (void *)
329 __acpi_map_table(sdt_entry[i].pa, sdt_entry[i].size);
330 if (!madt) {
331 printk(KERN_WARNING PREFIX "Unable to map %s\n",
332 acpi_table_signatures[id]);
333 return -ENODEV;
334 }
335 break;
336 }
338 if (!madt) {
339 printk(KERN_WARNING PREFIX "%s not present\n",
340 acpi_table_signatures[id]);
341 return -ENODEV;
342 }
344 madt_end = (unsigned long)madt + sdt_entry[i].size;
346 /* Parse all entries looking for a match. */
348 entry = (acpi_table_entry_header *)
349 ((unsigned long)madt + madt_size);
351 while (((unsigned long)entry) + sizeof(acpi_table_entry_header) <
352 madt_end) {
353 if (entry->type == entry_id
354 && (!max_entries || count++ < max_entries))
355 if (handler(entry, madt_end))
356 return -EINVAL;
358 entry = (acpi_table_entry_header *)
359 ((unsigned long)entry + entry->length);
360 }
361 if (max_entries && count > max_entries) {
362 printk(KERN_WARNING PREFIX "[%s:0x%02x] ignored %i entries of "
363 "%i found\n", acpi_table_signatures[id], entry_id,
364 count - max_entries, count);
365 }
367 return count;
368 }
370 int __init
371 acpi_table_parse_madt(enum acpi_madt_entry_id id,
372 acpi_madt_entry_handler handler, unsigned int max_entries)
373 {
374 return acpi_table_parse_madt_family(ACPI_APIC,
375 sizeof(struct acpi_table_madt), id,
376 handler, max_entries);
377 }
379 int __init acpi_table_parse(enum acpi_table_id id, acpi_table_handler handler)
380 {
381 int count = 0;
382 unsigned int i = 0;
384 if (!handler)
385 return -EINVAL;
387 for (i = 0; i < sdt_count; i++) {
388 if (sdt_entry[i].id != id)
389 continue;
390 count++;
391 if (count == 1)
392 handler(sdt_entry[i].pa, sdt_entry[i].size);
394 else
395 printk(KERN_WARNING PREFIX
396 "%d duplicate %s table ignored.\n", count,
397 acpi_table_signatures[id]);
398 }
400 return count;
401 }
403 static int __init acpi_table_get_sdt(struct acpi_table_rsdp *rsdp)
404 {
405 struct acpi_table_header *header = NULL;
406 unsigned int i, id = 0;
408 if (!rsdp)
409 return -EINVAL;
411 /* First check XSDT (but only on ACPI 2.0-compatible systems) */
413 if ((rsdp->revision >= 2) &&
414 (((struct acpi20_table_rsdp *)rsdp)->xsdt_address)) {
416 struct acpi_table_xsdt *mapped_xsdt = NULL;
418 sdt_pa = ((struct acpi20_table_rsdp *)rsdp)->xsdt_address;
420 /* map in just the header */
421 header = (struct acpi_table_header *)
422 __acpi_map_table(sdt_pa, sizeof(struct acpi_table_header));
424 if (!header) {
425 printk(KERN_WARNING PREFIX
426 "Unable to map XSDT header\n");
427 return -ENODEV;
428 }
430 /* remap in the entire table before processing */
431 mapped_xsdt = (struct acpi_table_xsdt *)
432 __acpi_map_table(sdt_pa, header->length);
433 if (!mapped_xsdt) {
434 printk(KERN_WARNING PREFIX "Unable to map XSDT\n");
435 return -ENODEV;
436 }
437 header = &mapped_xsdt->header;
439 if (strncmp(header->signature, "XSDT", 4)) {
440 printk(KERN_WARNING PREFIX
441 "XSDT signature incorrect\n");
442 return -ENODEV;
443 }
445 if (acpi_table_compute_checksum(header, header->length)) {
446 printk(KERN_WARNING PREFIX "Invalid XSDT checksum\n");
447 return -ENODEV;
448 }
450 sdt_count =
451 (header->length - sizeof(struct acpi_table_header)) >> 3;
452 if (sdt_count > ACPI_MAX_TABLES) {
453 printk(KERN_WARNING PREFIX
454 "Truncated %lu XSDT entries\n",
455 (sdt_count - ACPI_MAX_TABLES));
456 sdt_count = ACPI_MAX_TABLES;
457 }
459 for (i = 0; i < sdt_count; i++)
460 sdt_entry[i].pa = (unsigned long)mapped_xsdt->entry[i];
461 }
463 /* Then check RSDT */
465 else if (rsdp->rsdt_address) {
467 struct acpi_table_rsdt *mapped_rsdt = NULL;
469 sdt_pa = rsdp->rsdt_address;
471 /* map in just the header */
472 header = (struct acpi_table_header *)
473 __acpi_map_table(sdt_pa, sizeof(struct acpi_table_header));
474 if (!header) {
475 printk(KERN_WARNING PREFIX
476 "Unable to map RSDT header\n");
477 return -ENODEV;
478 }
480 /* remap in the entire table before processing */
481 mapped_rsdt = (struct acpi_table_rsdt *)
482 __acpi_map_table(sdt_pa, header->length);
483 if (!mapped_rsdt) {
484 printk(KERN_WARNING PREFIX "Unable to map RSDT\n");
485 return -ENODEV;
486 }
487 header = &mapped_rsdt->header;
489 if (strncmp(header->signature, "RSDT", 4)) {
490 printk(KERN_WARNING PREFIX
491 "RSDT signature incorrect\n");
492 return -ENODEV;
493 }
495 if (acpi_table_compute_checksum(header, header->length)) {
496 printk(KERN_WARNING PREFIX "Invalid RSDT checksum\n");
497 return -ENODEV;
498 }
500 sdt_count =
501 (header->length - sizeof(struct acpi_table_header)) >> 2;
502 if (sdt_count > ACPI_MAX_TABLES) {
503 printk(KERN_WARNING PREFIX
504 "Truncated %lu RSDT entries\n",
505 (sdt_count - ACPI_MAX_TABLES));
506 sdt_count = ACPI_MAX_TABLES;
507 }
509 for (i = 0; i < sdt_count; i++)
510 sdt_entry[i].pa = (unsigned long)mapped_rsdt->entry[i];
511 }
513 else {
514 printk(KERN_WARNING PREFIX
515 "No System Description Table (RSDT/XSDT) specified in RSDP\n");
516 return -ENODEV;
517 }
519 acpi_table_print(header, sdt_pa);
521 for (i = 0; i < sdt_count; i++) {
523 /* map in just the header */
524 header = (struct acpi_table_header *)
525 __acpi_map_table(sdt_entry[i].pa,
526 sizeof(struct acpi_table_header));
527 if (!header)
528 continue;
530 /* remap in the entire table before processing */
531 header = (struct acpi_table_header *)
532 __acpi_map_table(sdt_entry[i].pa, header->length);
533 if (!header)
534 continue;
536 acpi_table_print(header, sdt_entry[i].pa);
538 if (acpi_table_compute_checksum(header, header->length)) {
539 printk(KERN_WARNING " >>> ERROR: Invalid checksum\n");
540 continue;
541 }
543 sdt_entry[i].size = header->length;
545 for (id = 0; id < ACPI_TABLE_COUNT; id++) {
546 if (!strncmp((char *)&header->signature,
547 acpi_table_signatures[id],
548 sizeof(header->signature))) {
549 sdt_entry[i].id = id;
550 }
551 }
552 }
554 /*
555 * The DSDT is *not* in the RSDT (why not? no idea.) but we want
556 * to print its info, because this is what people usually blacklist
557 * against. Unfortunately, we don't know the phys_addr, so just
558 * print 0. Maybe no one will notice.
559 */
560 if (!acpi_get_table_header_early(ACPI_DSDT, &header))
561 acpi_table_print(header, 0);
563 return 0;
564 }
566 /*
567 * acpi_table_init()
568 *
569 * find RSDP, find and checksum SDT/XSDT.
570 * checksum all tables, print SDT/XSDT
571 *
572 * result: sdt_entry[] is initialized
573 */
575 int __init acpi_table_init(void)
576 {
577 struct acpi_table_rsdp *rsdp = NULL;
578 unsigned long rsdp_phys = 0;
579 int result = 0;
581 /* Locate and map the Root System Description Table (RSDP) */
583 rsdp_phys = acpi_find_rsdp();
584 if (!rsdp_phys) {
585 printk(KERN_ERR PREFIX "Unable to locate RSDP\n");
586 return -ENODEV;
587 }
589 rsdp = (struct acpi_table_rsdp *)__acpi_map_table(rsdp_phys,
590 sizeof(struct acpi_table_rsdp));
591 if (!rsdp) {
592 printk(KERN_WARNING PREFIX "Unable to map RSDP\n");
593 return -ENODEV;
594 }
596 printk(KERN_DEBUG PREFIX
597 "RSDP (v%3.3d %6.6s ) @ 0x%p\n",
598 rsdp->revision, rsdp->oem_id, (void *)rsdp_phys);
600 if (rsdp->revision < 2)
601 result =
602 acpi_table_compute_checksum(rsdp,
603 sizeof(struct acpi_table_rsdp));
604 else
605 result =
606 acpi_table_compute_checksum(rsdp,
607 ((struct acpi20_table_rsdp *)
608 rsdp)->length);
610 if (result) {
611 printk(KERN_WARNING " >>> ERROR: Invalid checksum\n");
612 return -ENODEV;
613 }
615 /* Locate and map the System Description table (RSDT/XSDT) */
617 if (acpi_table_get_sdt(rsdp))
618 return -ENODEV;
620 return 0;
621 }