Skip to contentSkip to conversation

Handle memmap and mem kernel options in boot stage kaslr

PATCH Superseded Baoquan He 4 participants 10 messages May 9, 2017 – May 12, 2017

Subsystems (2)

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Baoquan He

author
#0 lore raw

v4 cover Handle memmap and mem kernel options in boot stage kaslr

People reported kernel panic occurs during system boots up with mem boot option. After checking code, several problems are found about memmap= and mem= in boot stage kaslr.

*) In commit f28442497b5c ("x86/boot: Fix KASLR and memmap= collision"), only one memmap
entry is considered and only the last one if multiple memmap entries are specified.

*) mem= and memmap=nn[KMG] are not considered yet. They are used to limit max address
of system. Kernel can't be randomized to be above the limit.

*) kernel-parameters.txt doesn't tell the updated behaviour of memmap=.

This patchset tries to solve above issues, and it sits on top of tip:x86/boot branch.

Changelog

v3->v4:
*Code improved patch 1/3 according to Kees's suggestion.

*Add 'Fall through' in switch case of parse_memmap() which
is suggestd by Kees.

v2->v3:
No functionality change in this round.
*Use local static variable insted of global variable
mem_avoid_memmap_index in patch 1/3.

*Fix a typo in patch 3/3.

v1->v2:
*The original patch 1/4 has been put in tip:x86/boot and no update,
so it's not included in this post.

*Use patch log Ingo reorganized.

*lib/ctype.c and lib/cmdline.c are needed for kaslr.c, while those
EXPORT_SYMBOL(x) contained caused failure of build on 32-bit allmodconfig:
......
ld: -r and -shared may not be used together
scripts/Makefile.build:294: recipe for target 'arch/x86/boot/compressed/kaslr.o' failed
......
Disabling the symbol exporting removes the build failure.

*Use dynamic allocation to allocate memory to contain copied kernel cmdline
buffer, it's implemented in include/linux/decompress/mm.h.

Baoquan He (3):
KASLR: Parse all memmap entries in cmdline
KASLR: Handle memory limit specified by memmap and mem option Documentation/kernel-parameters.txt: Update 'memmap=' option
description

 Documentation/admin-guide/kernel-parameters.txt |   9 ++
 arch/x86/boot/compressed/cmdline.c              |   2 +-
 arch/x86/boot/compressed/kaslr.c                | 191 ++++++++++++++++--------
 arch/x86/boot/string.c                          |   8 +
 4 files changed, 144 insertions(+), 66 deletions(-)
Signature · 1 line
2.5.5
author
#1 lore raw

PATCH v4 1/3 KASLR: Parse all memmap entries in cmdline

In commit:

f28442497b5c ("x86/boot: Fix KASLR and memmap= collision")

... the memmap= option is parsed so that KASLR can avoid those reserved regions. It uses cmdline_find_option() to get the value if memmap= is specified, however the problem is that cmdline_find_option() can only find the last entry if multiple memmap entries are provided. This is not correct.

In this patch, the whole cmdline will be scanned to search each memmap, all of them will be parsed and handled.

---
 arch/x86/boot/compressed/cmdline.c |   2 +-
 arch/x86/boot/compressed/kaslr.c   | 136 ++++++++++++++++++++++---------------
 arch/x86/boot/string.c             |   8 +++
 3 files changed, 91 insertions(+), 55 deletions(-)
arch/x86/boot/compressed/cmdline.c +1 -1
index 73ccf63..9dc1ce6 100644
@@ -13,7 +13,7 @@ static inline char rdfs8(addr_t addr)
 	return *((char *)(fs + addr));
 }
 #include "../cmdline.c"
-static unsigned long get_cmd_line_ptr(void)
+unsigned long get_cmd_line_ptr(void)
 {
 	unsigned long cmd_line_ptr = boot_params->hdr.cmd_line_ptr;
 
arch/x86/boot/compressed/kaslr.c +82 -54

200 lines not on this page · raw message

arch/x86/boot/string.c +8 -0
index 5457b02..630e366 100644
@@ -122,6 +122,14 @@ unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int bas
 	return result;
 }
 
+long simple_strtol(const char *cp, char **endp, unsigned int base)
+{
+	if (*cp == '-')
+		return -simple_strtoull(cp + 1, endp, base);
+
+	return simple_strtoull(cp, endp, base);
+}
+
 /**
  * strlen - Find the length of a string
  * @s: The string to be sized
Signature · 1 line
2.5.5
#2 lore raw

Re: [PATCH v4 1/3] KASLR: Parse all memmap entries in cmdline

Quoted 11 lines · Baoquan He

In commit:

f28442497b5c ("x86/boot: Fix KASLR and memmap= collision")

... the memmap= option is parsed so that KASLR can avoid those reserved regions. It uses cmdline_find_option() to get the value if memmap= is specified, however the problem is that cmdline_find_option() can only find the last entry if multiple memmap entries are provided. This is not correct.

In this patch, the whole cmdline will be scanned to search each

Can you please finally stop using this 'This patch does foo', 'In this patch' phrases. They are bogus. We already know that this is a patch otherwise you wouldn't have sent it.

See Documentation/process/SubmittingPatches.txt

Aside of that can you please use properly written out words instead of using random abbreviations in the changelog, e.g. command line instead of cmdline?

Quoted 1 line

memmap, all of them will be parsed and handled.

A proper example would be:

Address this by checking each command line token for a "memmap=" match and parse each instance instead of using cmdline_find_option().

Thanks,

tglx

author
#3 lore raw

Re: [PATCH v4 1/3] KASLR: Parse all memmap entries in cmdline

Quoted 24 lines · Thomas Gleixner
Quoted 11 lines · Baoquan He

In commit:

f28442497b5c ("x86/boot: Fix KASLR and memmap= collision")

... the memmap= option is parsed so that KASLR can avoid those reserved regions. It uses cmdline_find_option() to get the value if memmap= is specified, however the problem is that cmdline_find_option() can only find the last entry if multiple memmap entries are provided. This is not correct.

In this patch, the whole cmdline will be scanned to search each

Can you please finally stop using this 'This patch does foo', 'In this patch' phrases. They are bogus. We already know that this is a patch otherwise you wouldn't have sent it.

See Documentation/process/SubmittingPatches.txt

Aside of that can you please use properly written out words instead of using random abbreviations in the changelog, e.g. command line instead of cmdline?

Quoted 6 lines
Quoted 1 line

memmap, all of them will be parsed and handled.

A proper example would be:

Address this by checking each command line token for a "memmap=" match and parse each instance instead of using cmdline_find_option().

Sorry for those mistakes. Will change accordingly when repost.

Thanks
Baoquan

author
#4 lore raw

PATCH v4 2/3 KASLR: Handle memory limit specified by memmap and mem option

In reply to Baoquan He

Option mem= will limit the max address a system can use and any memory region above the limit will be removed.

Furthermore, memmap=nn[KMG] which has no offset specified has the same behaviour as mem=.

KASLR needs to consider this when choosing the random position for decompressing the kernel.

This patch implements that.

---
 arch/x86/boot/compressed/kaslr.c | 69 +++++++++++++++++++++++++++++-----------
 1 file changed, 51 insertions(+), 18 deletions(-)
arch/x86/boot/compressed/kaslr.c +51 -18
index 106e13b..0637e85 100644
@@ -88,6 +88,10 @@ struct mem_vector {
 static bool memmap_too_large;
 
 
+/* Store memory limit specified by "mem=nn[KMG]" or "memmap=nn[KMG]" */
+unsigned long long mem_limit = ULLONG_MAX;
+
+
 enum mem_avoid_index {
 	MEM_AVOID_ZO_RANGE = 0,
 	MEM_AVOID_INITRD,
@@ -138,16 +142,24 @@ parse_memmap(char *p, unsigned long long *start, unsigned long long *size)
 		return -EINVAL;
 
 	switch (*p) {
-	case '@':
-		/* Skip this region, usable */
-		*start = 0;
-		*size = 0;
-		return 0;
 	case '#':
 	case '$':
 	case '!':
 		*start = memparse(p + 1, &p);
 		return 0;
+	case '@':	/* Fall through: */
+		/*
+		 * memmap=nn@ss specifies usable region, should be skipped
+		 */
+		*size = 0;
+	default:
+		/*
+		 * If w/o offset, only size specified, memmap=nn[KMG] has the
+		 * same behaviour as mem=nn[KMG]. It limits the max address
+		 * system can use. Region above the limit should be avoided.
+		 */
+		*start = 0;
+		return 0;
 	}
 
 	return -EINVAL;
@@ -173,9 +185,14 @@ static void mem_avoid_memmap(char *str)
 		if (rc < 0)
 			break;
 		str = k;
-		/* A usable region that should not be skipped */
-		if (size == 0)
+
+		if (start == 0) {
+			/* Store the specified memory limit if size > 0 */
+			if (size > 0)
+				mem_limit = size;
+
 			continue;
+		}
 
 		mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].start = start;
 		mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
@@ -187,19 +204,15 @@ static void mem_avoid_memmap(char *str)
 		memmap_too_large = true;
 }
 
-
-/*
- * handle_mem_memmap will also cover 'mem=' issue in next patch. Will remove
- * this note later.
- */
 static int handle_mem_memmap(void)
 {
 	char *args = (char *)get_cmd_line_ptr();
 	size_t len = strlen((char *)args);
 	char *tmp_cmdline;
 	char *param, *val;
+	u64 mem_size;
 
-	if (!strstr(args, "memmap="))
+	if (!strstr(args, "memmap=") && !strstr(args, "mem="))
 		return 0;
 
 	tmp_cmdline = malloc(len + 1);
@@ -222,8 +235,20 @@ static int handle_mem_memmap(void)
 			return -1;
 		}
 
-		if (!strcmp(param, "memmap"))
+		if (!strcmp(param, "memmap")) {
 			mem_avoid_memmap(val);
+		} else if (!strcmp(param, "mem")) {
+			char *p = val;
+
+			if (!strcmp(p, "nopentium"))
+				continue;
+			mem_size = memparse(p, &p);
+			if (mem_size == 0) {
+				free(tmp_cmdline);
+				return -EINVAL;
+			}
+			mem_limit = mem_size;
+		}
 	}
 
 	free(tmp_cmdline);
@@ -460,7 +485,8 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 {
 	struct mem_vector region, overlap;
 	struct slot_area slot_area;
-	unsigned long start_orig;
+	unsigned long start_orig, end;
+	struct boot_e820_entry cur_entry;
 
 	/* Skip non-RAM entries. */
 	if (entry->type != E820_TYPE_RAM)
@@ -474,8 +500,15 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 	if (entry->addr + entry->size < minimum)
 		return;
 
-	region.start = entry->addr;
-	region.size = entry->size;
+	/* Ignore entries above memory limit */
+	end = min(entry->size + entry->addr, mem_limit);
+	if (entry->addr >= end)
+		return;
+	cur_entry.addr = entry->addr;
+	cur_entry.size = end - entry->addr;
+
+	region.start = cur_entry.addr;
+	region.size = cur_entry.size;
 
 	/* Give up if slot area array is full. */
 	while (slot_area_index < MAX_SLOT_AREA) {
@@ -489,7 +522,7 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 		region.start = ALIGN(region.start, CONFIG_PHYSICAL_ALIGN);
 
 		/* Did we raise the address above this e820 region? */
-		if (region.start > entry->addr + entry->size)
+		if (region.start > cur_entry.addr + cur_entry.size)
 			return;
 
 		/* Reduce size by any delta from the original address. */
Signature · 1 line
2.5.5
#5 lore raw

Re: [PATCH v4 2/3] KASLR: Handle memory limit specified by memmap and mem option

Quoted 40 lines · Baoquan He

Option mem= will limit the max address a system can use and any memory region above the limit will be removed.

Furthermore, memmap=nn[KMG] which has no offset specified has the same behaviour as mem=.

KASLR needs to consider this when choosing the random position for decompressing the kernel.

This patch implements that.

---
 arch/x86/boot/compressed/kaslr.c | 69 +++++++++++++++++++++++++++++-----------
 1 file changed, 51 insertions(+), 18 deletions(-)
arch/x86/boot/compressed/kaslr.c +4 -5
index 106e13b..0637e85 100644
@@ -88,6 +88,10 @@ struct mem_vector {
 static bool memmap_too_large;
 
 
+/* Store memory limit specified by "mem=nn[KMG]" or "memmap=nn[KMG]" */
+unsigned long long mem_limit = ULLONG_MAX;
+
+
 enum mem_avoid_index {
        MEM_AVOID_ZO_RANGE = 0,
        MEM_AVOID_INITRD,
@@ -138,16 +142,24 @@ parse_memmap(char *p, unsigned long long *start, unsigned long long *size)
                return -EINVAL;
 
        switch (*p) {
-       case '@':
-               /* Skip this region, usable */
-               *start = 0;
-               *size = 0;
-               return 0;

arch/x86/boot/compressed/kaslr.c parse_memmap(char *p, unsigned long long *start, unsigned long long *size) · line 154

Quoted 10 lines
arch/x86/boot/compressed/kaslr.c +5 -0
        case '#':
        case '$':
        case '!':
                *start = memparse(p + 1, &p);
                return 0;
+       case '@':       /* Fall through: */
+               /*
+                * memmap=nn@ss specifies usable region, should be skipped
+                */
+               *size = 0;

The "fall through" comment should go here (where the break is "missing").

Quoted 110 lines
arch/x86/boot/compressed/kaslr.c +42 -14
+       default:
+               /*
+                * If w/o offset, only size specified, memmap=nn[KMG] has the
+                * same behaviour as mem=nn[KMG]. It limits the max address
+                * system can use. Region above the limit should be avoided.
+                */
+               *start = 0;
+               return 0;
        }
 
        return -EINVAL;
@@ -173,9 +185,14 @@ static void mem_avoid_memmap(char *str)
                if (rc < 0)
                        break;
                str = k;
-               /* A usable region that should not be skipped */
-               if (size == 0)
+
+               if (start == 0) {
+                       /* Store the specified memory limit if size > 0 */
+                       if (size > 0)
+                               mem_limit = size;
+
                        continue;
+               }
 
                mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].start = start;
                mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
@@ -187,19 +204,15 @@ static void mem_avoid_memmap(char *str)
                memmap_too_large = true;
 }
 
-
-/*
- * handle_mem_memmap will also cover 'mem=' issue in next patch. Will remove
- * this note later.
- */
 static int handle_mem_memmap(void)
 {
        char *args = (char *)get_cmd_line_ptr();
        size_t len = strlen((char *)args);
        char *tmp_cmdline;
        char *param, *val;
+       u64 mem_size;
 
-       if (!strstr(args, "memmap="))
+       if (!strstr(args, "memmap=") && !strstr(args, "mem="))
                return 0;
 
        tmp_cmdline = malloc(len + 1);
@@ -222,8 +235,20 @@ static int handle_mem_memmap(void)
                        return -1;
                }
 
-               if (!strcmp(param, "memmap"))
+               if (!strcmp(param, "memmap")) {
                        mem_avoid_memmap(val);
+               } else if (!strcmp(param, "mem")) {
+                       char *p = val;
+
+                       if (!strcmp(p, "nopentium"))
+                               continue;
+                       mem_size = memparse(p, &p);
+                       if (mem_size == 0) {
+                               free(tmp_cmdline);
+                               return -EINVAL;
+                       }
+                       mem_limit = mem_size;
+               }
        }
 
        free(tmp_cmdline);
@@ -460,7 +485,8 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 {
        struct mem_vector region, overlap;
        struct slot_area slot_area;
-       unsigned long start_orig;
+       unsigned long start_orig, end;
+       struct boot_e820_entry cur_entry;
 
        /* Skip non-RAM entries. */
        if (entry->type != E820_TYPE_RAM)
@@ -474,8 +500,15 @@ static void process_e820_entry(struct boot_e820_entry *entry,
        if (entry->addr + entry->size < minimum)
                return;
 
-       region.start = entry->addr;
-       region.size = entry->size;
+       /* Ignore entries above memory limit */
+       end = min(entry->size + entry->addr, mem_limit);
+       if (entry->addr >= end)
+               return;
+       cur_entry.addr = entry->addr;
+       cur_entry.size = end - entry->addr;
+
+       region.start = cur_entry.addr;
+       region.size = cur_entry.size;
 
        /* Give up if slot area array is full. */
        while (slot_area_index < MAX_SLOT_AREA) {
@@ -489,7 +522,7 @@ static void process_e820_entry(struct boot_e820_entry *entry,
                region.start = ALIGN(region.start, CONFIG_PHYSICAL_ALIGN);
 
                /* Did we raise the address above this e820 region? */
-               if (region.start > entry->addr + entry->size)
+               if (region.start > cur_entry.addr + cur_entry.size)
                        return;
 
                /* Reduce size by any delta from the original address. */
--
Quoted 2 lines

2.5.5

Otherwise looks fine to me!

-Kees

Signature · 2 lines
Kees Cook
Pixel Security
author
#6 lore raw

Re: [PATCH v4 2/3] KASLR: Handle memory limit specified by memmap and mem option

Quoted 45 lines · Kees Cook
Quoted 44 lines · Baoquan He

Option mem= will limit the max address a system can use and any memory region above the limit will be removed.

Furthermore, memmap=nn[KMG] which has no offset specified has the same behaviour as mem=.

KASLR needs to consider this when choosing the random position for decompressing the kernel.

This patch implements that.

---
 arch/x86/boot/compressed/kaslr.c | 69 +++++++++++++++++++++++++++++-----------
 1 file changed, 51 insertions(+), 18 deletions(-)
arch/x86/boot/compressed/kaslr.c +4 -5
index 106e13b..0637e85 100644
@@ -88,6 +88,10 @@ struct mem_vector {
 static bool memmap_too_large;
 
 
+/* Store memory limit specified by "mem=nn[KMG]" or "memmap=nn[KMG]" */
+unsigned long long mem_limit = ULLONG_MAX;
+
+
 enum mem_avoid_index {
        MEM_AVOID_ZO_RANGE = 0,
        MEM_AVOID_INITRD,
@@ -138,16 +142,24 @@ parse_memmap(char *p, unsigned long long *start, unsigned long long *size)
                return -EINVAL;
 
        switch (*p) {
-       case '@':
-               /* Skip this region, usable */
-               *start = 0;
-               *size = 0;
-               return 0;
        case '#':
        case '$':
        case '!':
                *start = memparse(p + 1, &p);
Quoted 8 lines

arch/x86/boot/compressed/kaslr.c parse_memmap(char *p, unsigned long long *start, unsigned long long *size) · line 154

Quoted 6 lines
arch/x86/boot/compressed/kaslr.c +5 -0
                return 0;
+       case '@':       /* Fall through: */
+               /*
+                * memmap=nn@ss specifies usable region, should be skipped
+                */
+               *size = 0;

The "fall through" comment should go here (where the break is "missing").

Ah, OK, will change and repost after patch 1/3 reviewing. Thanks a lot!

Quoted 121 lines
Quoted 111 lines
arch/x86/boot/compressed/kaslr.c +42 -14
+       default:
+               /*
+                * If w/o offset, only size specified, memmap=nn[KMG] has the
+                * same behaviour as mem=nn[KMG]. It limits the max address
+                * system can use. Region above the limit should be avoided.
+                */
+               *start = 0;
+               return 0;
        }
 
        return -EINVAL;
@@ -173,9 +185,14 @@ static void mem_avoid_memmap(char *str)
                if (rc < 0)
                        break;
                str = k;
-               /* A usable region that should not be skipped */
-               if (size == 0)
+
+               if (start == 0) {
+                       /* Store the specified memory limit if size > 0 */
+                       if (size > 0)
+                               mem_limit = size;
+
                        continue;
+               }
 
                mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].start = start;
                mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
@@ -187,19 +204,15 @@ static void mem_avoid_memmap(char *str)
                memmap_too_large = true;
 }
 
-
-/*
- * handle_mem_memmap will also cover 'mem=' issue in next patch. Will remove
- * this note later.
- */
 static int handle_mem_memmap(void)
 {
        char *args = (char *)get_cmd_line_ptr();
        size_t len = strlen((char *)args);
        char *tmp_cmdline;
        char *param, *val;
+       u64 mem_size;
 
-       if (!strstr(args, "memmap="))
+       if (!strstr(args, "memmap=") && !strstr(args, "mem="))
                return 0;
 
        tmp_cmdline = malloc(len + 1);
@@ -222,8 +235,20 @@ static int handle_mem_memmap(void)
                        return -1;
                }
 
-               if (!strcmp(param, "memmap"))
+               if (!strcmp(param, "memmap")) {
                        mem_avoid_memmap(val);
+               } else if (!strcmp(param, "mem")) {
+                       char *p = val;
+
+                       if (!strcmp(p, "nopentium"))
+                               continue;
+                       mem_size = memparse(p, &p);
+                       if (mem_size == 0) {
+                               free(tmp_cmdline);
+                               return -EINVAL;
+                       }
+                       mem_limit = mem_size;
+               }
        }
 
        free(tmp_cmdline);
@@ -460,7 +485,8 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 {
        struct mem_vector region, overlap;
        struct slot_area slot_area;
-       unsigned long start_orig;
+       unsigned long start_orig, end;
+       struct boot_e820_entry cur_entry;
 
        /* Skip non-RAM entries. */
        if (entry->type != E820_TYPE_RAM)
@@ -474,8 +500,15 @@ static void process_e820_entry(struct boot_e820_entry *entry,
        if (entry->addr + entry->size < minimum)
                return;
 
-       region.start = entry->addr;
-       region.size = entry->size;
+       /* Ignore entries above memory limit */
+       end = min(entry->size + entry->addr, mem_limit);
+       if (entry->addr >= end)
+               return;
+       cur_entry.addr = entry->addr;
+       cur_entry.size = end - entry->addr;
+
+       region.start = cur_entry.addr;
+       region.size = cur_entry.size;
 
        /* Give up if slot area array is full. */
        while (slot_area_index < MAX_SLOT_AREA) {
@@ -489,7 +522,7 @@ static void process_e820_entry(struct boot_e820_entry *entry,
                region.start = ALIGN(region.start, CONFIG_PHYSICAL_ALIGN);
 
                /* Did we raise the address above this e820 region? */
-               if (region.start > entry->addr + entry->size)
+               if (region.start > cur_entry.addr + cur_entry.size)
                        return;
 
                /* Reduce size by any delta from the original address. */
--
Quoted 2 lines

2.5.5

Otherwise looks fine to me!

-Kees

Signature · 2 lines
Kees Cook
Pixel Security
Tested-by on v4 2/3
#7 lore raw

Re: [PATCH v4 2/3] KASLR: Handle memory limit specified by memmap and mem option

In reply to Baoquan He

Hi Baoquan,

Thank you for fixing!
I confirmed that the kernel is located within mem= address.

Regards,
Masayoshi Mizuma

Quoted 162 lines · On Tue, 9 May 2017 13:57:51 +0800 Baoquan He wrote:

Option mem= will limit the max address a system can use and any memory region above the limit will be removed.

Furthermore, memmap=nn[KMG] which has no offset specified has the same behaviour as mem=.

KASLR needs to consider this when choosing the random position for decompressing the kernel.

This patch implements that.

---
 arch/x86/boot/compressed/kaslr.c | 69 +++++++++++++++++++++++++++++-----------
 1 file changed, 51 insertions(+), 18 deletions(-)
arch/x86/boot/compressed/kaslr.c +51 -18
index 106e13b..0637e85 100644
@@ -88,6 +88,10 @@ struct mem_vector {
 static bool memmap_too_large;
 
 
+/* Store memory limit specified by "mem=nn[KMG]" or "memmap=nn[KMG]" */
+unsigned long long mem_limit = ULLONG_MAX;
+
+
 enum mem_avoid_index {
 	MEM_AVOID_ZO_RANGE = 0,
 	MEM_AVOID_INITRD,
@@ -138,16 +142,24 @@ parse_memmap(char *p, unsigned long long *start, unsigned long long *size)
 		return -EINVAL;
 
 	switch (*p) {
-	case '@':
-		/* Skip this region, usable */
-		*start = 0;
-		*size = 0;
-		return 0;
 	case '#':
 	case '$':
 	case '!':
 		*start = memparse(p + 1, &p);
 		return 0;
+	case '@':	/* Fall through: */
+		/*
+		 * memmap=nn@ss specifies usable region, should be skipped
+		 */
+		*size = 0;
+	default:
+		/*
+		 * If w/o offset, only size specified, memmap=nn[KMG] has the
+		 * same behaviour as mem=nn[KMG]. It limits the max address
+		 * system can use. Region above the limit should be avoided.
+		 */
+		*start = 0;
+		return 0;
 	}
 
 	return -EINVAL;
@@ -173,9 +185,14 @@ static void mem_avoid_memmap(char *str)
 		if (rc < 0)
 			break;
 		str = k;
-		/* A usable region that should not be skipped */
-		if (size == 0)
+
+		if (start == 0) {
+			/* Store the specified memory limit if size > 0 */
+			if (size > 0)
+				mem_limit = size;
+
 			continue;
+		}
 
 		mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].start = start;
 		mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
@@ -187,19 +204,15 @@ static void mem_avoid_memmap(char *str)
 		memmap_too_large = true;
 }
 
-
-/*
- * handle_mem_memmap will also cover 'mem=' issue in next patch. Will remove
- * this note later.
- */
 static int handle_mem_memmap(void)
 {
 	char *args = (char *)get_cmd_line_ptr();
 	size_t len = strlen((char *)args);
 	char *tmp_cmdline;
 	char *param, *val;
+	u64 mem_size;
 
-	if (!strstr(args, "memmap="))
+	if (!strstr(args, "memmap=") && !strstr(args, "mem="))
 		return 0;
 
 	tmp_cmdline = malloc(len + 1);
@@ -222,8 +235,20 @@ static int handle_mem_memmap(void)
 			return -1;
 		}
 
-		if (!strcmp(param, "memmap"))
+		if (!strcmp(param, "memmap")) {
 			mem_avoid_memmap(val);
+		} else if (!strcmp(param, "mem")) {
+			char *p = val;
+
+			if (!strcmp(p, "nopentium"))
+				continue;
+			mem_size = memparse(p, &p);
+			if (mem_size == 0) {
+				free(tmp_cmdline);
+				return -EINVAL;
+			}
+			mem_limit = mem_size;
+		}
 	}
 
 	free(tmp_cmdline);
@@ -460,7 +485,8 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 {
 	struct mem_vector region, overlap;
 	struct slot_area slot_area;
-	unsigned long start_orig;
+	unsigned long start_orig, end;
+	struct boot_e820_entry cur_entry;
 
 	/* Skip non-RAM entries. */
 	if (entry->type != E820_TYPE_RAM)
@@ -474,8 +500,15 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 	if (entry->addr + entry->size < minimum)
 		return;
 
-	region.start = entry->addr;
-	region.size = entry->size;
+	/* Ignore entries above memory limit */
+	end = min(entry->size + entry->addr, mem_limit);
+	if (entry->addr >= end)
+		return;
+	cur_entry.addr = entry->addr;
+	cur_entry.size = end - entry->addr;
+
+	region.start = cur_entry.addr;
+	region.size = cur_entry.size;
 
 	/* Give up if slot area array is full. */
 	while (slot_area_index < MAX_SLOT_AREA) {
@@ -489,7 +522,7 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 		region.start = ALIGN(region.start, CONFIG_PHYSICAL_ALIGN);
 
 		/* Did we raise the address above this e820 region? */
-		if (region.start > entry->addr + entry->size)
+		if (region.start > cur_entry.addr + cur_entry.size)
 			return;
 
 		/* Reduce size by any delta from the original address. */
Signature · 1 line
2.5.5
author
#8 lore raw

Re: [PATCH v4 2/3] KASLR: Handle memory limit specified by memmap and mem option

Quoted 6 lines · Masayoshi Mizuma

Hi Baoquan,

Thank you for fixing!
I confirmed that the kernel is located within mem= address.

Thanks for your testing!

I will post v5 according to comments from Thomas and Kees. Since no functionality code change, will add your Tested-by.

Thanks
Baoquan

Quoted 166 lines · On Tue, 9 May 2017 13:57:51 +0800 Baoquan He wrote:
Quoted 163 lines

Option mem= will limit the max address a system can use and any memory region above the limit will be removed.

Furthermore, memmap=nn[KMG] which has no offset specified has the same behaviour as mem=.

KASLR needs to consider this when choosing the random position for decompressing the kernel.

This patch implements that.

---
 arch/x86/boot/compressed/kaslr.c | 69 +++++++++++++++++++++++++++++-----------
 1 file changed, 51 insertions(+), 18 deletions(-)
arch/x86/boot/compressed/kaslr.c +51 -18
index 106e13b..0637e85 100644
@@ -88,6 +88,10 @@ struct mem_vector {
 static bool memmap_too_large;
 
 
+/* Store memory limit specified by "mem=nn[KMG]" or "memmap=nn[KMG]" */
+unsigned long long mem_limit = ULLONG_MAX;
+
+
 enum mem_avoid_index {
 	MEM_AVOID_ZO_RANGE = 0,
 	MEM_AVOID_INITRD,
@@ -138,16 +142,24 @@ parse_memmap(char *p, unsigned long long *start, unsigned long long *size)
 		return -EINVAL;
 
 	switch (*p) {
-	case '@':
-		/* Skip this region, usable */
-		*start = 0;
-		*size = 0;
-		return 0;
 	case '#':
 	case '$':
 	case '!':
 		*start = memparse(p + 1, &p);
 		return 0;
+	case '@':	/* Fall through: */
+		/*
+		 * memmap=nn@ss specifies usable region, should be skipped
+		 */
+		*size = 0;
+	default:
+		/*
+		 * If w/o offset, only size specified, memmap=nn[KMG] has the
+		 * same behaviour as mem=nn[KMG]. It limits the max address
+		 * system can use. Region above the limit should be avoided.
+		 */
+		*start = 0;
+		return 0;
 	}
 
 	return -EINVAL;
@@ -173,9 +185,14 @@ static void mem_avoid_memmap(char *str)
 		if (rc < 0)
 			break;
 		str = k;
-		/* A usable region that should not be skipped */
-		if (size == 0)
+
+		if (start == 0) {
+			/* Store the specified memory limit if size > 0 */
+			if (size > 0)
+				mem_limit = size;
+
 			continue;
+		}
 
 		mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].start = start;
 		mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
@@ -187,19 +204,15 @@ static void mem_avoid_memmap(char *str)
 		memmap_too_large = true;
 }
 
-
-/*
- * handle_mem_memmap will also cover 'mem=' issue in next patch. Will remove
- * this note later.
- */
 static int handle_mem_memmap(void)
 {
 	char *args = (char *)get_cmd_line_ptr();
 	size_t len = strlen((char *)args);
 	char *tmp_cmdline;
 	char *param, *val;
+	u64 mem_size;
 
-	if (!strstr(args, "memmap="))
+	if (!strstr(args, "memmap=") && !strstr(args, "mem="))
 		return 0;
 
 	tmp_cmdline = malloc(len + 1);
@@ -222,8 +235,20 @@ static int handle_mem_memmap(void)
 			return -1;
 		}
 
-		if (!strcmp(param, "memmap"))
+		if (!strcmp(param, "memmap")) {
 			mem_avoid_memmap(val);
+		} else if (!strcmp(param, "mem")) {
+			char *p = val;
+
+			if (!strcmp(p, "nopentium"))
+				continue;
+			mem_size = memparse(p, &p);
+			if (mem_size == 0) {
+				free(tmp_cmdline);
+				return -EINVAL;
+			}
+			mem_limit = mem_size;
+		}
 	}
 
 	free(tmp_cmdline);
@@ -460,7 +485,8 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 {
 	struct mem_vector region, overlap;
 	struct slot_area slot_area;
-	unsigned long start_orig;
+	unsigned long start_orig, end;
+	struct boot_e820_entry cur_entry;
 
 	/* Skip non-RAM entries. */
 	if (entry->type != E820_TYPE_RAM)
@@ -474,8 +500,15 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 	if (entry->addr + entry->size < minimum)
 		return;
 
-	region.start = entry->addr;
-	region.size = entry->size;
+	/* Ignore entries above memory limit */
+	end = min(entry->size + entry->addr, mem_limit);
+	if (entry->addr >= end)
+		return;
+	cur_entry.addr = entry->addr;
+	cur_entry.size = end - entry->addr;
+
+	region.start = cur_entry.addr;
+	region.size = cur_entry.size;
 
 	/* Give up if slot area array is full. */
 	while (slot_area_index < MAX_SLOT_AREA) {
@@ -489,7 +522,7 @@ static void process_e820_entry(struct boot_e820_entry *entry,
 		region.start = ALIGN(region.start, CONFIG_PHYSICAL_ALIGN);
 
 		/* Did we raise the address above this e820 region? */
-		if (region.start > entry->addr + entry->size)
+		if (region.start > cur_entry.addr + cur_entry.size)
 			return;
 
 		/* Reduce size by any delta from the original address. */
Signature · 1 line
2.5.5
author
#9 lore raw

PATCH v4 3/3 Documentation/kernel-parameters.txt: Update 'memmap=' option description

In reply to Baoquan He

In commit:

9710f581bb4c ("x86, mm: Let "memmap=" take more entries one time")

... 'memmap=' was changed to adopt multiple, comma delimited values in a single entry, so update the related description.

In the special case of only specifying size value without an offset, like memmap=nn[KMG], memmap behaves similarly to mem=nn[KMG], so update it too here.

Furthermore, for memmap=nn[KMG]$ss[KMG], an escape character needs be added before '$' for some bootloaders. E.g in grub2, if we specify memmap=100M$5G as suggested by the documentation, "memmap=100MG" gets passed to the kernel.

Clarify all this.

---
 Documentation/admin-guide/kernel-parameters.txt | 9 +++++++++
 1 file changed, 9 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +9 -0
index e4c9e0e..8d37f26 100644
@@ -2112,6 +2112,12 @@
 	memmap=nn[KMG]@ss[KMG]
 			[KNL] Force usage of a specific region of memory.
 			Region of memory to be used is from ss to ss+nn.
+			If @ss[KMG] is omitted, it equals to mem=nn[KMG]
+			which limits max address as nn[KMG].
+			Multiple different options can be put into one entry
+			with comma delimited to save space:
+			Example:
+				memmap=100M@2G,100M#3G,1G!1024G
 
 	memmap=nn[KMG]#ss[KMG]
 			[KNL,ACPI] Mark specific memory as ACPI data.
@@ -2124,6 +2130,9 @@
 			         memmap=64K$0x18690000
 			         or
 			         memmap=0x10000$0x18690000
+			Some bootloaders may need escape character before '$',
+			like in grub2, otherwise '$' and the following number
+			will be eaten.
 
 	memmap=nn[KMG]!ss[KMG]
 			[KNL,X86] Mark specific memory as protected.
Signature · 1 line
2.5.5