lkml.org 
[lkml]   [2017]   [Aug]   [18]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [RFC PATCH] kaslr: get ACPI SRAT table to avoid movable memory
Hi all,

Here is my POC mail:
https://www.spinics.net/lists/kernel/msg2571811.html

Since no reply, so I made this RFC PATCH.
I ran it in QEMU guest. It can get and print the mem_affinity.
But no physical machine available right now.

If there is something wrong, please let me know.
If someone has a better method to handle the movable memory,
please tell me.

Thanks,
Chao Fan

On Fri, Aug 18, 2017 at 04:58:20PM +0800, Chao Fan wrote:
>KASLR should choose the memory region of immovable node to extract kernel.
>So get ACPI SRAT table and store the memory region of movable node which
>kaslr shold avoid.
>
>Signed-off-by: Chao Fan <fanc.fnst@cn.fujitsu.com>
>---
> arch/x86/boot/compressed/kaslr.c | 231 +++++++++++++++++++++++++++++++++++++++
> arch/x86/boot/compressed/misc.h | 27 +++++
> 2 files changed, 258 insertions(+)
>
>diff --git a/arch/x86/boot/compressed/kaslr.c b/arch/x86/boot/compressed/kaslr.c
>index 7de23bb279ce..3b8c111b8a84 100644
>--- a/arch/x86/boot/compressed/kaslr.c
>+++ b/arch/x86/boot/compressed/kaslr.c
>@@ -45,6 +45,11 @@
> #define STATIC
> #include <linux/decompress/mm.h>
>
>+#include <linux/efi.h>
>+#include <linux/acpi.h>
>+#include <linux/numa.h>
>+#include <asm/efi.h>
>+
> extern unsigned long get_cmd_line_ptr(void);
>
> /* Simplified build-specific string for starting entropy. */
>@@ -94,6 +99,18 @@ static bool memmap_too_large;
> /* Store memory limit specified by "mem=nn[KMG]" or "memmap=nn[KMG]" */
> unsigned long long mem_limit = ULLONG_MAX;
>
>+/* Store the max numbers of acpi tables */
>+#define ACPI_MAX_TABLES 128
>+
>+/* Store the movable memory */
>+static struct {
>+ u64 start;
>+ u64 end;
>+} movable_mem[MAX_NUMNODES*2];
>+
>+/* Store the num of movable mem affinity */
>+static int num_movable_ma;
>+
>
> enum mem_avoid_index {
> MEM_AVOID_ZO_RANGE = 0,
>@@ -257,6 +274,180 @@ static int handle_mem_memmap(void)
> return 0;
> }
>
>+static void handle_movable_node(void)
>+{
>+ struct acpi_table_desc table_descs[ACPI_MAX_TABLES];
>+ struct acpi_table_header *table_header;
>+ struct acpi_srat_mem_affinity *ma;
>+ struct acpi_subtable_header *asth;
>+ acpi_physical_address root_table;
>+ acpi_physical_address acpi_table;
>+ acpi_physical_address rsdp_addr;
>+ struct acpi_table_header *th;
>+ efi_system_table_t *systab;
>+ unsigned long table_size;
>+ unsigned long table_end;
>+ bool use_rsdt = false;
>+ bool acpi_20 = false;
>+ bool efi_64 = false;
>+ void *config_tables;
>+ int size, total_size;
>+ u32 table_entry_size;
>+ struct efi_info *e;
>+ u8 *table_entry;
>+ u32 table_count;
>+ char *args;
>+ char *sig;
>+ u32 len;
>+ int i, j;
>+
>+ args = (char *)get_cmd_line_ptr();
>+ if (!strstr(args, "movable_node"))
>+ return;
>+
>+ e = &boot_params->efi_info;
>+ sig = (char *)&e->efi_loader_signature;
>+
>+ if (!strncmp(sig, EFI64_LOADER_SIGNATURE, 4))
>+ efi_64 = true;
>+ else if (!strncmp(sig, EFI32_LOADER_SIGNATURE, 4))
>+ efi_64 = false;
>+ else {
>+ debug_putstr("Wrong efi loader signature.\n");
>+ return;
>+ }
>+
>+ // Get systab from boot params
>+#ifdef CONFIG_X86_32
>+ if (e->efi_systab_hi || e->efi_memmap_hi) {
>+ debug_putstr("Table located above 4GB, disabling EFI.\n");
>+ return;
>+ }
>+ systab = (efi_system_table_t *)e->efi_systab;
>+#else
>+ systab = (efi_system_table_t *)(e->efi_systab |
>+ ((__u64)e->efi_systab_hi<<32));
>+#endif
>+
>+ // Get efi tables from systab
>+ size = efi_64 ? sizeof(efi_config_table_64_t) :
>+ sizeof(efi_config_table_32_t);
>+ total_size = systab->nr_tables * size;
>+
>+ for (i = 0; i < systab->nr_tables; i++) {
>+ efi_guid_t guid;
>+ unsigned long table;
>+
>+ config_tables = (void *)(systab->tables + size * i);
>+ if (efi_64) {
>+ efi_config_table_64_t *tmp_table;
>+
>+ tmp_table = (efi_config_table_64_t *)config_tables;
>+ guid = tmp_table->guid;
>+ table = tmp_table->table;
>+#ifndef CONFIG_64BIT
>+ if (table >> 32) {
>+ debug_putstr
>+ ("Table located above 4G, disabling EFI.\n");
>+ return -EINVAL;
>+ }
>+#endif
>+ } else {
>+ efi_config_table_32_t *tmp_table;
>+
>+ tmp_table = (efi_config_table_32_t *)config_tables;
>+ guid = tmp_table->guid;
>+ table = tmp_table->table;
>+ }
>+
>+ // Get rsdp from efi tables
>+ if (!(efi_guidcmp(guid, ACPI_TABLE_GUID)) && !acpi_20) {
>+ rsdp_addr = (acpi_physical_address)table;
>+ acpi_20 = false;
>+ } else if (!(efi_guidcmp(guid, ACPI_20_TABLE_GUID))) {
>+ rsdp_addr = (acpi_physical_address)table;
>+ acpi_20 = true;
>+ }
>+ }
>+
>+ // Get rsdt or xsdt from rsdp
>+ if (strstr(args, "acpi=rsdt"))
>+ use_rsdt = true;
>+
>+ if (!(use_rsdt) && (acpi_20) &&
>+ ((((struct acpi_table_rsdp *)rsdp_addr)->revision) > 1)) {
>+ root_table = ((struct acpi_table_rsdp *)
>+ rsdp_addr)->xsdt_physical_address;
>+ table_entry_size = ACPI_XSDT_ENTRY_SIZE;
>+ } else {
>+ root_table = ((struct acpi_table_rsdp *)
>+ rsdp_addr)->rsdt_physical_address;
>+ table_entry_size = ACPI_RSDT_ENTRY_SIZE;
>+ }
>+
>+ // Get acpi root table from rsdt or xsdt
>+ th = (struct acpi_table_header *)root_table;
>+ len = th->length;
>+ table_count = (u32)((len - sizeof(struct acpi_table_header)) /
>+ table_entry_size);
>+ table_entry = ACPI_ADD_PTR(u8, th, sizeof(struct acpi_table_header));
>+
>+ for (i = 0; i < table_count; i++) {
>+ u64 address64;
>+
>+ memset(&table_descs[i], 0, sizeof(struct acpi_table_desc));
>+ if (table_entry_size == ACPI_RSDT_ENTRY_SIZE)
>+ acpi_table = ((acpi_physical_address)
>+ (*ACPI_CAST_PTR(u32, table_entry)));
>+ else {
>+ ACPI_MOVE_64_TO_64(&address64, table_entry);
>+ acpi_table = (acpi_physical_address) address64;
>+ }
>+
>+ if (acpi_table) {
>+ table_descs[i].address = acpi_table;
>+ table_descs[i].length =
>+ sizeof(struct acpi_table_header);
>+ table_descs[i].pointer =
>+ (struct acpi_table_header *)acpi_table;
>+ for (j = 0; j < 4; j++)
>+ table_descs[i].signature.ascii[j] =
>+ ((struct acpi_table_header *)
>+ acpi_table)->signature[j];
>+ }
>+
>+ if (!strncmp(table_descs[i].signature.ascii, "SRAT", 4)) {
>+ table_header = table_descs[i].pointer;
>+ break;
>+ }
>+
>+ table_entry += table_entry_size;
>+ }
>+
>+ // Get acpi srat mem affinity frpm acpi root table
>+ table_size = sizeof(struct acpi_table_srat);
>+ table_end = (unsigned long)table_header + table_header->length;
>+ asth = (struct acpi_subtable_header *)
>+ ((unsigned long)table_header + table_size);
>+ j = 0;
>+
>+ while (((unsigned long)asth) +
>+ sizeof(struct acpi_subtable_header) < table_end) {
>+ if (asth->type == 1) {
>+ ma = (struct acpi_srat_mem_affinity *)asth;
>+ if (ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) {
>+ movable_mem[j].start = ma->base_address;
>+ movable_mem[j].end = ma->base_address +
>+ ma->length - 1;
>+ j++;
>+ }
>+ }
>+ asth = (struct acpi_subtable_header *)
>+ ((unsigned long)asth + asth->length);
>+ }
>+ num_movable_ma = j;
>+}
>+
> /*
> * In theory, KASLR can put the kernel anywhere in the range of [16M, 64T).
> * The mem_avoid array is used to store the ranges that need to be avoided
>@@ -380,6 +571,11 @@ static void mem_avoid_init(unsigned long input, unsigned long input_size,
> /* Mark the memmap regions we need to avoid */
> handle_mem_memmap();
>
>+#ifdef CONFIG_EFI
>+ /* Mark the hotplug SB regions we need choose */
>+ handle_movable_node();
>+#endif
>+
> #ifdef CONFIG_X86_VERBOSE_BOOTUP
> /* Make sure video RAM can be used. */
> add_identity_map(0, PMD_SIZE);
>@@ -481,6 +677,36 @@ static unsigned long slots_fetch_random(void)
> return 0;
> }
>
>+static int check_movable_memory(struct mem_vector *entry)
>+{
>+ int i;
>+ unsigned long long start;
>+ unsigned long long end;
>+
>+ start = entry->start;
>+ end = entry->start + entry->size - 1;
>+
>+ if (num_movable_ma == 0)
>+ return 0;
>+
>+ for (i = 0; i < num_movable_ma; i++) {
>+ if ((start >= movable_mem[i].start) &&
>+ (start <= movable_mem[i].end))
>+ return 1;
>+
>+ if ((end >= movable_mem[i].start) &&
>+ (end <= movable_mem[i].end))
>+ return 1;
>+
>+ if (start > movable_mem[i].end)
>+ continue;
>+
>+ if (end < movable_mem[i].start)
>+ break;
>+ }
>+ return 0;
>+}
>+
> static void process_mem_region(struct mem_vector *entry,
> unsigned long minimum,
> unsigned long image_size)
>@@ -502,6 +728,11 @@ static void process_mem_region(struct mem_vector *entry,
> end = min(entry->size + entry->start, mem_limit);
> if (entry->start >= end)
> return;
>+
>+ /* Ignore the memory region of movable_node */
>+ if (check_movable_memory(entry))
>+ return;
>+
> cur_entry.start = entry->start;
> cur_entry.size = end - entry->start;
>
>diff --git a/arch/x86/boot/compressed/misc.h b/arch/x86/boot/compressed/misc.h
>index 766a5211f827..5f514959b2f1 100644
>--- a/arch/x86/boot/compressed/misc.h
>+++ b/arch/x86/boot/compressed/misc.h
>@@ -109,3 +109,30 @@ static inline void console_init(void)
> #endif
>
> #endif
>+
>+#ifdef ACPI_BIG_ENDIAN
>+#define ACPI_MOVE_64_TO_64(d, s) \
>+{((u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[7]; \
>+((u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[6]; \
>+((u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[5]; \
>+((u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[4]; \
>+((u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[3]; \
>+((u8 *)(void *)(d))[5] = ((u8 *)(void *)(s))[2]; \
>+((u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1]; \
>+((u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0]; }
>+#else
>+#ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED
>+#define ACPI_MOVE_64_TO_64(d, s) \
>+{*(u64 *)(void *)(d) = *(u64 *)(void *)(s)}
>+#else
>+#define ACPI_MOVE_64_TO_64(d, s) \
>+{((u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[0]; \
>+((u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[1]; \
>+((u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[2]; \
>+((u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[3]; \
>+((u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[4]; \
>+((u8 *)(void *)(d))[5] = ((u8 *)(void *)(s))[5]; \
>+((u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[6]; \
>+((u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[7]; }
>+#endif
>+#endif
>--
>2.13.4
>


\
 
 \ /
  Last update: 2017-08-18 11:36    [W:0.046 / U:8.992 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site