Skip to contentSkip to conversation

Avoid false-positive mem_section validation with vmlinux

PATCH New HAGIO KAZUHITO=?unknown-8bit?b?6JCp5bC+IOS4gOS7gQ==?= 3 participants 8 messages Apr 20, 2022 – Apr 27, 2022

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Avoid false-positive mem_section validation with vmlinux

Currently get_mem_section() validates if SYMBOL(mem_section) is the address of the mem_section array first. But there was a report that the first validation wrongly returned TRUE with -x vmlinux and SPARSEMEM_EXTREME (4.15+) on s390x. This leads to crash failing statup with the following seek error:

crash: seek error: kernel virtual address: 67fffc2800 type: "memory section root table"

Skip the first validation when satisfying the conditions.

---
 makedumpfile.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
makedumpfile.c +31 -0
index a2f45c84cee3..65d1c7c2f02c 100644
@@ -3698,6 +3698,22 @@ validate_mem_section(unsigned long *mem_sec,
 	return ret;
 }
 
+/*
+ * SYMBOL(mem_section) varies with the combination of memory model and
+ * its source:
+ *
+ * SPARSEMEM
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v1
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v2 (with 83e3c48729d9 and a0b1280368d1) 4.15+
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of pointer to mem_section root array
+ */
 static int
 get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 		unsigned int num_section)
@@ -3710,12 +3726,27 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 		    strerror(errno));
 		return FALSE;
 	}
+
+	/*
+	 * There was a report that the first validation wrongly returned TRUE
+	 * with -x vmlinux and SPARSEMEM_EXTREME v2 on s390x, so skip it.
+	 * Howerver, leave the fallback validation as it is for the -i option.
+	 */
+	if (is_sparsemem_extreme() && info->name_vmlinux) {
+		unsigned long flag = 0;
+		if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+					NULL, &flag)
+		    && !(flag & TYPE_ARRAY))
+			goto skip_1st_validation;
+	}
+
 	ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
 				   mem_section_size, mem_maps, num_section);
 
 	if (!ret && is_sparsemem_extreme()) {
 		unsigned long mem_section_ptr;
 
+skip_1st_validation:
 		if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
 			     sizeof(mem_section_ptr)))
 			goto out;
Signature · 1 line
2.27.0
#1 lore raw

PATCH 1/1 Avoid false-positive mem_section validation with vmlinux

Quoted 10 lines · HAGIO KAZUHITO(?? ??)

Currently get_mem_section() validates if SYMBOL(mem_section) is the address of the mem_section array first. But there was a report that the first validation wrongly returned TRUE with -x vmlinux and SPARSEMEM_EXTREME (4.15+) on s390x. This leads to crash failing statup with the following seek error:

crash: seek error: kernel virtual address: 67fffc2800 type: "memory section root table"

Skip the first validation when satisfying the conditions.

I still prefer to your V1, which is discussed internally. In which, the logic was made straight forward. And I suggest some slight change to your V1, which folds "-x vmlinux" logic into is_sparsemem_extreme().

What about the following: (not tested yet, if it is good, I can test it)

makedumpfile.c +17 -14
index a2f45c8..3ebe372 100644
@@ -2240,11 +2240,18 @@ int
 is_sparsemem_extreme(void)
 {
 	if ((ARRAY_LENGTH(mem_section)
-	     == divideup(NR_MEM_SECTIONS(), _SECTIONS_PER_ROOT_EXTREME()))
-	    || (ARRAY_LENGTH(mem_section) == NOT_FOUND_STRUCTURE))
-		return TRUE;
-	else
+	     == divideup(NR_MEM_SECTIONS(), _SECTIONS_PER_ROOT_EXTREME())) {
+	     return TRUE;
+	} else if (info->name_vmlinux) {
+		unsigned long flag = 0;
+
+		if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+				NULL, &flag)
+		    && !(flag & TYPE_ARRAY))
+		        return TRUE;
+	} else {
 		return FALSE;
+	}
 }
 
 int
@@ -3704,28 +3711,24 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 {
 	int ret = FALSE;
 	unsigned long *mem_sec = NULL;
+	unsigned long mem_section_ptr = SYMBOL(mem_section);
 
 	if ((mem_sec = malloc(mem_section_size)) == NULL) {
 		ERRMSG("Can't allocate memory for the mem_section. %s\n",
 		    strerror(errno));
 		return FALSE;
 	}
-	ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
-				   mem_section_size, mem_maps, num_section);
-
-	if (!ret && is_sparsemem_extreme()) {
-		unsigned long mem_section_ptr;
 
+	if (is_sparsemem_extreme()) {
 		if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
 			     sizeof(mem_section_ptr)))
 			goto out;
+	}
 
-		ret = validate_mem_section(mem_sec, mem_section_ptr,
-				mem_section_size, mem_maps, num_section);
-
-		if (!ret)
+	ret = validate_mem_section(mem_sec, mem_section_ptr,
+		mem_section_size, mem_maps, num_section);
+	if (!ret)
 			ERRMSG("Could not validate mem_section.\n");
-	}
 out:
 	if (mem_sec != NULL)
 		free(mem_sec);
Signature · 3 lines
Thanks,

	Pingfan
Quoted 64 lines
---
 makedumpfile.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
makedumpfile.c +31 -0
index a2f45c84cee3..65d1c7c2f02c 100644
@@ -3698,6 +3698,22 @@ validate_mem_section(unsigned long *mem_sec,
 	return ret;
 }
 
+/*
+ * SYMBOL(mem_section) varies with the combination of memory model and
+ * its source:
+ *
+ * SPARSEMEM
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v1
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v2 (with 83e3c48729d9 and a0b1280368d1) 4.15+
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of pointer to mem_section root array
+ */
 static int
 get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 		unsigned int num_section)
@@ -3710,12 +3726,27 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 		    strerror(errno));
 		return FALSE;
 	}
+
+	/*
+	 * There was a report that the first validation wrongly returned TRUE
+	 * with -x vmlinux and SPARSEMEM_EXTREME v2 on s390x, so skip it.
+	 * Howerver, leave the fallback validation as it is for the -i option.
+	 */
+	if (is_sparsemem_extreme() && info->name_vmlinux) {
+		unsigned long flag = 0;
+		if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+					NULL, &flag)
+		    && !(flag & TYPE_ARRAY))
+			goto skip_1st_validation;
+	}
+
 	ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
 				   mem_section_size, mem_maps, num_section);
 
 	if (!ret && is_sparsemem_extreme()) {
 		unsigned long mem_section_ptr;
 
+skip_1st_validation:
 		if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
 			     sizeof(mem_section_ptr)))
 			goto out;
Signature · 1 line
2.27.0
#2 lore raw

PATCH 1/1 Avoid false-positive mem_section validation with vmlinux

Hi Pingfan,

-----Original Message-----

Quoted 9 lines · HAGIO KAZUHITO(?? ??)
Quoted 8 lines

Currently get_mem_section() validates if SYMBOL(mem_section) is the address of the mem_section array first. But there was a report that the first validation wrongly returned TRUE with -x vmlinux and SPARSEMEM_EXTREME (4.15+) on s390x. This leads to crash failing statup with the following seek error:

crash: seek error: kernel virtual address: 67fffc2800 type: "memory section root table"

Quoted 8 lines
Quoted 2 lines

Skip the first validation when satisfying the conditions.

I still prefer to your V1, which is discussed internally. In which, the logic was made straight forward. And I suggest some slight change to your V1, which folds "-x vmlinux" logic into is_sparsemem_extreme().

What about the following: (not tested yet, if it is good, I can test it)

Thanks for your review and suggestion.

The purpose of my patch is to distinguish between SPARSEMEM_EXTREME v1 and v2, i.e. whether it has 83e3c48729d9 or not.

is_sparsemem_extreme() has to return whether it's SPARSEMEM_EXTREME or SPARSEMEM, so unfortunately it's not suitable to use that logic in the function.

Thanks,
Kazu

Quoted 134 lines
makedumpfile.c +17 -15
index a2f45c8..3ebe372 100644
@@ -2240,11 +2240,18 @@ int
 is_sparsemem_extreme(void)
 {
 	if ((ARRAY_LENGTH(mem_section)
-	     == divideup(NR_MEM_SECTIONS(), _SECTIONS_PER_ROOT_EXTREME()))
-	    || (ARRAY_LENGTH(mem_section) == NOT_FOUND_STRUCTURE))
-		return TRUE;
-	else
+	     == divideup(NR_MEM_SECTIONS(), _SECTIONS_PER_ROOT_EXTREME())) {
+	     return TRUE;
+	} else if (info->name_vmlinux) {
+		unsigned long flag = 0;
+
+		if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+				NULL, &flag)
+		    && !(flag & TYPE_ARRAY))
+		        return TRUE;
+	} else {
 		return FALSE;
+	}
 }
 
 int
@@ -3704,28 +3711,24 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 {
 	int ret = FALSE;
 	unsigned long *mem_sec = NULL;
+	unsigned long mem_section_ptr = SYMBOL(mem_section);
 
 	if ((mem_sec = malloc(mem_section_size)) == NULL) {
 		ERRMSG("Can't allocate memory for the mem_section. %s\n",
 		    strerror(errno));
 		return FALSE;
 	}
-	ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
-				   mem_section_size, mem_maps, num_section);
-
-	if (!ret && is_sparsemem_extreme()) {
-		unsigned long mem_section_ptr;
 
+	if (is_sparsemem_extreme()) {
 		if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
 			     sizeof(mem_section_ptr)))
 			goto out;
+	}
 
-		ret = validate_mem_section(mem_sec, mem_section_ptr,
-				mem_section_size, mem_maps, num_section);
-
-		if (!ret)
+	ret = validate_mem_section(mem_sec, mem_section_ptr,
+		mem_section_size, mem_maps, num_section);
+	if (!ret)
 			ERRMSG("Could not validate mem_section.\n");
-	}
 out:
 	if (mem_sec != NULL)
 		free(mem_sec);
--

Thanks,

Pingfan

Quoted 64 lines
---
 makedumpfile.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
makedumpfile.c +31 -1
index a2f45c84cee3..65d1c7c2f02c 100644
@@ -3698,6 +3698,22 @@ validate_mem_section(unsigned long *mem_sec,
 	return ret;
 }
 
+/*
+ * SYMBOL(mem_section) varies with the combination of memory model and
+ * its source:
+ *
+ * SPARSEMEM
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v1
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v2 (with 83e3c48729d9 and a0b1280368d1) 4.15+
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of pointer to mem_section root array
+ */
 static int
 get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 		unsigned int num_section)
@@ -3710,12 +3726,27 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 		    strerror(errno));
 		return FALSE;
 	}
+
+	/*
+	 * There was a report that the first validation wrongly returned TRUE
+	 * with -x vmlinux and SPARSEMEM_EXTREME v2 on s390x, so skip it.
+	 * Howerver, leave the fallback validation as it is for the -i option.
+	 */
+	if (is_sparsemem_extreme() && info->name_vmlinux) {
+		unsigned long flag = 0;
+		if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+					NULL, &flag)
+		    && !(flag & TYPE_ARRAY))
+			goto skip_1st_validation;
+	}
+
 	ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
 				   mem_section_size, mem_maps, num_section);
 
 	if (!ret && is_sparsemem_extreme()) {
 		unsigned long mem_section_ptr;
 
+skip_1st_validation:
 		if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
 			     sizeof(mem_section_ptr)))
 			goto out;
--

2.27.0

#3 lore raw

PATCH 1/1 Avoid false-positive mem_section validation with vmlinux

Quoted 20 lines · HAGIO KAZUHITO(?????)

Hi Pingfan,

-----Original Message-----

Quoted 16 lines · HAGIO KAZUHITO(?? ??)
Quoted 10 lines

Currently get_mem_section() validates if SYMBOL(mem_section) is the address of the mem_section array first. But there was a report that the first validation wrongly returned TRUE with -x vmlinux and SPARSEMEM_EXTREME (4.15+) on s390x. This leads to crash failing statup with the following seek error:

crash: seek error: kernel virtual address: 67fffc2800 type: "memory section root table"

Skip the first validation when satisfying the conditions.

I still prefer to your V1, which is discussed internally. In which, the logic was made straight forward. And I suggest some slight change to your V1, which folds "-x vmlinux" logic into is_sparsemem_extreme().

Quoted 7 lines
Quoted 1 line

What about the following: (not tested yet, if it is good, I can test it)

Thanks for your review and suggestion.

The purpose of my patch is to distinguish between SPARSEMEM_EXTREME v1 and v2, i.e. whether it has 83e3c48729d9 or not.

Not sure about dwarf, but is it possible to utilize the array length info in is_sparsemem_extreme()?

For SPARSEMEM_EXTREME,
#ifdef CONFIG_SPARSEMEM_EXTREME
extern struct mem_section *mem_section[NR_SECTION_ROOTS];
#else
extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT]; #endif

And if DWARF_INFO_GET_SYMBOL_ARRAY_LENGTH works, then there is a big gap between "NR_SECTION_ROOTS * 8-bytes" and "sizeof(struct mem_section) * NR_SECTION_ROOTS * SECTIONS_PER_ROOT"

Thanks,

Pingfan

Quoted 141 lines

is_sparsemem_extreme() has to return whether it's SPARSEMEM_EXTREME or SPARSEMEM, so unfortunately it's not suitable to use that logic in the function.

Thanks,
Kazu

Quoted 134 lines
makedumpfile.c +17 -15
index a2f45c8..3ebe372 100644
@@ -2240,11 +2240,18 @@ int
 is_sparsemem_extreme(void)
 {
      if ((ARRAY_LENGTH(mem_section)
-          == divideup(NR_MEM_SECTIONS(), _SECTIONS_PER_ROOT_EXTREME()))
-         || (ARRAY_LENGTH(mem_section) == NOT_FOUND_STRUCTURE))
-             return TRUE;
-     else
+          == divideup(NR_MEM_SECTIONS(), _SECTIONS_PER_ROOT_EXTREME())) {
+          return TRUE;
+     } else if (info->name_vmlinux) {
+             unsigned long flag = 0;
+
+             if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+                             NULL, &flag)
+                 && !(flag & TYPE_ARRAY))
+                     return TRUE;
+     } else {
              return FALSE;
+     }
 }
 
 int
@@ -3704,28 +3711,24 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 {
      int ret = FALSE;
      unsigned long *mem_sec = NULL;
+     unsigned long mem_section_ptr = SYMBOL(mem_section);
 
      if ((mem_sec = malloc(mem_section_size)) == NULL) {
              ERRMSG("Can't allocate memory for the mem_section. %s\n",
                  strerror(errno));
              return FALSE;
      }
-     ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
-                                mem_section_size, mem_maps, num_section);
-
-     if (!ret && is_sparsemem_extreme()) {
-             unsigned long mem_section_ptr;
 
+     if (is_sparsemem_extreme()) {
              if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
                           sizeof(mem_section_ptr)))
                      goto out;
+     }
 
-             ret = validate_mem_section(mem_sec, mem_section_ptr,
-                             mem_section_size, mem_maps, num_section);
-
-             if (!ret)
+     ret = validate_mem_section(mem_sec, mem_section_ptr,
+             mem_section_size, mem_maps, num_section);
+     if (!ret)
                      ERRMSG("Could not validate mem_section.\n");
-     }
 out:
      if (mem_sec != NULL)
              free(mem_sec);
--

Thanks,

Pingfan

Quoted 64 lines
---
 makedumpfile.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
makedumpfile.c +31 -1
index a2f45c84cee3..65d1c7c2f02c 100644
@@ -3698,6 +3698,22 @@ validate_mem_section(unsigned long *mem_sec,
    return ret;
 }
 
+/*
+ * SYMBOL(mem_section) varies with the combination of memory model and
+ * its source:
+ *
+ * SPARSEMEM
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v1
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v2 (with 83e3c48729d9 and a0b1280368d1) 4.15+
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of pointer to mem_section root array
+ */
 static int
 get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
            unsigned int num_section)
@@ -3710,12 +3726,27 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
                strerror(errno));
            return FALSE;
    }
+
+   /*
+    * There was a report that the first validation wrongly returned TRUE
+    * with -x vmlinux and SPARSEMEM_EXTREME v2 on s390x, so skip it.
+    * Howerver, leave the fallback validation as it is for the -i option.
+    */
+   if (is_sparsemem_extreme() && info->name_vmlinux) {
+           unsigned long flag = 0;
+           if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+                                   NULL, &flag)
+               && !(flag & TYPE_ARRAY))
+                   goto skip_1st_validation;
+   }
+
    ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
                               mem_section_size, mem_maps, num_section);
 
    if (!ret && is_sparsemem_extreme()) {
            unsigned long mem_section_ptr;
 
+skip_1st_validation:
            if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
                         sizeof(mem_section_ptr)))
                    goto out;
--

2.27.0

#4 lore raw

PATCH 1/1 Avoid false-positive mem_section validation with vmlinux

-----Original Message-----

Quoted 40 lines
Quoted 20 lines · HAGIO KAZUHITO(?????)

Hi Pingfan,

-----Original Message-----

Quoted 16 lines · HAGIO KAZUHITO(?? ??)
Quoted 10 lines

Currently get_mem_section() validates if SYMBOL(mem_section) is the address of the mem_section array first. But there was a report that the first validation wrongly returned TRUE with -x vmlinux and SPARSEMEM_EXTREME (4.15+) on s390x. This leads to crash failing statup with the following seek error:

crash: seek error: kernel virtual address: 67fffc2800 type: "memory section root table"

Skip the first validation when satisfying the conditions.

I still prefer to your V1, which is discussed internally. In which, the logic was made straight forward. And I suggest some slight change to your V1, which folds "-x vmlinux" logic into is_sparsemem_extreme().

Quoted 7 lines
Quoted 1 line

What about the following: (not tested yet, if it is good, I can test it)

Thanks for your review and suggestion.

The purpose of my patch is to distinguish between SPARSEMEM_EXTREME v1 and v2, i.e. whether it has 83e3c48729d9 or not.

Not sure about dwarf, but is it possible to utilize the array length info in is_sparsemem_extreme()?

For SPARSEMEM_EXTREME,
#ifdef CONFIG_SPARSEMEM_EXTREME
extern struct mem_section *mem_section[NR_SECTION_ROOTS];
#else
extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT]; #endif

Quoted 3 lines

And if DWARF_INFO_GET_SYMBOL_ARRAY_LENGTH works, then there is a big gap between "NR_SECTION_ROOTS * 8-bytes" and "sizeof(struct mem_section) * NR_SECTION_ROOTS * SECTIONS_PER_ROOT"

hmm, sorry, I haven't got your point, the current is_sparsemem_extreme() already uses that value to determine whether it's SPARSEMEM_EXTREME or not. and it's doing the same thing with vmlinux, too.

Quoted 4 lines
Quoted 4 lines

makedumpfile.c int · line 2245

Quoted 4 lines

if ((ARRAY_LENGTH(mem_section)

makedumpfile.c +0 -3
-          == divideup(NR_MEM_SECTIONS(), _SECTIONS_PER_ROOT_EXTREME()))
-         || (ARRAY_LENGTH(mem_section) == NOT_FOUND_STRUCTURE))
-             return TRUE;
        if (SYMBOL(mem_section) != NOT_FOUND_SYMBOL)
                SYMBOL_ARRAY_LENGTH_INIT(mem_section, "mem_section");

Thanks,
Kazu

#5 lore raw

PATCH 1/1 Avoid false-positive mem_section validation with vmlinux

In reply to HAGIO KAZUHITO=?unknown-8bit?b?6JCp5bC+IOS4gOS7gQ==?=

Hi Kazu,

Quoted 6 lines · On Wed, 20 Apr 2022 23:58:29 +0000 HAGIO KAZUHITO(?????) <[email protected]>…

Currently get_mem_section() validates if SYMBOL(mem_section) is the address of the mem_section array first. But there was a report that the first validation wrongly returned TRUE with -x vmlinux and SPARSEMEM_EXTREME (4.15+) on s390x. This leads to crash failing statup with the following seek error:

Quoted 6 lines

crash: seek error: kernel virtual address: 67fffc2800 type: "memory section root table"

Skip the first validation when satisfying the conditions.

for me this patch looks fine and exactly addresses the problem, that mem_section has different types in the vmlinux and vmcoreinfo. So, for what I want

Reviewed-and-Tested-by Philipp Rudo <[email protected]>
Quoted 59 lines
---
 makedumpfile.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
makedumpfile.c +31 -0
index a2f45c84cee3..65d1c7c2f02c 100644
@@ -3698,6 +3698,22 @@ validate_mem_section(unsigned long *mem_sec,
 	return ret;
 }
 
+/*
+ * SYMBOL(mem_section) varies with the combination of memory model and
+ * its source:
+ *
+ * SPARSEMEM
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v1
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v2 (with 83e3c48729d9 and a0b1280368d1) 4.15+
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of pointer to mem_section root array
+ */
 static int
 get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 		unsigned int num_section)
@@ -3710,12 +3726,27 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
 		    strerror(errno));
 		return FALSE;
 	}
+
+	/*
+	 * There was a report that the first validation wrongly returned TRUE
+	 * with -x vmlinux and SPARSEMEM_EXTREME v2 on s390x, so skip it.
+	 * Howerver, leave the fallback validation as it is for the -i option.
+	 */
+	if (is_sparsemem_extreme() && info->name_vmlinux) {
+		unsigned long flag = 0;
+		if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+					NULL, &flag)
+		    && !(flag & TYPE_ARRAY))
+			goto skip_1st_validation;
+	}
+
 	ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
 				   mem_section_size, mem_maps, num_section);
 
 	if (!ret && is_sparsemem_extreme()) {
 		unsigned long mem_section_ptr;
 
+skip_1st_validation:
 		if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
 			     sizeof(mem_section_ptr)))
 			goto out;
#6 lore raw

PATCH 1/1 Avoid false-positive mem_section validation with vmlinux

In reply to HAGIO KAZUHITO=?unknown-8bit?b?6JCp5bC+IOS4gOS7gQ==?=
Quoted 73 lines · HAGIO KAZUHITO(?????)

Currently get_mem_section() validates if SYMBOL(mem_section) is the address of the mem_section array first. But there was a report that the first validation wrongly returned TRUE with -x vmlinux and SPARSEMEM_EXTREME (4.15+) on s390x. This leads to crash failing statup with the following seek error:

crash: seek error: kernel virtual address: 67fffc2800 type: "memory section root table"

Skip the first validation when satisfying the conditions.

---
 makedumpfile.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
makedumpfile.c +31 -1
index a2f45c84cee3..65d1c7c2f02c 100644
@@ -3698,6 +3698,22 @@ validate_mem_section(unsigned long *mem_sec,
        return ret;
 }
 
+/*
+ * SYMBOL(mem_section) varies with the combination of memory model and
+ * its source:
+ *
+ * SPARSEMEM
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v1
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v2 (with 83e3c48729d9 and a0b1280368d1) 4.15+
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of pointer to mem_section root array
+ */
 static int
 get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
                unsigned int num_section)
@@ -3710,12 +3726,27 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
                    strerror(errno));
                return FALSE;
        }
+
+       /*
+        * There was a report that the first validation wrongly returned TRUE
+        * with -x vmlinux and SPARSEMEM_EXTREME v2 on s390x, so skip it.
+        * Howerver, leave the fallback validation as it is for the -i option.
+        */
+       if (is_sparsemem_extreme() && info->name_vmlinux) {
+               unsigned long flag = 0;
+               if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+                                       NULL, &flag)
+                   && !(flag & TYPE_ARRAY))
+                       goto skip_1st_validation;
+       }
+
        ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
                                   mem_section_size, mem_maps, num_section);
 
        if (!ret && is_sparsemem_extreme()) {
                unsigned long mem_section_ptr;
 
+skip_1st_validation:
                if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
                             sizeof(mem_section_ptr)))
                        goto out;
--
Quoted 2 lines

2.27.0

Discussed with Kazu off-list, and with his nice help, I got clear why he drops V1.

Hence,

#7 lore raw

PATCH 1/1 Avoid false-positive mem_section validation with vmlinux

Hi Pingfan, Philipp,

Thank you for reviewing and testing this, applied.
https://github.com/makedumpfile/makedumpfile/commit/6d0d95ecc04a70f8448d562ff0fbbae237f5c929

Kazu

-----Original Message-----

Quoted 82 lines
Quoted 73 lines · HAGIO KAZUHITO(?????)

Currently get_mem_section() validates if SYMBOL(mem_section) is the address of the mem_section array first. But there was a report that the first validation wrongly returned TRUE with -x vmlinux and SPARSEMEM_EXTREME (4.15+) on s390x. This leads to crash failing statup with the following seek error:

crash: seek error: kernel virtual address: 67fffc2800 type: "memory section root table"

Skip the first validation when satisfying the conditions.

---
 makedumpfile.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
makedumpfile.c +31 -1
index a2f45c84cee3..65d1c7c2f02c 100644
@@ -3698,6 +3698,22 @@ validate_mem_section(unsigned long *mem_sec,
        return ret;
 }
 
+/*
+ * SYMBOL(mem_section) varies with the combination of memory model and
+ * its source:
+ *
+ * SPARSEMEM
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v1
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of mem_section root array
+ *
+ * SPARSEMEM_EXTREME v2 (with 83e3c48729d9 and a0b1280368d1) 4.15+
+ *   vmcoreinfo: address of mem_section root array
+ *   -x vmlinux: address of pointer to mem_section root array
+ */
 static int
 get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
                unsigned int num_section)
@@ -3710,12 +3726,27 @@ get_mem_section(unsigned int mem_section_size, unsigned long *mem_maps,
                    strerror(errno));
                return FALSE;
        }
+
+       /*
+        * There was a report that the first validation wrongly returned TRUE
+        * with -x vmlinux and SPARSEMEM_EXTREME v2 on s390x, so skip it.
+        * Howerver, leave the fallback validation as it is for the -i option.
+        */
+       if (is_sparsemem_extreme() && info->name_vmlinux) {
+               unsigned long flag = 0;
+               if (get_symbol_type_name("mem_section", DWARF_INFO_GET_SYMBOL_TYPE,
+                                       NULL, &flag)
+                   && !(flag & TYPE_ARRAY))
+                       goto skip_1st_validation;
+       }
+
        ret = validate_mem_section(mem_sec, SYMBOL(mem_section),
                                   mem_section_size, mem_maps, num_section);
 
        if (!ret && is_sparsemem_extreme()) {
                unsigned long mem_section_ptr;
 
+skip_1st_validation:
                if (!readmem(VADDR, SYMBOL(mem_section), &mem_section_ptr,
                             sizeof(mem_section_ptr)))
                        goto out;
--
Quoted 2 lines

2.27.0

Discussed with Kazu off-list, and with his nice help, I got clear why he drops V1.

Hence,