root/arch/x86/boot/compressed/acpi.c

DEFINITIONS

1. __efi_get_rsdp_addr
2. get_kexec_setup_data_addr
3. kexec_get_rsdp_addr
4. kexec_get_rsdp_addr
5. efi_get_rsdp_addr
6. compute_checksum
7. scan_mem_for_rsdp
8. bios_get_rsdp_addr
9. get_rsdp_addr
10. get_cmdline_acpi_rsdp
11. get_acpi_srat_table
12. count_immovable_mem_regions

   1 // SPDX-License-Identifier: GPL-2.0
   2 #define BOOT_CTYPE_H
   3 #include "misc.h"
   4 #include "error.h"
   5 #include "../string.h"
   6 
   7 #include <linux/numa.h>
   8 #include <linux/efi.h>
   9 #include <asm/efi.h>
  10 
  11 /*
  12  * Longest parameter of 'acpi=' is 'copy_dsdt', plus an extra '\0'
  13  * for termination.
  14  */
  15 #define MAX_ACPI_ARG_LENGTH 10
  16 
  17 /*
  18  * Immovable memory regions representation. Max amount of memory regions is
  19  * MAX_NUMNODES*2.
  20  */
  21 struct mem_vector immovable_mem[MAX_NUMNODES*2];
  22 
  23 /*
  24  * Search EFI system tables for RSDP.  If both ACPI_20_TABLE_GUID and
  25  * ACPI_TABLE_GUID are found, take the former, which has more features.
  26  */
  27 static acpi_physical_address
  28 __efi_get_rsdp_addr(unsigned long config_tables, unsigned int nr_tables,
  29                     bool efi_64)
  30 {
  31         acpi_physical_address rsdp_addr = 0;
  32 
  33 #ifdef CONFIG_EFI
  34         int i;
  35 
  36         /* Get EFI tables from systab. */
  37         for (i = 0; i < nr_tables; i++) {
  38                 acpi_physical_address table;
  39                 efi_guid_t guid;
  40 
  41                 if (efi_64) {
  42                         efi_config_table_64_t *tbl = (efi_config_table_64_t *)config_tables + i;
  43 
  44                         guid  = tbl->guid;
  45                         table = tbl->table;
  46 
  47                         if (!IS_ENABLED(CONFIG_X86_64) && table >> 32) {
  48                                 debug_putstr("Error getting RSDP address: EFI config table located above 4GB.\n");
  49                                 return 0;
  50                         }
  51                 } else {
  52                         efi_config_table_32_t *tbl = (efi_config_table_32_t *)config_tables + i;
  53 
  54                         guid  = tbl->guid;
  55                         table = tbl->table;
  56                 }
  57 
  58                 if (!(efi_guidcmp(guid, ACPI_TABLE_GUID)))
  59                         rsdp_addr = table;
  60                 else if (!(efi_guidcmp(guid, ACPI_20_TABLE_GUID)))
  61                         return table;
  62         }
  63 #endif
  64         return rsdp_addr;
  65 }
  66 
  67 /* EFI/kexec support is 64-bit only. */
  68 #ifdef CONFIG_X86_64
  69 static struct efi_setup_data *get_kexec_setup_data_addr(void)
  70 {
  71         struct setup_data *data;
  72         u64 pa_data;
  73 
  74         pa_data = boot_params->hdr.setup_data;
  75         while (pa_data) {
  76                 data = (struct setup_data *)pa_data;
  77                 if (data->type == SETUP_EFI)
  78                         return (struct efi_setup_data *)(pa_data + sizeof(struct setup_data));
  79 
  80                 pa_data = data->next;
  81         }
  82         return NULL;
  83 }
  84 
  85 static acpi_physical_address kexec_get_rsdp_addr(void)
  86 {
  87         efi_system_table_64_t *systab;
  88         struct efi_setup_data *esd;
  89         struct efi_info *ei;
  90         char *sig;
  91 
  92         esd = (struct efi_setup_data *)get_kexec_setup_data_addr();
  93         if (!esd)
  94                 return 0;
  95 
  96         if (!esd->tables) {
  97                 debug_putstr("Wrong kexec SETUP_EFI data.\n");
  98                 return 0;
  99         }
 100 
 101         ei = &boot_params->efi_info;
 102         sig = (char *)&ei->efi_loader_signature;
 103         if (strncmp(sig, EFI64_LOADER_SIGNATURE, 4)) {
 104                 debug_putstr("Wrong kexec EFI loader signature.\n");
 105                 return 0;
 106         }
 107 
 108         /* Get systab from boot params. */
 109         systab = (efi_system_table_64_t *) (ei->efi_systab | ((__u64)ei->efi_systab_hi << 32));
 110         if (!systab)
 111                 error("EFI system table not found in kexec boot_params.");
 112 
 113         return __efi_get_rsdp_addr((unsigned long)esd->tables, systab->nr_tables, true);
 114 }
 115 #else
 116 static acpi_physical_address kexec_get_rsdp_addr(void) { return 0; }
 117 #endif /* CONFIG_X86_64 */
 118 
 119 static acpi_physical_address efi_get_rsdp_addr(void)
 120 {
 121 #ifdef CONFIG_EFI
 122         unsigned long systab, config_tables;
 123         unsigned int nr_tables;
 124         struct efi_info *ei;
 125         bool efi_64;
 126         char *sig;
 127 
 128         ei = &boot_params->efi_info;
 129         sig = (char *)&ei->efi_loader_signature;
 130 
 131         if (!strncmp(sig, EFI64_LOADER_SIGNATURE, 4)) {
 132                 efi_64 = true;
 133         } else if (!strncmp(sig, EFI32_LOADER_SIGNATURE, 4)) {
 134                 efi_64 = false;
 135         } else {
 136                 debug_putstr("Wrong EFI loader signature.\n");
 137                 return 0;
 138         }
 139 
 140         /* Get systab from boot params. */
 141 #ifdef CONFIG_X86_64
 142         systab = ei->efi_systab | ((__u64)ei->efi_systab_hi << 32);
 143 #else
 144         if (ei->efi_systab_hi || ei->efi_memmap_hi) {
 145                 debug_putstr("Error getting RSDP address: EFI system table located above 4GB.\n");
 146                 return 0;
 147         }
 148         systab = ei->efi_systab;
 149 #endif
 150         if (!systab)
 151                 error("EFI system table not found.");
 152 
 153         /* Handle EFI bitness properly */
 154         if (efi_64) {
 155                 efi_system_table_64_t *stbl = (efi_system_table_64_t *)systab;
 156 
 157                 config_tables   = stbl->tables;
 158                 nr_tables       = stbl->nr_tables;
 159         } else {
 160                 efi_system_table_32_t *stbl = (efi_system_table_32_t *)systab;
 161 
 162                 config_tables   = stbl->tables;
 163                 nr_tables       = stbl->nr_tables;
 164         }
 165 
 166         if (!config_tables)
 167                 error("EFI config tables not found.");
 168 
 169         return __efi_get_rsdp_addr(config_tables, nr_tables, efi_64);
 170 #else
 171         return 0;
 172 #endif
 173 }
 174 
 175 static u8 compute_checksum(u8 *buffer, u32 length)
 176 {
 177         u8 *end = buffer + length;
 178         u8 sum = 0;
 179 
 180         while (buffer < end)
 181                 sum += *(buffer++);
 182 
 183         return sum;
 184 }
 185 
 186 /* Search a block of memory for the RSDP signature. */
 187 static u8 *scan_mem_for_rsdp(u8 *start, u32 length)
 188 {
 189         struct acpi_table_rsdp *rsdp;
 190         u8 *address, *end;
 191 
 192         end = start + length;
 193 
 194         /* Search from given start address for the requested length */
 195         for (address = start; address < end; address += ACPI_RSDP_SCAN_STEP) {
 196                 /*
 197                  * Both RSDP signature and checksum must be correct.
 198                  * Note: Sometimes there exists more than one RSDP in memory;
 199                  * the valid RSDP has a valid checksum, all others have an
 200                  * invalid checksum.
 201                  */
 202                 rsdp = (struct acpi_table_rsdp *)address;
 203 
 204                 /* BAD Signature */
 205                 if (!ACPI_VALIDATE_RSDP_SIG(rsdp->signature))
 206                         continue;
 207 
 208                 /* Check the standard checksum */
 209                 if (compute_checksum((u8 *)rsdp, ACPI_RSDP_CHECKSUM_LENGTH))
 210                         continue;
 211 
 212                 /* Check extended checksum if table version >= 2 */
 213                 if ((rsdp->revision >= 2) &&
 214                     (compute_checksum((u8 *)rsdp, ACPI_RSDP_XCHECKSUM_LENGTH)))
 215                         continue;
 216 
 217                 /* Signature and checksum valid, we have found a real RSDP */
 218                 return address;
 219         }
 220         return NULL;
 221 }
 222 
 223 /* Search RSDP address in EBDA. */
 224 static acpi_physical_address bios_get_rsdp_addr(void)
 225 {
 226         unsigned long address;
 227         u8 *rsdp;
 228 
 229         /* Get the location of the Extended BIOS Data Area (EBDA) */
 230         address = *(u16 *)ACPI_EBDA_PTR_LOCATION;
 231         address <<= 4;
 232 
 233         /*
 234          * Search EBDA paragraphs (EBDA is required to be a minimum of
 235          * 1K length)
 236          */
 237         if (address > 0x400) {
 238                 rsdp = scan_mem_for_rsdp((u8 *)address, ACPI_EBDA_WINDOW_SIZE);
 239                 if (rsdp)
 240                         return (acpi_physical_address)(unsigned long)rsdp;
 241         }
 242 
 243         /* Search upper memory: 16-byte boundaries in E0000h-FFFFFh */
 244         rsdp = scan_mem_for_rsdp((u8 *) ACPI_HI_RSDP_WINDOW_BASE,
 245                                         ACPI_HI_RSDP_WINDOW_SIZE);
 246         if (rsdp)
 247                 return (acpi_physical_address)(unsigned long)rsdp;
 248 
 249         return 0;
 250 }
 251 
 252 /* Return RSDP address on success, otherwise 0. */
 253 acpi_physical_address get_rsdp_addr(void)
 254 {
 255         acpi_physical_address pa;
 256 
 257         pa = boot_params->acpi_rsdp_addr;
 258 
 259         /*
 260          * Try to get EFI data from setup_data. This can happen when we're a
 261          * kexec'ed kernel and kexec(1) has passed all the required EFI info to
 262          * us.
 263          */
 264         if (!pa)
 265                 pa = kexec_get_rsdp_addr();
 266 
 267         if (!pa)
 268                 pa = efi_get_rsdp_addr();
 269 
 270         if (!pa)
 271                 pa = bios_get_rsdp_addr();
 272 
 273         return pa;
 274 }
 275 
 276 #if defined(CONFIG_RANDOMIZE_BASE) && defined(CONFIG_MEMORY_HOTREMOVE)
 277 /*
 278  * Max length of 64-bit hex address string is 19, prefix "0x" + 16 hex
 279  * digits, and '\0' for termination.
 280  */
 281 #define MAX_ADDR_LEN 19
 282 
 283 static acpi_physical_address get_cmdline_acpi_rsdp(void)
 284 {
 285         acpi_physical_address addr = 0;
 286 
 287 #ifdef CONFIG_KEXEC
 288         char val[MAX_ADDR_LEN] = { };
 289         int ret;
 290 
 291         ret = cmdline_find_option("acpi_rsdp", val, MAX_ADDR_LEN);
 292         if (ret < 0)
 293                 return 0;
 294 
 295         if (kstrtoull(val, 16, &addr))
 296                 return 0;
 297 #endif
 298         return addr;
 299 }
 300 
 301 /* Compute SRAT address from RSDP. */
 302 static unsigned long get_acpi_srat_table(void)
 303 {
 304         unsigned long root_table, acpi_table;
 305         struct acpi_table_header *header;
 306         struct acpi_table_rsdp *rsdp;
 307         u32 num_entries, size, len;
 308         char arg[10];
 309         u8 *entry;
 310 
 311         /*
 312          * Check whether we were given an RSDP on the command line. We don't
 313          * stash this in boot params because the kernel itself may have
 314          * different ideas about whether to trust a command-line parameter.
 315          */
 316         rsdp = (struct acpi_table_rsdp *)get_cmdline_acpi_rsdp();
 317 
 318         if (!rsdp)
 319                 rsdp = (struct acpi_table_rsdp *)(long)
 320                         boot_params->acpi_rsdp_addr;
 321 
 322         if (!rsdp)
 323                 return 0;
 324 
 325         /* Get ACPI root table from RSDP.*/
 326         if (!(cmdline_find_option("acpi", arg, sizeof(arg)) == 4 &&
 327             !strncmp(arg, "rsdt", 4)) &&
 328             rsdp->xsdt_physical_address &&
 329             rsdp->revision > 1) {
 330                 root_table = rsdp->xsdt_physical_address;
 331                 size = ACPI_XSDT_ENTRY_SIZE;
 332         } else {
 333                 root_table = rsdp->rsdt_physical_address;
 334                 size = ACPI_RSDT_ENTRY_SIZE;
 335         }
 336 
 337         if (!root_table)
 338                 return 0;
 339 
 340         header = (struct acpi_table_header *)root_table;
 341         len = header->length;
 342         if (len < sizeof(struct acpi_table_header) + size)
 343                 return 0;
 344 
 345         num_entries = (len - sizeof(struct acpi_table_header)) / size;
 346         entry = (u8 *)(root_table + sizeof(struct acpi_table_header));
 347 
 348         while (num_entries--) {
 349                 if (size == ACPI_RSDT_ENTRY_SIZE)
 350                         acpi_table = *(u32 *)entry;
 351                 else
 352                         acpi_table = *(u64 *)entry;
 353 
 354                 if (acpi_table) {
 355                         header = (struct acpi_table_header *)acpi_table;
 356 
 357                         if (ACPI_COMPARE_NAMESEG(header->signature, ACPI_SIG_SRAT))
 358                                 return acpi_table;
 359                 }
 360                 entry += size;
 361         }
 362         return 0;
 363 }
 364 
 365 /**
 366  * count_immovable_mem_regions - Parse SRAT and cache the immovable
 367  * memory regions into the immovable_mem array.
 368  *
 369  * Return the number of immovable memory regions on success, 0 on failure:
 370  *
 371  * - Too many immovable memory regions
 372  * - ACPI off or no SRAT found
 373  * - No immovable memory region found.
 374  */
 375 int count_immovable_mem_regions(void)
 376 {
 377         unsigned long table_addr, table_end, table;
 378         struct acpi_subtable_header *sub_table;
 379         struct acpi_table_header *table_header;
 380         char arg[MAX_ACPI_ARG_LENGTH];
 381         int num = 0;
 382 
 383         if (cmdline_find_option("acpi", arg, sizeof(arg)) == 3 &&
 384             !strncmp(arg, "off", 3))
 385                 return 0;
 386 
 387         table_addr = get_acpi_srat_table();
 388         if (!table_addr)
 389                 return 0;
 390 
 391         table_header = (struct acpi_table_header *)table_addr;
 392         table_end = table_addr + table_header->length;
 393         table = table_addr + sizeof(struct acpi_table_srat);
 394 
 395         while (table + sizeof(struct acpi_subtable_header) < table_end) {
 396 
 397                 sub_table = (struct acpi_subtable_header *)table;
 398                 if (!sub_table->length) {
 399                         debug_putstr("Invalid zero length SRAT subtable.\n");
 400                         return 0;
 401                 }
 402 
 403                 if (sub_table->type == ACPI_SRAT_TYPE_MEMORY_AFFINITY) {
 404                         struct acpi_srat_mem_affinity *ma;
 405 
 406                         ma = (struct acpi_srat_mem_affinity *)sub_table;
 407                         if (!(ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && ma->length) {
 408                                 immovable_mem[num].start = ma->base_address;
 409                                 immovable_mem[num].size = ma->length;
 410                                 num++;
 411                         }
 412 
 413                         if (num >= MAX_NUMNODES*2) {
 414                                 debug_putstr("Too many immovable memory regions, aborting.\n");
 415                                 return 0;
 416                         }
 417                 }
 418                 table += sub_table->length;
 419         }
 420         return num;
 421 }
 422 #endif /* CONFIG_RANDOMIZE_BASE && CONFIG_MEMORY_HOTREMOVE */