x86, acpi: Handle xapic/x2apic entries in MADT at same time

One system have mixing xapic and x2apic entries in MADT and SRAT.
BIOS guys insist that ACPI 4.0 SPEC said so, if apic id < 255, even
the cpus are with x2apic mode pre-enabled, still need to use xapic entries
instead of x2apic entries.

on 8 socket system with x2apic pre-enabled, will get out of order sequence:
CPU0: socket0, core0, thread0.
CPU1 - CPU 40: socket 4 - socket 7, thread 0
CPU41 - CPU 80: socket 4 - socket 7, thread 1
CPU81 - CPU 119: socket 0 - socket 3, thread 0
CPU120 - CPU 159: socket 0 - socket 3, thread 1

so max_cpus=80 will not get all thread0 now.

Need to handle every entry in MADT at same time with xapic and x2apic.
so we can honor sequence in MADT.

We can use max_cpus= command line to use thread0 in every core,
because recent MADT always have all thread0 at first.
Also it could make the cpu to node mapping more sane.

after patch will get
CPU0 - CPU 79: socket 0 - socket 7, thread 0
CPU80 - CPU 159: socket 0 - socket 7, thread 1

-v2: update some comments, and change to pass array pointer.

Signed-off-by: Yinghai Lu <yinghai@kernel.org>

diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 4558f0d0822dcbaf7e0c7b9504e5a2ccb05879c4..56657259a8e284eab92d0285fb7e48df41fda6de 100644 (file)
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -883,6 +883,7 @@ static int __init acpi_parse_madt_lapic_entries(void)
 {
        int count;
        int x2count = 0;
+       struct acpi_subtable_proc madt_proc[2];
 
        if (!cpu_has_apic)
                return -ENODEV;
@@ -907,10 +908,16 @@ static int __init acpi_parse_madt_lapic_entries(void)
                                      acpi_parse_sapic, MAX_LOCAL_APIC);
 
        if (!count) {
-               x2count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC,
-                                       acpi_parse_x2apic, MAX_LOCAL_APIC);
-               count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC,
-                                       acpi_parse_lapic, MAX_LOCAL_APIC);
+               memset(madt_proc, 0, sizeof(madt_proc));
+               madt_proc[0].id = ACPI_MADT_TYPE_LOCAL_APIC;
+               madt_proc[0].handler = acpi_parse_lapic;
+               madt_proc[1].id = ACPI_MADT_TYPE_LOCAL_X2APIC;
+               madt_proc[1].handler = acpi_parse_x2apic;
+               acpi_table_parse_entries_array(ACPI_SIG_MADT,
+                                           sizeof(struct acpi_table_madt),
+                           madt_proc, ARRAY_SIZE(madt_proc), MAX_LOCAL_APIC);
+               count = madt_proc[0].count;
+               x2count = madt_proc[1].count;
        }
        if (!count && !x2count) {
                printk(KERN_ERR PREFIX "No LAPIC entries present\n");
@@ -922,11 +929,16 @@ static int __init acpi_parse_madt_lapic_entries(void)
                return count;
        }
 
-       x2count =
-           acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC_NMI,
-                                 acpi_parse_x2apic_nmi, 0);
-       count =
-           acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, acpi_parse_lapic_nmi, 0);
+       memset(madt_proc, 0, sizeof(madt_proc));
+       madt_proc[0].id = ACPI_MADT_TYPE_LOCAL_APIC_NMI;
+       madt_proc[0].handler = acpi_parse_lapic_nmi;
+       madt_proc[1].id = ACPI_MADT_TYPE_LOCAL_X2APIC_NMI;
+       madt_proc[1].handler = acpi_parse_x2apic_nmi;
+       acpi_table_parse_entries_array(ACPI_SIG_MADT,
+                                   sizeof(struct acpi_table_madt),
+                                   madt_proc, ARRAY_SIZE(madt_proc), 0);
+       count = madt_proc[0].count;
+       x2count = madt_proc[1].count;
        if (count < 0 || x2count < 0) {
                printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n");
                /* TBD: Cleanup to allow fallback to MPS */

diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 3b5c3189fd995e4cc200c532b2d05ba6b274fac7..cc97a8cd3efdac4dd6972627f1e8d3303ea0bf5f 100644 (file)
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -284,10 +284,18 @@ int __init acpi_numa_init(void)
 
        /* SRAT: Static Resource Affinity Table */
        if (!acpi_table_parse(ACPI_SIG_SRAT, acpi_parse_srat)) {
-               acpi_table_parse_srat(ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY,
-                                    acpi_parse_x2apic_affinity, 0);
-               acpi_table_parse_srat(ACPI_SRAT_TYPE_CPU_AFFINITY,
-                                    acpi_parse_processor_affinity, 0);
+               struct acpi_subtable_proc srat_proc[2];
+
+               memset(srat_proc, 0, sizeof(srat_proc));
+               srat_proc[0].id = ACPI_SRAT_TYPE_CPU_AFFINITY;
+               srat_proc[0].handler = acpi_parse_processor_affinity;
+               srat_proc[1].id = ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY;
+               srat_proc[1].handler = acpi_parse_x2apic_affinity;
+
+               acpi_table_parse_entries_array(ACPI_SIG_SRAT,
+                                          sizeof(struct acpi_table_srat),
+                                          srat_proc, ARRAY_SIZE(srat_proc), 0);
+
                cnt = acpi_table_parse_srat(ACPI_SRAT_TYPE_MEMORY_AFFINITY,
                                            acpi_parse_memory_affinity,
                                            NR_NODE_MEMBLKS);

diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index f336bca7c4503ec1d03d7741ee8185afae942381..1e244190d463e23ca1c72f316bb083539133e048 100644 (file)
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -201,10 +201,9 @@ void acpi_table_print_madt_entry(struct acpi_subtable_header *header)
 
 
 int __init
-acpi_table_parse_entries(char *id,
+acpi_table_parse_entries_array(char *id,
                             unsigned long table_size,
-                            int entry_id,
-                            acpi_table_entry_handler handler,
+                            struct acpi_subtable_proc *proc, int proc_num,
                             unsigned int max_entries)
 {
        struct acpi_table_header *table_header = NULL;
@@ -212,12 +211,12 @@ acpi_table_parse_entries(char *id,
        unsigned int count = 0;
        unsigned long table_end;
        acpi_size tbl_size;
+       int i;
 
-       if (acpi_disabled)
+       if (acpi_disabled) {
+               proc[0].count = -ENODEV;
                return -ENODEV;
-
-       if (!handler)
-               return -EINVAL;
+       }
 
        if (strncmp(id, ACPI_SIG_MADT, 4) == 0)
                acpi_get_table_with_size(id, acpi_apic_instance, &table_header, &tbl_size);
@@ -226,6 +225,7 @@ acpi_table_parse_entries(char *id,
 
        if (!table_header) {
                printk(KERN_WARNING PREFIX "%4.4s not present\n", id);
+               proc[0].count = -ENODEV;
                return -ENODEV;
        }
 
@@ -238,25 +238,56 @@ acpi_table_parse_entries(char *id,
 
        while (((unsigned long)entry) + sizeof(struct acpi_subtable_header) <
               table_end) {
-               if (entry->type == entry_id
-                   && (!max_entries || count++ < max_entries))
-                       if (handler(entry, table_end)) {
-                               early_acpi_os_unmap_memory((char *)table_header, tbl_size);
+               for (i = 0; i < proc_num; i++) {
+                       if (entry->type != proc[i].id)
+                               continue;
+                       if (max_entries && count++ >= max_entries)
+                               continue;
+                       if (proc[i].handler(entry, table_end)) {
+                               early_acpi_os_unmap_memory((char *)table_header,
+                                                                tbl_size);
+                               proc[i].count = -EINVAL;
                                return -EINVAL;
                        }
+                       proc[i].count++;
+                       break;
+               }
 
                entry = (struct acpi_subtable_header *)
                    ((unsigned long)entry + entry->length);
        }
        if (max_entries && count > max_entries) {
-               printk(KERN_WARNING PREFIX "[%4.4s:0x%02x] ignored %i entries of "
-                      "%i found\n", id, entry_id, count - max_entries, count);
+               printk(KERN_WARNING PREFIX "[%4.4s:0x%02x ", id, proc[0].id);
+               for (i = 1; i < proc_num; i++)
+                       printk(KERN_CONT " 0x%02x", proc[i].id);
+               printk(KERN_CONT "] ignored %i entries of %i found\n",
+                      count-max_entries, count);
        }
 
        early_acpi_os_unmap_memory((char *)table_header, tbl_size);
        return count;
 }
 
+int __init
+acpi_table_parse_entries(char *id,
+                            unsigned long table_size,
+                            int entry_id,
+                            acpi_table_entry_handler handler,
+                            unsigned int max_entries)
+{
+       struct acpi_subtable_proc proc[1];
+
+       if (!handler)
+               return -EINVAL;
+
+       memset(proc, 0, sizeof(proc));
+       proc[0].id = entry_id;
+       proc[0].handler = handler;
+
+       return acpi_table_parse_entries_array(id, table_size, proc, 1,
+                                                max_entries);
+}
+
 int __init
 acpi_table_parse_madt(enum acpi_madt_type id,
                      acpi_table_entry_handler handler, unsigned int max_entries)

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 1deb2a73c2daf861fb20130f17b4c6a3d924e152..b8e3881d24f3f0a1be2bdba1b13699494b40af17 100644 (file)
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -76,6 +76,12 @@ typedef int (*acpi_table_handler) (struct acpi_table_header *table);
 
 typedef int (*acpi_table_entry_handler) (struct acpi_subtable_header *header, const unsigned long end);
 
+struct acpi_subtable_proc {
+       int id;
+       acpi_table_entry_handler handler;
+       int count;
+};
+
 char * __acpi_map_table (unsigned long phys_addr, unsigned long size);
 void __acpi_unmap_table(char *map, unsigned long size);
 int early_acpi_boot_init(void);
@@ -86,6 +92,9 @@ int acpi_numa_init (void);
 
 int acpi_table_init (void);
 int acpi_table_parse (char *id, acpi_table_handler handler);
+int acpi_table_parse_entries_array(char *id, unsigned long table_size,
+       struct acpi_subtable_proc *proc, int proc_num,
+       unsigned int max_entries);
 int __init acpi_table_parse_entries(char *id, unsigned long table_size,
        int entry_id, acpi_table_entry_handler handler, unsigned int max_entries);
 int acpi_table_parse_madt (enum acpi_madt_type id, acpi_table_entry_handler handler, unsigned int max_entries);