Skip to contentSkip to conversation

Handle memmap and mem kernel options in boot stage kaslr

PATCH Superseded Baoquan He 4 participants 14 messages Apr 24, 2017

Subsystems (2)

v2 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Baoquan He

author
#0 lore raw

v2 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.

Changelog:
v1->v2

a)
The original patch 1/4 has been put in tip:x86/boot and no update, so it's not included in this post.

b)
Use patch log Ingo reorganized.

c)
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.

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

e)
This patchset sits on top of tip:x86/boot branch.

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                | 185 +++++++++++++++---------
 arch/x86/boot/string.c                          |   8 +
 4 files changed, 138 insertions(+), 66 deletions(-)
Signature · 1 line
2.5.5
author
#1 lore raw

PATCH v2 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.

Cc "H. Peter Anvin" <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc Kees Cook <[email protected]>
Cc Yinghai Lu <[email protected]>
Cc Borislav Petkov <[email protected]>
---
 arch/x86/boot/compressed/cmdline.c |   2 +-
 arch/x86/boot/compressed/kaslr.c   | 127 +++++++++++++++++++++----------------
 arch/x86/boot/string.c             |   8 +++
 3 files changed, 82 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 +73 -54

195 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 v2 1/3] KASLR: Parse all memmap entries in cmdline

Hi Baoquan,

Quoted 10 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.

[...]

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

Quoted 9 lines
arch/x86/boot/compressed/kaslr.c +2 -4
-static void mem_avoid_memmap(void)
+static void mem_avoid_memmap(char *str)
 {
-	char arg[128];
 	int rc;
-	int i;
-	char *str;
+	int i = mem_avoid_memmap_index;

Is it better that we make that variable *static* to remove the global variable(mem_avoid_memmap_index)?

- int i = mem_avoid_memmap_index;
+ static int i;

if (i >= MAX_MEMMAP_REGIONS)
return;
@@ -172,7 +172,6 @@ static void mem_avoid_memmap(char *str)

                mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
                i++;
        }

- mem_avoid_memmap_index = i;

        /* More than 4 memmaps, fail kaslr */
        if ((i >= MAX_MEMMAP_REGIONS) && str)

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

Quoted 7 lines
arch/x86/boot/compressed/kaslr.c +1 -3
-	/* See if we have any memmap areas */
-	rc = cmdline_find_option("memmap", arg, sizeof(arg));
-	if (rc <= 0)
+	if (i >= MAX_MEMMAP_REGIONS)
 		return;

I guess we just parsed and handled 4 MEMMAP_REGIONS and might ignore the following in the whole cmdline.

Is it reasonable? Is there any priority? The smaller the size, the more priority?

Thanks,
Liyang

Quoted 90 lines
arch/x86/boot/compressed/kaslr.c +44 -3
-	i = 0;
-	str = arg;
 	while (str && (i < MAX_MEMMAP_REGIONS)) {
 		int rc;
 		unsigned long long start, size;
@@ -196,12 +172,55 @@ static void mem_avoid_memmap(void)
 		mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
 		i++;
 	}
+	mem_avoid_memmap_index = i;
 
 	/* More than 4 memmaps, fail kaslr */
 	if ((i >= MAX_MEMMAP_REGIONS) && str)
 		memmap_too_large = true;
 }
 
+
+/* Macros used by the included decompressor code below. */
+#define STATIC
+#include <linux/decompress/mm.h>
+
+#define COMMAND_LINE_SIZE 256
+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;
+
+	tmp_cmdline = malloc(COMMAND_LINE_SIZE);
+	if (!tmp_cmdline )
+		error("Failed to allocate space for tmp_cmdline");
+
+	len = (len >= COMMAND_LINE_SIZE) ? COMMAND_LINE_SIZE - 1 : len;
+	memcpy(tmp_cmdline, args, len);
+	tmp_cmdline[len] = 0;
+	args = tmp_cmdline;
+
+	/* Chew leading spaces */
+	args = skip_spaces(args);
+
+	while (*args) {
+		args = next_arg(args, &param, &val);
+		/* Stop at -- */
+		if (!val && strcmp(param, "--") == 0) {
+			warn("Only '--' specified in cmdline");
+			free(tmp_cmdline);
+			return -1;
+		}
+
+		if (!strcmp(param, "memmap"))
+			mem_avoid_memmap(val);
+	}
+
+	free(tmp_cmdline);
+	return 0;
+}
+
 /*
  * 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
@@ -323,7 +342,7 @@ static void mem_avoid_init(unsigned long input, unsigned long input_size,
 	/* We don't need to set a mapping for setup_data. */
 
 	/* Mark the memmap regions we need to avoid */
-	mem_avoid_memmap();
+	handle_mem_memmap();
 
 #ifdef CONFIG_X86_VERBOSE_BOOTUP
 	/* Make sure video RAM can be used. */
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
author
#3 lore raw

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

Quoted 15 lines · Dou Liyang

Hi Baoquan,

Quoted 10 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.

[...]

Quoted 1 line
Quoted 11 lines

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

Quoted 8 lines
arch/x86/boot/compressed/kaslr.c +2 -4
-static void mem_avoid_memmap(void)
+static void mem_avoid_memmap(char *str)
 {
-	char arg[128];
 	int rc;
-	int i;
-	char *str;
+	int i = mem_avoid_memmap_index;

Is it better that we make that variable *static* to remove the global variable(mem_avoid_memmap_index)?

Yeah, I am fine with it. Can change lik this:

Quoted 17 lines
arch/x86/boot/compressed/kaslr.c +1 -2
-       int i = mem_avoid_memmap_index;
+       static int i;
 
        if (i >= MAX_MEMMAP_REGIONS)
                return;
@@ -172,7 +172,6 @@ static void mem_avoid_memmap(char *str)
                mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
                i++;
        }
-       mem_avoid_memmap_index = i;
 
        /* More than 4 memmaps, fail kaslr */
        if ((i >= MAX_MEMMAP_REGIONS) && str)
Quoted 3 lines
Quoted 9 lines

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

Quoted 6 lines
arch/x86/boot/compressed/kaslr.c +1 -3
-	/* See if we have any memmap areas */
-	rc = cmdline_find_option("memmap", arg, sizeof(arg));
-	if (rc <= 0)
+	if (i >= MAX_MEMMAP_REGIONS)
 		return;

I guess we just parsed and handled 4 MEMMAP_REGIONS and might ignore the following in the whole cmdline.

Right

Quoted 3 lines

Is it reasonable? Is there any priority? The smaller the size, the more priority?

It's on purpose. Please see the discussion during Dave Jiang's patch posting.

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

Quoted 94 lines
Quoted 92 lines
arch/x86/boot/compressed/kaslr.c +44 -3
-	i = 0;
-	str = arg;
 	while (str && (i < MAX_MEMMAP_REGIONS)) {
 		int rc;
 		unsigned long long start, size;
@@ -196,12 +172,55 @@ static void mem_avoid_memmap(void)
 		mem_avoid[MEM_AVOID_MEMMAP_BEGIN + i].size = size;
 		i++;
 	}
+	mem_avoid_memmap_index = i;
 
 	/* More than 4 memmaps, fail kaslr */
 	if ((i >= MAX_MEMMAP_REGIONS) && str)
 		memmap_too_large = true;
 }
 
+
+/* Macros used by the included decompressor code below. */
+#define STATIC
+#include <linux/decompress/mm.h>
+
+#define COMMAND_LINE_SIZE 256
+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;
+
+	tmp_cmdline = malloc(COMMAND_LINE_SIZE);
+	if (!tmp_cmdline )
+		error("Failed to allocate space for tmp_cmdline");
+
+	len = (len >= COMMAND_LINE_SIZE) ? COMMAND_LINE_SIZE - 1 : len;
+	memcpy(tmp_cmdline, args, len);
+	tmp_cmdline[len] = 0;
+	args = tmp_cmdline;
+
+	/* Chew leading spaces */
+	args = skip_spaces(args);
+
+	while (*args) {
+		args = next_arg(args, &param, &val);
+		/* Stop at -- */
+		if (!val && strcmp(param, "--") == 0) {
+			warn("Only '--' specified in cmdline");
+			free(tmp_cmdline);
+			return -1;
+		}
+
+		if (!strcmp(param, "memmap"))
+			mem_avoid_memmap(val);
+	}
+
+	free(tmp_cmdline);
+	return 0;
+}
+
 /*
  * 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
@@ -323,7 +342,7 @@ static void mem_avoid_init(unsigned long input, unsigned long input_size,
 	/* We don't need to set a mapping for setup_data. */
 
 	/* Mark the memmap regions we need to avoid */
-	mem_avoid_memmap();
+	handle_mem_memmap();
 
 #ifdef CONFIG_X86_VERBOSE_BOOTUP
 	/* Make sure video RAM can be used. */
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
#4 lore raw

[RFC PATCH] KASLR: mem_avoid_memmap_index can be static

In reply to Baoquan He
Signed-off-by: Fengguang Wu <[email protected]>
---
 kaslr.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/boot/compressed/kaslr.c +1 -1
index 6649ecd..7190d35 100644
@@ -75,7 +75,7 @@ struct mem_vector {
 #define MAX_MEMMAP_REGIONS	4
 
 static bool memmap_too_large;
-int mem_avoid_memmap_index;
+static int mem_avoid_memmap_index;
 extern unsigned long get_cmd_line_ptr(void);
 
 
author
#5 lore raw

Re: [RFC PATCH] KASLR: mem_avoid_memmap_index can be static

Hi Fengguang,

Thanks for pointing it out!

I am fine with defining mem_avoid_memmap_index it as static variable. While Liyang suggested using a local static inside mem_avoid_memmap, then mem_avoid_memmap_index is not needed any more. Do you think it's OK to you?

Thanks
Baoquan

Quoted 19 lines · kbuild test robot
---
 kaslr.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/boot/compressed/kaslr.c +1 -1
index 6649ecd..7190d35 100644
@@ -75,7 +75,7 @@ struct mem_vector {
 #define MAX_MEMMAP_REGIONS	4
 
 static bool memmap_too_large;
-int mem_avoid_memmap_index;
+static int mem_avoid_memmap_index;
 extern unsigned long get_cmd_line_ptr(void);
 
 
build bot
#6 lore raw

Re: [kbuild-all] [RFC PATCH] KASLR: mem_avoid_memmap_index can be static

Yes, that'd be a better solution. It's a robot generated patch and is open for optimization or correction.

Hi Baoquan,

On Mon, Apr 24, 2017 at 05:00:40PM +0800, Baoquan He wrote:

>Hi Fengguang,
>
>Thanks for pointing it out!
>
>I am fine with defining mem_avoid_memmap_index it as static variable.
>While Liyang suggested using a local static inside mem_avoid_memmap,
>then mem_avoid_memmap_index is not needed any more. Do you think it's OK
>to you?

Yes, that'd be a better solution. It's a robot generated patch and is open for optimization or correction.

Thanks,
Fengguang

>On 04/24/17 at 04:48pm, kbuild test robot wrote:
>>
>> Signed-off-by: Fengguang Wu <[email protected]>
>> ---
>>  kaslr.c |    2 +-
>>  1 file changed, 1 insertion(+), 1 deletion(-)
>>
>> diff --git a/arch/x86/boot/compressed/kaslr.c b/arch/x86/boot/compressed/kaslr.c
>> index 6649ecd..7190d35 100644
>> --- a/arch/x86/boot/compressed/kaslr.c
>> +++ b/arch/x86/boot/compressed/kaslr.c
>> @@ -75,7 +75,7 @@ struct mem_vector {
>>  #define MAX_MEMMAP_REGIONS	4
>>
>>  static bool memmap_too_large;
>> -int mem_avoid_memmap_index;
>> +static int mem_avoid_memmap_index;
>>  extern unsigned long get_cmd_line_ptr(void);
>>
>>
>_______________________________________________
>kbuild-all mailing list
>[email protected]
>https://lists.01.org/mailman/listinfo/kbuild-all
author
#7 lore raw

Re: [kbuild-all] [RFC PATCH] KASLR: mem_avoid_memmap_index can be static

Quoted 7 lines · Fengguang Wu

Hi Baoquan,

Quoted 4 lines · Baoquan He

Hi Fengguang,

Thanks for pointing it out!

Quoted 7 lines
Quoted 4 lines

I am fine with defining mem_avoid_memmap_index it as static variable. While Liyang suggested using a local static inside mem_avoid_memmap, then mem_avoid_memmap_index is not needed any more. Do you think it's OK to you?

Yes, that'd be a better solution. It's a robot generated patch and is open for optimization or correction.

Oh, the tip robot is so great! Thanks for telling, then let me repost.

Quoted 25 lines
Quoted 25 lines · kbuild test robot
Quoted 11 lines
---
 kaslr.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/boot/compressed/kaslr.c +0 -0
index 6649ecd..7190d35 100644

arch/x86/boot/compressed/kaslr.c struct mem_vector { · line 81

Quoted 8 lines
arch/x86/boot/compressed/kaslr.c +1 -1
@@ -75,7 +75,7 @@ struct mem_vector {
 #define MAX_MEMMAP_REGIONS	4
 
 static bool memmap_too_large;
-int mem_avoid_memmap_index;
+static int mem_avoid_memmap_index;
 extern unsigned long get_cmd_line_ptr(void);
 
 

_______________________________________________
kbuild-all mailing list
[email protected]
https://lists.01.org/mailman/listinfo/kbuild-all

#8 lore raw

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

In reply to Baoquan He
url: https://github.com/0day-ci/linux/commits/Baoquan-He/Handle-memmap-and-mem-kernel-options-in-boot-stage-kaslr/20170424-104809 reproduce:

Hi Baoquan,

[auto build test WARNING on next-20170421]
[also build test WARNING on v4.11-rc8]
[cannot apply to tip/x86/core linus/master linux/master v4.9-rc8 v4.9-rc7 v4.9-rc6] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url: https://github.com/0day-ci/linux/commits/Baoquan-He/Handle-memmap-and-mem-kernel-options-in-boot-stage-kaslr/20170424-104809
reproduce:

        # apt-get install sparse
        make ARCH=x86_64 allmodconfig
        make C=1 CF=-D__CHECK_ENDIAN__

sparse warnings: (new ones prefixed by >>)

>> arch/x86/boot/compressed/kaslr.c:78:5: sparse: symbol 'mem_avoid_memmap_index' was not declared. Should it be static?

Please review and possibly fold the followup patch.

---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation

author
#9 lore raw

PATCH v2 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.

Cc "H. Peter Anvin" <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc Kees Cook <[email protected]>
Cc Yinghai Lu <[email protected]>
Cc Borislav Petkov <[email protected]>
---
 arch/x86/boot/compressed/kaslr.c | 60 ++++++++++++++++++++++++++++++++--------
 1 file changed, 48 insertions(+), 12 deletions(-)
arch/x86/boot/compressed/kaslr.c +48 -12
index 6649ecd..34f66a5 100644
@@ -79,6 +79,10 @@ int mem_avoid_memmap_index;
 extern unsigned long get_cmd_line_ptr(void);
 
 
+/* 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,
@@ -129,16 +133,22 @@ 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 '@':
+		/* 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;
@@ -164,9 +174,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;
@@ -191,6 +206,7 @@ static int handle_mem_memmap(void)
 	size_t len = strlen((char *)args);
 	char *tmp_cmdline;
 	char *param, *val;
+	u64 mem_size;
 
 	tmp_cmdline = malloc(COMMAND_LINE_SIZE);
 	if (!tmp_cmdline )
@@ -213,8 +229,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);
@@ -451,7 +479,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)
@@ -465,8 +494,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) {
@@ -480,7 +516,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
Acked-by on v2 2/3
#10 lore raw

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

Quoted 151 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.

Cc "H. Peter Anvin" <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc Kees Cook <[email protected]>
Cc Yinghai Lu <[email protected]>
Cc Borislav Petkov <[email protected]>
---
 arch/x86/boot/compressed/kaslr.c | 60 ++++++++++++++++++++++++++++++++--------
 1 file changed, 48 insertions(+), 12 deletions(-)
arch/x86/boot/compressed/kaslr.c +48 -13
index 6649ecd..34f66a5 100644
@@ -79,6 +79,10 @@ int mem_avoid_memmap_index;
 extern unsigned long get_cmd_line_ptr(void);
 
 
+/* 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,
@@ -129,16 +133,22 @@ 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 '@':
+               /* 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;
@@ -164,9 +174,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;
@@ -191,6 +206,7 @@ static int handle_mem_memmap(void)
        size_t len = strlen((char *)args);
        char *tmp_cmdline;
        char *param, *val;
+       u64 mem_size;
 
        tmp_cmdline = malloc(COMMAND_LINE_SIZE);
        if (!tmp_cmdline )
@@ -213,8 +229,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);
@@ -451,7 +479,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)
@@ -465,8 +494,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) {
@@ -480,7 +516,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

Thanks! I find this much more readable. :)

-Kees

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

PATCH v2 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.

Cc Jonathan Corbet <[email protected]>
Cc "Rafael J. Wysocki" <[email protected]>
Cc Andrew Morton <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Bjorn Helgaas <[email protected]>
Cc Mauro Carvalho Chehab <[email protected]>
---
 Documentation/admin-guide/kernel-parameters.txt | 9 +++++++++
 1 file changed, 9 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +9 -0
index 986e443..4054328 100644
@@ -2097,6 +2097,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 ommited, 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.
@@ -2109,6 +2115,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
#12 lore raw

Re: [PATCH v2 3/3] Documentation/kernel-parameters.txt: Update 'memmap=' option description

Quoted 34 lines · 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.

Cc Jonathan Corbet <[email protected]>
Cc "Rafael J. Wysocki" <[email protected]>
Cc Andrew Morton <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Bjorn Helgaas <[email protected]>
Cc Mauro Carvalho Chehab <[email protected]>
---
 Documentation/admin-guide/kernel-parameters.txt | 9 +++++++++
 1 file changed, 9 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +0 -0
index 986e443..4054328 100644

Documentation/admin-guide/kernel-parameters.txt line 2100

Quoted 4 lines
Documentation/admin-guide/kernel-parameters.txt +1 -0
@@ -2097,6 +2097,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 ommited, it equals to mem=nn[KMG]

s/ommited/omitted/

Thanks,
Liyang

Quoted 19 lines
Documentation/admin-guide/kernel-parameters.txt +8 -0
+			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.
@@ -2109,6 +2115,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.
author
#13 lore raw

Re: [PATCH v2 3/3] Documentation/kernel-parameters.txt: Update 'memmap=' option description

Quoted 32 lines · Dou Liyang
Quoted 29 lines · 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.

Cc Jonathan Corbet <[email protected]>
Cc "Rafael J. Wysocki" <[email protected]>
Cc Andrew Morton <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Bjorn Helgaas <[email protected]>
Cc Mauro Carvalho Chehab <[email protected]>
---
 Documentation/admin-guide/kernel-parameters.txt | 9 +++++++++
 1 file changed, 9 insertions(+)
Quoted 11 lines

Documentation/admin-guide/kernel-parameters.txt line 2100

Quoted 9 lines
Documentation/admin-guide/kernel-parameters.txt +1 -0
index 986e443..4054328 100644
@@ -2097,6 +2097,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 ommited, it equals to mem=nn[KMG]

s/ommited/omitted/

Right, thanks. Will see if there's other comment and update.

Quoted 22 lines
Quoted 20 lines
Documentation/admin-guide/kernel-parameters.txt +8 -0
+			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.
@@ -2109,6 +2115,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.