Hi All, At 12/07/2017 11:56 AM, Chao Fan wrote:
On Thu, Dec 07, 2017 at 11:09:24AM +0800, Baoquan He wrote:On 12/07/17 at 10:53am, Chao Fan wrote:On Wed, Dec 06, 2017 at 05:35:57PM +0800, Baoquan He wrote:Hi Chao,Yes, now the code looks much better than the last version. On 12/05/17 at 04:51pm, Chao Fan wrote:In current code, kaslr may choose the memory region in movable nodes to extract kernel, which will make the nodes can't be hot-removed. To solve it, we can specify the memory region in immovable node. Create immovable_mem to store the regions in immovable_mem, where should be chosen by kaslr. Multiple regions can be specified, comma delimited. Considering the usage of memory, only support for 4 regions. 4 regions contains 2 nodes at least, enough for kernel to extract. Also change the "handle_mem_memmap" to "handle_mem_filter", since it will not only handle memmap parameter now.One concern is whether it will fail to do KASLR if only specifySorry, I think I have not understood your point. So if there is something wrong, please let me know.What I meant is whether we need check 'movable_node' and 'immovable_mem=' being specified together. If only specify 'movable_node', we may need to return and do not do kaslr or do not do physical kaslr since kernel could be located on movable mem region.
Indeed.
If *immovable_mem* is valid only when Kernel supports both
KASLR and Node hotplug(movable_node). we need check them together:
...
else if (!strcmp(param, "movable_node")) {
if (!strcmp(param, "immovable_mem"))
parse_immovable_mem_regions(val);
else
//no KASLR or no node hotplug?
}
...
I think both are OK and have reasons, and I tend to not return. Because if there is a parameter can solve the problem, but not specified. It's a problem of user-level. How do you think?
Seems we should clarify the scope of 'immovable_mem=' and document it.
Thanks,
dou
Thanks, Chao FanOtherwise it will do physical kaslr anyway, memory hotplug will be impacted later.I don't think if only specify "movable_node" will fail KASLR. Since in this patchset(3/4), only disable kernel mirror. KASLR in current upstream code didn't parse "movable_node"."movable_node". Surely in this case it won't fail system, just hotplug memory might be impacted if kernel is located on that, will FJ mindYes, it's the reason why I make this patchset. In my personal understanding, "movable_node" is a beginning why I make this patchset, but not the whole reason. Only "movable_node" specified might cause hotplug memory can't be removed if kernel is located on that, so we need the help of "immovable_mem=". "movable_node" help hotplug memory can be removed, and "immovable_mem=" works for the same target, but just in kaslr. So up to now, there is not a very tight coupling between "movable_node" and "immovable_mem=". The independence of "immovable_mem=" is that, help kaslr selects the right regions, avoid the memory in hotpluggable NUMA nodes, which causes the memory can't removed. It's a independent reason why we need a parameter like "immovable_mem=". So I think we should also handle it if only specify "immovable_mem=" without "movable_node". Thanks, Chao Fanthis? And what if only specify 'immovable_mem=' but without 'movable_node'? Thanks BaoquanSigned-off-by: Chao Fan <[email protected]> --- arch/x86/boot/compressed/kaslr.c | 80 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 77 insertions(+), 3 deletions(-) diff --git a/arch/x86/boot/compressed/kaslr.c b/arch/x86/boot/compressed/kaslr.c index a63fbc25ce84..0bbbaf5f6370 100644 --- a/arch/x86/boot/compressed/kaslr.c +++ b/arch/x86/boot/compressed/kaslr.c @@ -108,6 +108,15 @@ enum mem_avoid_index {static struct mem_vector mem_avoid[MEM_AVOID_MAX]; +/* Only supporting at most 4 immovable memory regions with kaslr */+#define MAX_IMMOVABLE_MEM 4 + +/* Store the memory regions in immovable node */ +static struct mem_vector immovable_mem[MAX_IMMOVABLE_MEM]; + +/* The immovable regions user specify, not more than 4 */ +static int num_immovable_region; + static bool mem_overlaps(struct mem_vector *one, struct mem_vector *two) { /* Item one is entirely before item two. */ @@ -168,6 +177,38 @@ parse_memmap(char *p, unsigned long long *start, unsigned long long *size) return -EINVAL; }+static int parse_immovable_mem(char *p,+ unsigned long long *start, + unsigned long long *size) +{ + char *oldp; + + if (!p) + return -EINVAL; + + oldp = p; + *size = memparse(p, &p); + if (p == oldp) + return -EINVAL; + + /* We support nn[KMG]@ss[KMG] and nn[KMG]. */ + switch (*p) { + case '@': + *start = memparse(p + 1, &p); + return 0; + default: + /* + * If w/o offset, only size specified, immovable_mem=nn[KMG] + * has the same behaviour as immovable_mem=nn[KMG]@0. It means + * the region starts from 0. + */ + *start = 0; + return 0; + } + + return -EINVAL; +} + static void mem_avoid_memmap(char *str) { static int i; @@ -207,7 +248,37 @@ static void mem_avoid_memmap(char *str) memmap_too_large = true; }-static int handle_mem_memmap(void)+#ifdef CONFIG_MEMORY_HOTPLUG +static void parse_immovable_mem_regions(char *str) +{ + static int i; + + while (str && (i < MAX_IMMOVABLE_MEM)) { + int rc; + unsigned long long start, size; + char *k = strchr(str, ','); + + if (k) + *k++ = 0; + + rc = parse_immovable_mem(str, &start, &size); + if (rc < 0) + break; + str = k; + + immovable_mem[i].start = start; + immovable_mem[i].size = size; + i++; + } + num_immovable_region = i; +} +#else +static inline void parse_immovable_mem_regions(char *str) +{ +} +#endif + +static int handle_mem_filter(void) { char *args = (char *)get_cmd_line_ptr(); size_t len = strlen((char *)args); @@ -215,7 +286,8 @@ static int handle_mem_memmap(void) char *param, *val; u64 mem_size;- if (!strstr(args, "memmap=") && !strstr(args, "mem="))+ if (!strstr(args, "memmap=") && !strstr(args, "mem=") && + !strstr(args, "immovable_mem=")) return 0;tmp_cmdline = malloc(len + 1);@@ -240,6 +312,8 @@ static int handle_mem_memmap(void)if (!strcmp(param, "memmap")) {mem_avoid_memmap(val); + } else if (!strcmp(param, "immovable_mem")) { + parse_immovable_mem_regions(val); } else if (!strcmp(param, "mem")) { char *p = val;@@ -379,7 +453,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 */- handle_mem_memmap(); + handle_mem_filter();#ifdef CONFIG_X86_VERBOSE_BOOTUP/* Make sure video RAM can be used. */ -- 2.14.3
