gmane.linux.kernel.kexec

[PATCH v4 2/3] s390/kdump: Use ELF header in new memory feature

Michael Holzheu — 2013-05-24T11:29:42

This patch now exchanges the old relocate mechanism with the new
arch function call override mechanism that allows to create the ELF
core header in the 2nd kernel.

Signed-off-by: Michael Holzheu <holzheu-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
---
 arch/s390/kernel/crash_dump.c | 64 ++++++++++++++++++++++++++++++-------------
 1 file changed, 45 insertions(+), 19 deletions(-)

diff --git a/arch/s390/kernel/crash_dump.c b/arch/s390/kernel/crash_dump.c
index f703d91..aeb1207 100644
--- a/arch/s390/kernel/crash_dump.c
+++ b/arch/s390/kernel/crash_dump.c
< at >< at > -21,6 +21,9 < at >< at >
 #define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
 #define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
 
+static size_t elfcorebuf_sz;
+static char *elfcorebuf;
+
 /*
  * Copy one page from "oldmem"
  *
< at >< at > -325,14 +328,6 < at >< at > static int get_mem_chunk_cnt(void)
 }
 
 /*
- * Relocate pointer in order to allow vmcore code access the data
- */
-static inline unsigned long relocate(unsigned long addr)
-{
-return OLDMEM_BASE + addr;
-}
-
-/*
  * Initialize ELF loads (new kernel)
  */
 static int loads_init(Elf64_Phdr *phdr, u64 loads_offset)
< at >< at > -383,7 +378,7 < at >< at > static void *notes_init(Elf64_Phdr *phdr, void *ptr, u64 notes_offset)
 ptr = nt_vmcoreinfo(ptr);
 memset(phdr, 0, sizeof(*phdr));
 phdr->p_type = PT_NOTE;
-phdr->p_offset = relocate(notes_offset);
+phdr->p_offset = notes_offset;
 phdr->p_filesz = (unsigned long) PTR_SUB(ptr, ptr_start);
 phdr->p_memsz = phdr->p_filesz;
 return ptr;
< at >< at > -392,7 +387,7 < at >< at > static void *notes_init(Elf64_Phdr *phdr, void *ptr, u64 notes_offset)
 /*
  * Create ELF core header (new kernel)
  */
-static void s390_elf_corehdr_create(char **elfcorebuf, size_t *elfcorebuf_sz)
+static int s390_elf_corehdr_create(char **elfcorebuf, size_t *elfcorebuf_sz)
 {
 Elf64_Phdr *phdr_notes, *phdr_loads;
 int mem_chunk_cnt;
< at >< at > -414,28 +409,59 < at >< at > static void s390_elf_corehdr_create(char **elfcorebuf, size_t *elfcorebuf_sz)
 ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr) * mem_chunk_cnt);
 /* Init notes */
 hdr_off = PTR_DIFF(ptr, hdr);
-ptr = notes_init(phdr_notes, ptr, ((unsigned long) hdr) + hdr_off);
+ptr = notes_init(phdr_notes, ptr, (unsigned long) hdr + hdr_off);
 /* Init loads */
 hdr_off = PTR_DIFF(ptr, hdr);
-loads_init(phdr_loads, ((unsigned long) hdr) + hdr_off);
+loads_init(phdr_loads, hdr_off);
 *elfcorebuf_sz = hdr_off;
-*elfcorebuf = (void *) relocate((unsigned long) hdr);
+*elfcorebuf = hdr;
 BUG_ON(*elfcorebuf_sz > alloc_size);
+return 0;
 }
 
 /*
- * Create kdump ELF core header in new kernel, if it has not been passed via
- * the "elfcorehdr" kernel parameter
+ * Return address of ELF core header (new or old memory)
  */
-static int setup_kdump_elfcorehdr(void)
+unsigned long long arch_get_crash_header(void)
 {
-size_t elfcorebuf_sz;
-char *elfcorebuf;
+if (elfcorebuf)
+return elfcorehdr_addr;
+else
+return __pa(elfcorebuf);
+}
 
+/*
+ * Free crash header
+ */
+void arch_free_crash_header(void)
+{
+kfree(elfcorebuf);
+elfcorebuf = 0;
+}
+
+/*
+ * Read from crash header (new or old memory)
+ */
+ssize_t arch_read_from_crash_header(char *buf, size_t count, u64 *ppos)
+{
+if (elfcorebuf)
+memcpy(buf, (void *)*ppos, count);
+else
+copy_from_oldmem(buf, (void *)*ppos, count);
+*ppos += count;
+return count;
+}
+
+/*
+ * Create kdump ELF core header in new kernel if it has not been passed via
+ * the "elfcorehdr=" kernel parameter
+ */
+static int setup_kdump_elfcorehdr(void)
+{
 if (!OLDMEM_BASE || is_kdump_kernel())
 return -EINVAL;
 s390_elf_corehdr_create(&elfcorebuf, &elfcorebuf_sz);
-elfcorehdr_addr = (unsigned long long) elfcorebuf;
+elfcorehdr_addr = __pa(elfcorebuf);
 elfcorehdr_size = elfcorebuf_sz;
 return 0;
 }

[PATCH v4 3/3] s390/kdump: Use vmcore for zfcpdump

Michael Holzheu — 2013-05-24T11:29:43

From: Jan Willeke <willeke-tA70FqPdS9bQT0dZR+AlfA< at >public.gmane.org>

This patch modifies the s390 copy_oldmem_page() function for zfcpdump
to read from the HSA memory if memory below HSA_SIZE bytes is requested.
Otherwise from real memory is read.

Signed-off-by: Jan Willeke <willeke-tA70FqPdS9bQT0dZR+AlfA< at >public.gmane.org>
Signed-off-by: Michael Holzheu <holzheu-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
---
 arch/s390/Kconfig             |  3 +-
 arch/s390/include/asm/sclp.h  |  1 +
 arch/s390/kernel/crash_dump.c | 74 ++++++++++++++++++++++++++++++++++---------
 drivers/s390/char/zcore.c     |  6 ++--
 4 files changed, 65 insertions(+), 19 deletions(-)

diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 2c9789d..a0d78f1 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
< at >< at > -516,6 +516,7 < at >< at > config CRASH_DUMP
 bool "kernel crash dumps"
 depends on 64BIT && SMP
 select KEXEC
+select ZFCPDUMP
 help
   Generate crash dump after being started by kexec.
   Crash dump kernels are loaded in the main kernel with kexec-tools
< at >< at > -526,7 +527,7 < at >< at > config CRASH_DUMP
 config ZFCPDUMP
 def_bool n
 prompt "zfcpdump support"
-select SMP
+depends on SMP
 help
   Select this option if you want to build an zfcpdump enabled kernel.
   Refer to <file:Documentation/s390/zfcpdump.txt> for more details on this.
diff --git a/arch/s390/include/asm/sclp.h b/arch/s390/include/asm/sclp.h
index 06a1361..7dc7f9c 100644
--- a/arch/s390/include/asm/sclp.h
+++ b/arch/s390/include/asm/sclp.h
< at >< at > -56,5 +56,6 < at >< at > bool sclp_has_linemode(void);
 bool sclp_has_vt220(void);
 int sclp_pci_configure(u32 fid);
 int sclp_pci_deconfigure(u32 fid);
+int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode);
 
 #endif /* _ASM_S390_SCLP_H */
diff --git a/arch/s390/kernel/crash_dump.c b/arch/s390/kernel/crash_dump.c
index aeb1207..fd0dc60 100644
--- a/arch/s390/kernel/crash_dump.c
+++ b/arch/s390/kernel/crash_dump.c
< at >< at > -16,6 +16,7 < at >< at >
 #include <asm/os_info.h>
 #include <asm/elf.h>
 #include <asm/ipl.h>
+#include <asm/sclp.h>
 
 #define PTR_ADD(x, y) (((char *) (x)) + ((unsigned long) (y)))
 #define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
< at >< at > -24,6 +25,25 < at >< at >
 static size_t elfcorebuf_sz;
 static char *elfcorebuf;
 
+/* For pages below ZFCPDUMP_HSA_SIZE memory from the HSA is copied. Otherwise
+ * real memory copy is used.
+ */
+static ssize_t copy_oldmem_page_zfcpdump(char *buf, size_t csize,
+ unsigned long src, int userbuf)
+{
+if (src < ZFCPDUMP_HSA_SIZE) {
+if (memcpy_hsa(buf, src, csize, userbuf) < 0)
+return -EINVAL;
+} else {
+if (userbuf)
+copy_to_user_real((void __force __user *) buf,
+  (void *) src, csize);
+else
+memcpy_real(buf, (void *) src, csize);
+}
+return csize;
+}
+
 /*
  * Copy one page from "oldmem"
  *
< at >< at > -31,15 +51,10 < at >< at > static char *elfcorebuf;
  *  - [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE] is mapped to [0 - OLDMEM_SIZE].
  *  - [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
  */
-ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
- size_t csize, unsigned long offset, int userbuf)
-{
-unsigned long src;
+static ssize_t copy_oldmem_page_kdump(char *buf, size_t csize,
+      unsigned long src, int userbuf)
 
-if (!csize)
-return 0;
-
-src = (pfn << PAGE_SHIFT) + offset;
+{
 if (src < OLDMEM_SIZE)
 src += OLDMEM_BASE;
 else if (src > OLDMEM_BASE &&
< at >< at > -54,6 +69,23 < at >< at > ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
 }
 
 /*
+ * Copy one page from "oldmem"
+ */
+ssize_t copy_oldmem_page(unsigned long pfn, char *buf, size_t csize,
+ unsigned long offset, int userbuf)
+{
+unsigned long src;
+if (!csize)
+return 0;
+src = (pfn << PAGE_SHIFT) + offset;
+
+if (OLDMEM_BASE)
+return copy_oldmem_page_kdump(buf, csize, src, userbuf);
+else
+return copy_oldmem_page_zfcpdump(buf, csize, src, userbuf);
+}
+
+/*
  * Copy memory from old kernel
  */
 int copy_from_oldmem(void *dest, void *src, size_t count)
< at >< at > -61,11 +93,21 < at >< at > int copy_from_oldmem(void *dest, void *src, size_t count)
 unsigned long copied = 0;
 int rc;
 
-if ((unsigned long) src < OLDMEM_SIZE) {
-copied = min(count, OLDMEM_SIZE - (unsigned long) src);
-rc = memcpy_real(dest, src + OLDMEM_BASE, copied);
-if (rc)
-return rc;
+if (OLDMEM_BASE) {
+if ((unsigned long) src < OLDMEM_SIZE) {
+copied = min(count, OLDMEM_SIZE - (unsigned long) src);
+rc = memcpy_real(dest, src + OLDMEM_BASE, copied);
+if (rc)
+return rc;
+}
+} else {
+if ((unsigned long) src < ZFCPDUMP_HSA_SIZE) {
+copied = min(count,
+     ZFCPDUMP_HSA_SIZE - (unsigned long) src);
+rc = memcpy_hsa(dest, (unsigned long) src, copied, 0);
+if (rc)
+return rc;
+}
 }
 return memcpy_real(dest + copied, src + copied, count - copied);
 }
< at >< at > -458,7 +500,9 < at >< at > ssize_t arch_read_from_crash_header(char *buf, size_t count, u64 *ppos)
  */
 static int setup_kdump_elfcorehdr(void)
 {
-if (!OLDMEM_BASE || is_kdump_kernel())
+if (!OLDMEM_BASE && (ipl_info.type != IPL_TYPE_FCP_DUMP))
+return -EINVAL;
+if (is_kdump_kernel())
 return -EINVAL;
 s390_elf_corehdr_create(&elfcorebuf, &elfcorebuf_sz);
 elfcorehdr_addr = __pa(elfcorebuf);
< at >< at > -466,4 +510,4 < at >< at > static int setup_kdump_elfcorehdr(void)
 return 0;
 }
 
-subsys_initcall(setup_kdump_elfcorehdr);
+subsys_initcall_sync(setup_kdump_elfcorehdr);
diff --git a/drivers/s390/char/zcore.c b/drivers/s390/char/zcore.c
index 9e5e146..794820a 100644
--- a/drivers/s390/char/zcore.c
+++ b/drivers/s390/char/zcore.c
< at >< at > -30,8 +30,8 < at >< at >
 
 #define TRACE(x...) debug_sprintf_event(zcore_dbf, 1, x)
 
-#define TO_USER0
-#define TO_KERNEL1
+#define TO_USER1
+#define TO_KERNEL0
 #define CHUNK_INFO_SIZE34 /* 2 16-byte char, each followed by blank */
 
 enum arch_id {
< at >< at > -73,7 +73,7 < at >< at > static struct ipl_parameter_block *ipl_block;
  * < at >count: Size of buffer, which should be copied
  * < at >mode:  Either TO_KERNEL or TO_USER
  */
-static int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode)
+int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode)
 {
 int offs, blk_num;
 static char buf[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));

Re: [PATCH] makedumpfile: Petr Tesarik's hugepage filtering

HATAYAMA Daisuke — 2013-05-24T02:40:47


Thinking further, it might be unlikely that we want user data but don't want hugetlbfs pages
on crash dump case. If so, I think Petr's implementation seems also OK. It seems no problem
to postpone introducing new dump level after someone who wants to filter hugetlbfs pages only,
actually occurs.

Re: [PATCH] makedumpfile: Petr Tesarik's hugepage filtering

HATAYAMA Daisuke — 2013-05-24T02:24:23


This seems correct. We don't know when and where page table gets remapped by huge pages
transparently. If user-space and transparent huge pages are filtered separately, data
larger than size of huge table, 2MiB or 1GiB on x86, can be corrupted. Consider the case
that 2MiB + 4KiB data is allocated on 2MiB boundary and only the first 2MiB area is
remapped by THP. We should filter them together.


hugetlbfs has no such risk, so this seems basically OK to me.

Also, hugetlbfs pages are "user data". They should get filtered when user data dump level
is specified. So how about:

       Dump  |  zero   without  with     user    free   hugetlbfs
       Level |  page   private  private  data    page   page
      -------+-----------------------------------------------------
          0  |
          1  |   X
          2  |           X
          4  |           X        X
          8  |                            X              X
         16  |                                    X
         32  |                                           X
         63  |   X       X        X       X       X      X

On dump level 8, hugetlbfs pages also get filtered.

Re: [PATCH] makedumpfile: Petr Tesarik's hugepage filtering

Atsushi Kumagai — 2013-05-24T01:11:21

On Wed, 15 May 2013 13:43:59 -0500
Cliff Wickman <cpw-sJ/iWh9BUns< at >public.gmane.org> wrote:


I send this mail to kexec list to open the discussion below.


This code will filter out both transparent huge pages and hugetlbfs pages.
But I think hugetlbfs pages shouldn't be filtered out as anonymous pages
because anonymous pages and hugetlbfs pages are certainly different kind
of pages.

Therefore, I plan to add a new dump level to filter out hugetlbfs pages.
My basic idea is like below:


  * Exclude the data page of the user process.
  */
                else if ((info->dump_level & DL_EXCLUDE_USER_DATA)
                    && isAnon(mapping)) {
                        if (clear_bit_on_2nd_bitmap_for_kernel(pfn))
                                pfn_user++;
+
+                       if (isPageHead(flags)) {
+                               int i, nr_pages = 1 << compound_order;
+
+                               for (i = 1; i < nr_pages; ++i) {
+                                       if (clear_bit_on_2nd_bitmap_for_kernel(pfn + i))
+                                               pfn_user++;
+                               }
+                               pfn += nr_pages - 2;
+                               mem_map += (nr_pages - 1) * SIZE(page);
+                       }
+               }
+               /*
+                * Exclude the hugetlbfs pages.
+                */
+               else if ((info->dump_level & DL_EXCLUDE_HUGETLBFS_DATA)
+                        && (!isAnon(mapping) && isPageHead(flags))) {
+                       int i, nr_pages = 1 << compound_order;
+
+                       for (i = 0; i < nr_pages; ++i) {
+                               if (clear_bit_on_2nd_bitmap_for_kernel(pfn + i))
+                                       pfn_hugetlb++;
+                       }
+                       pfn += nr_pages - 1;
+                       mem_map += (nr_pages - 1) * SIZE(page);
                }
                /*
                 * Exclude the hwpoison page.


But before that, I would like to hear the opinions about the new dump level
to make sure that the level is worthy or not.


Thanks
Atsushi Kumagai

[PATCH v3 1/3] kdump: Introduce ELF header in new memory feature

Michael Holzheu — 2013-05-23T18:56:59

Currently for s390 we create the ELF core header in the 2nd kernel
with a small trick. We relocate the addresses in the ELF header in
a way that for the /proc/vmcore code it seems to be in the 1st kernel
(old) memory and the read_from_oldmem() returns the correct data.
This allows the /proc/vmcore code to use the ELF header in the
2nd kernel.

This patch now exchanges the old mechanism with the new and much
cleaner function call override feature that now offcially allows to
create the ELF core header in the 2nd kernel.

To use the new feature the following has to be done by the architecture
backend code:

 * Override arch_get_crash_header() to return the address of the ELF
   header in new memory
 * Override arch_free_crash_header() to free the memory of the ELF
   header in new memory
 * Override arch_read_from_crash_header() to read from the ELF header
   in new memory
 * Set elfcorehdr_addr to the address of ELF header in new memory

Signed-off-by: Michael Holzheu <holzheu-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
---
 fs/proc/vmcore.c           | 65 +++++++++++++++++++++++++++++++++-------------
 include/linux/crash_dump.h |  4 +++
 2 files changed, 51 insertions(+), 18 deletions(-)

diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index 6ba32f8..a9e1b65 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
< at >< at > -123,6 +123,28 < at >< at > static ssize_t read_from_oldmem(char *buf, size_t count,
 return read;
 }
 
+/*
+ * Architetures may override this function to read header data
+ */
+ssize_t __weak arch_read_from_crash_header(char *buf, size_t count, u64 *ppos)
+{
+return read_from_oldmem(buf, count, ppos, 0);
+}
+
+/*
+ * Architetures may override this function to get header address
+ */
+unsigned long long __weak arch_get_crash_header(void)
+{
+return elfcorehdr_addr;
+}
+
+/*
+ * Architetures may override this function to free header
+ */
+void __weak arch_free_crash_header(void)
+{}
+
 /* Read from the ELF header and then the crash dump. On error, negative value is
  * returned otherwise number of bytes read are returned.
  */
< at >< at > -356,7 +378,8 < at >< at > static int __init get_note_number_and_size_elf64(const Elf64_Ehdr *ehdr_ptr,
 notes_section = kmalloc(max_sz, GFP_KERNEL);
 if (!notes_section)
 return -ENOMEM;
-rc = read_from_oldmem(notes_section, max_sz, &offset, 0);
+rc = arch_read_from_crash_header(notes_section, max_sz,
+ &offset);
 if (rc < 0) {
 kfree(notes_section);
 return rc;
< at >< at > -412,7 +435,8 < at >< at > static int __init copy_notes_elf64(const Elf64_Ehdr *ehdr_ptr, char *notes_buf)
 notes_section = kmalloc(max_sz, GFP_KERNEL);
 if (!notes_section)
 return -ENOMEM;
-rc = read_from_oldmem(notes_section, max_sz, &offset, 0);
+rc = arch_read_from_crash_header(notes_section, max_sz,
+ &offset);
 if (rc < 0) {
 kfree(notes_section);
 return rc;
< at >< at > -428,8 +452,8 < at >< at > static int __init copy_notes_elf64(const Elf64_Ehdr *ehdr_ptr, char *notes_buf)
 nhdr_ptr = (Elf64_Nhdr*)((char*)nhdr_ptr + sz);
 }
 offset = phdr_ptr->p_offset;
-rc = read_from_oldmem(notes_buf + phdr_sz, real_sz,
-      &offset, 0);
+rc = arch_read_from_crash_header(notes_buf + phdr_sz, real_sz,
+ &offset);
 if (rc < 0) {
 kfree(notes_section);
 return rc;
< at >< at > -533,7 +557,8 < at >< at > static int __init get_note_number_and_size_elf32(const Elf32_Ehdr *ehdr_ptr,
 notes_section = kmalloc(max_sz, GFP_KERNEL);
 if (!notes_section)
 return -ENOMEM;
-rc = read_from_oldmem(notes_section, max_sz, &offset, 0);
+rc = arch_read_from_crash_header(notes_section, max_sz,
+ &offset);
 if (rc < 0) {
 kfree(notes_section);
 return rc;
< at >< at > -589,7 +614,8 < at >< at > static int __init copy_notes_elf32(const Elf32_Ehdr *ehdr_ptr, char *notes_buf)
 notes_section = kmalloc(max_sz, GFP_KERNEL);
 if (!notes_section)
 return -ENOMEM;
-rc = read_from_oldmem(notes_section, max_sz, &offset, 0);
+rc = arch_read_from_crash_header(notes_section, max_sz,
+ &offset);
 if (rc < 0) {
 kfree(notes_section);
 return rc;
< at >< at > -605,8 +631,8 < at >< at > static int __init copy_notes_elf32(const Elf32_Ehdr *ehdr_ptr, char *notes_buf)
 nhdr_ptr = (Elf32_Nhdr*)((char*)nhdr_ptr + sz);
 }
 offset = phdr_ptr->p_offset;
-rc = read_from_oldmem(notes_buf + phdr_sz, real_sz,
-      &offset, 0);
+rc = arch_read_from_crash_header(notes_buf + phdr_sz, real_sz,
+ &offset);
 if (rc < 0) {
 kfree(notes_section);
 return rc;
< at >< at > -804,10 +830,11 < at >< at > static int __init parse_crash_elf64_headers(void)
 Elf64_Ehdr ehdr;
 u64 addr;
 
-addr = elfcorehdr_addr;
+addr = arch_get_crash_header();
 
 /* Read Elf header */
-rc = read_from_oldmem((char*)&ehdr, sizeof(Elf64_Ehdr), &addr, 0);
+rc = arch_read_from_crash_header((char *)&ehdr, sizeof(Elf64_Ehdr),
+ &addr);
 if (rc < 0)
 return rc;
 
< at >< at > -832,8 +859,8 < at >< at > static int __init parse_crash_elf64_headers(void)
        get_order(elfcorebuf_sz_orig));
 if (!elfcorebuf)
 return -ENOMEM;
-addr = elfcorehdr_addr;
-rc = read_from_oldmem(elfcorebuf, elfcorebuf_sz_orig, &addr, 0);
+addr = arch_get_crash_header();
+rc = arch_read_from_crash_header(elfcorebuf, elfcorebuf_sz_orig, &addr);
 if (rc < 0) {
 free_pages((unsigned long)elfcorebuf,
    get_order(elfcorebuf_sz_orig));
< at >< at > -867,10 +894,11 < at >< at > static int __init parse_crash_elf32_headers(void)
 Elf32_Ehdr ehdr;
 u64 addr;
 
-addr = elfcorehdr_addr;
+addr = arch_get_crash_header();
 
 /* Read Elf header */
-rc = read_from_oldmem((char*)&ehdr, sizeof(Elf32_Ehdr), &addr, 0);
+rc = arch_read_from_crash_header((char *)&ehdr, sizeof(Elf32_Ehdr),
+ &addr);
 if (rc < 0)
 return rc;
 
< at >< at > -895,8 +923,8 < at >< at > static int __init parse_crash_elf32_headers(void)
        get_order(elfcorebuf_sz_orig));
 if (!elfcorebuf)
 return -ENOMEM;
-addr = elfcorehdr_addr;
-rc = read_from_oldmem(elfcorebuf, elfcorebuf_sz_orig, &addr, 0);
+addr = arch_get_crash_header();
+rc = arch_read_from_crash_header(elfcorebuf, elfcorebuf_sz_orig, &addr);
 if (rc < 0) {
 free_pages((unsigned long)elfcorebuf,
    get_order(elfcorebuf_sz_orig));
< at >< at > -930,8 +958,8 < at >< at > static int __init parse_crash_elf_headers(void)
 u64 addr;
 int rc=0;
 
-addr = elfcorehdr_addr;
-rc = read_from_oldmem(e_ident, EI_NIDENT, &addr, 0);
+addr = arch_get_crash_header();
+rc = arch_read_from_crash_header(e_ident, EI_NIDENT, &addr);
 if (rc < 0)
 return rc;
 if (memcmp(e_ident, ELFMAG, SELFMAG) != 0) {
< at >< at > -961,6 +989,7 < at >< at > static int __init parse_crash_elf_headers(void)
 pr_warn("Warning: Core image elf header is not sane\n");
 return -EINVAL;
 }
+arch_free_crash_header();
 return 0;
 }
 
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
index 37e4f8d..c66da41 100644
--- a/include/linux/crash_dump.h
+++ b/include/linux/crash_dump.h
< at >< at > -14,6 +14,10 < at >< at > extern unsigned long long elfcorehdr_size;
 
 extern ssize_t copy_oldmem_page(unsigned long, char *, size_t,
 unsigned long, int);
+extern unsigned long long __weak arch_get_crash_header(void);
+extern void __weak arch_free_crash_header(void);
+extern ssize_t __weak arch_read_from_crash_header(char *buf, size_t count,
+  u64 *ppos);
 
 /* Architecture code defines this if there are other possible ELF
  * machine types, e.g. on bi-arch capable hardware. */

[PATCH v3 2/3] s390/kdump: Use ELF header in new memory feature

Michael Holzheu — 2013-05-23T18:57:00

This patch now exchanges the old relocate mechanism with the new
arch function call override mechanism that allows to create the ELF
core header in the 2nd kernel.

Signed-off-by: Michael Holzheu <holzheu-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
---
 arch/s390/kernel/crash_dump.c | 64 ++++++++++++++++++++++++++++++-------------
 1 file changed, 45 insertions(+), 19 deletions(-)

diff --git a/arch/s390/kernel/crash_dump.c b/arch/s390/kernel/crash_dump.c
index f703d91..aeb1207 100644
--- a/arch/s390/kernel/crash_dump.c
+++ b/arch/s390/kernel/crash_dump.c
< at >< at > -21,6 +21,9 < at >< at >
 #define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
 #define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
 
+static size_t elfcorebuf_sz;
+static char *elfcorebuf;
+
 /*
  * Copy one page from "oldmem"
  *
< at >< at > -325,14 +328,6 < at >< at > static int get_mem_chunk_cnt(void)
 }
 
 /*
- * Relocate pointer in order to allow vmcore code access the data
- */
-static inline unsigned long relocate(unsigned long addr)
-{
-return OLDMEM_BASE + addr;
-}
-
-/*
  * Initialize ELF loads (new kernel)
  */
 static int loads_init(Elf64_Phdr *phdr, u64 loads_offset)
< at >< at > -383,7 +378,7 < at >< at > static void *notes_init(Elf64_Phdr *phdr, void *ptr, u64 notes_offset)
 ptr = nt_vmcoreinfo(ptr);
 memset(phdr, 0, sizeof(*phdr));
 phdr->p_type = PT_NOTE;
-phdr->p_offset = relocate(notes_offset);
+phdr->p_offset = notes_offset;
 phdr->p_filesz = (unsigned long) PTR_SUB(ptr, ptr_start);
 phdr->p_memsz = phdr->p_filesz;
 return ptr;
< at >< at > -392,7 +387,7 < at >< at > static void *notes_init(Elf64_Phdr *phdr, void *ptr, u64 notes_offset)
 /*
  * Create ELF core header (new kernel)
  */
-static void s390_elf_corehdr_create(char **elfcorebuf, size_t *elfcorebuf_sz)
+static int s390_elf_corehdr_create(char **elfcorebuf, size_t *elfcorebuf_sz)
 {
 Elf64_Phdr *phdr_notes, *phdr_loads;
 int mem_chunk_cnt;
< at >< at > -414,28 +409,59 < at >< at > static void s390_elf_corehdr_create(char **elfcorebuf, size_t *elfcorebuf_sz)
 ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr) * mem_chunk_cnt);
 /* Init notes */
 hdr_off = PTR_DIFF(ptr, hdr);
-ptr = notes_init(phdr_notes, ptr, ((unsigned long) hdr) + hdr_off);
+ptr = notes_init(phdr_notes, ptr, (unsigned long) hdr + hdr_off);
 /* Init loads */
 hdr_off = PTR_DIFF(ptr, hdr);
-loads_init(phdr_loads, ((unsigned long) hdr) + hdr_off);
+loads_init(phdr_loads, hdr_off);
 *elfcorebuf_sz = hdr_off;
-*elfcorebuf = (void *) relocate((unsigned long) hdr);
+*elfcorebuf = hdr;
 BUG_ON(*elfcorebuf_sz > alloc_size);
+return 0;
 }
 
 /*
- * Create kdump ELF core header in new kernel, if it has not been passed via
- * the "elfcorehdr" kernel parameter
+ * Return address of ELF core header (new or old memory)
  */
-static int setup_kdump_elfcorehdr(void)
+unsigned long long arch_get_crash_header(void)
 {
-size_t elfcorebuf_sz;
-char *elfcorebuf;
+if (elfcorebuf)
+return elfcorehdr_addr;
+else
+return __pa(elfcorebuf);
+}
 
+/*
+ * Free crash header
+ */
+void arch_free_crash_header(void)
+{
+kfree(elfcorebuf);
+elfcorebuf = 0;
+}
+
+/*
+ * Read from crash header (new or old memory)
+ */
+ssize_t arch_read_from_crash_header(char *buf, size_t count, u64 *ppos)
+{
+if (elfcorebuf)
+memcpy(buf, (void *)*ppos, count);
+else
+copy_from_oldmem(buf, (void *)*ppos, count);
+*ppos += count;
+return count;
+}
+
+/*
+ * Create kdump ELF core header in new kernel if it has not been passed via
+ * the "elfcorehdr=" kernel parameter
+ */
+static int setup_kdump_elfcorehdr(void)
+{
 if (!OLDMEM_BASE || is_kdump_kernel())
 return -EINVAL;
 s390_elf_corehdr_create(&elfcorebuf, &elfcorebuf_sz);
-elfcorehdr_addr = (unsigned long long) elfcorebuf;
+elfcorehdr_addr = __pa(elfcorebuf);
 elfcorehdr_size = elfcorebuf_sz;
 return 0;
 }

Re: [PATCH v2 1/3] kdump: Introduce ELF header in new memory feature

Vivek Goyal — 2013-05-23T17:41:27

setting elfcorehdr_addr to ELFCORE_ADDR_NEWMEM looks really odd to me.
There is no need for arch independent code to know whether crash headers
are in new memory or not. Our old assumption was that everything is in
old memory. Now that is broken because of s390. So arch should be
able to override read_from_crash_header() call and read headers from
new memory. If need be s390 can maintain another variable for this
state to figure out where headers are.

Also arch should be able to  set elfcorehdr_addr to virtual address
of ELF header. is_kdump_kernel() does not care whether address stored
in elfcorehdr_addr is physical or virtual.

IOW, generic code would not care whether headers are in new memory
or old memory. All the operations on header will be abstracted with
the help of helper functions.

Can we please get rid of this NEWMEM stuff.



Why do we need read_from_newmem? I thought arch code will override
read_from_crash_header() and write a variant of read_from_newmem()
internally. I think could still be an helper function in vmcore.c if
there are many arch keeping headers in new memory so that we don't
have same code across multiple arches. But s390 seems to be the only
expcetion at this point of time.


I thought read_from_crash_header() will simply be

read_from_crash_header() {
return read_from_oldmem()
}

And arch code will override it to read the headers from new memory. That
way generic code does not have to know whether headers are in old memory
or in new memory or somewhere else.

Also current usage of read_from_crash_header() seems to be that we are
not copying header data to user space buffer directly. Generic code will
process headers and copy them in kernel memory and it will be copied to
user space from there if need be.

So for time being I think it should be just fine to assume that
read_from_crash_header() is copying data to kernel memory only.

Thanks
Vivek

[PATCH v2 3/3] s390/kdump: Use vmcore for zfcpdump

Michael Holzheu — 2013-05-22T17:58:37

From: Jan Willeke <willeke-tA70FqPdS9bQT0dZR+AlfA< at >public.gmane.org>

This patch modifies the s390 copy_oldmem_page() function for zfcpdump
to read from the HSA memory if memory below HSA_SIZE bytes is requested.
Otherwise from real memory is read.

Signed-off-by: Jan Willeke <willeke-tA70FqPdS9bQT0dZR+AlfA< at >public.gmane.org>
Signed-off-by: Michael Holzheu <holzheu-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
---
 arch/s390/Kconfig             |  3 +-
 arch/s390/include/asm/sclp.h  |  1 +
 arch/s390/kernel/crash_dump.c | 74 ++++++++++++++++++++++++++++++++++---------
 drivers/s390/char/zcore.c     |  6 ++--
 4 files changed, 65 insertions(+), 19 deletions(-)

diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 2c9789d..a0d78f1 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
< at >< at > -516,6 +516,7 < at >< at > config CRASH_DUMP
 bool "kernel crash dumps"
 depends on 64BIT && SMP
 select KEXEC
+select ZFCPDUMP
 help
   Generate crash dump after being started by kexec.
   Crash dump kernels are loaded in the main kernel with kexec-tools
< at >< at > -526,7 +527,7 < at >< at > config CRASH_DUMP
 config ZFCPDUMP
 def_bool n
 prompt "zfcpdump support"
-select SMP
+depends on SMP
 help
   Select this option if you want to build an zfcpdump enabled kernel.
   Refer to <file:Documentation/s390/zfcpdump.txt> for more details on this.
diff --git a/arch/s390/include/asm/sclp.h b/arch/s390/include/asm/sclp.h
index 06a1361..7dc7f9c 100644
--- a/arch/s390/include/asm/sclp.h
+++ b/arch/s390/include/asm/sclp.h
< at >< at > -56,5 +56,6 < at >< at > bool sclp_has_linemode(void);
 bool sclp_has_vt220(void);
 int sclp_pci_configure(u32 fid);
 int sclp_pci_deconfigure(u32 fid);
+int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode);
 
 #endif /* _ASM_S390_SCLP_H */
diff --git a/arch/s390/kernel/crash_dump.c b/arch/s390/kernel/crash_dump.c
index 4fe7fa7..40373b3 100644
--- a/arch/s390/kernel/crash_dump.c
+++ b/arch/s390/kernel/crash_dump.c
< at >< at > -16,6 +16,7 < at >< at >
 #include <asm/os_info.h>
 #include <asm/elf.h>
 #include <asm/ipl.h>
+#include <asm/sclp.h>
 
 #define PTR_ADD(x, y) (((char *) (x)) + ((unsigned long) (y)))
 #define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
< at >< at > -24,6 +25,25 < at >< at >
 static size_t elfcorebuf_sz;
 static char *elfcorebuf;
 
+/* For pages below ZFCPDUMP_HSA_SIZE memory from the HSA is copied. Otherwise
+ * real memory copy is used.
+ */
+static ssize_t copy_oldmem_page_zfcpdump(char *buf, size_t csize,
+ unsigned long src, int userbuf)
+{
+if (src < ZFCPDUMP_HSA_SIZE) {
+if (memcpy_hsa(buf, src, csize, userbuf) < 0)
+return -EINVAL;
+} else {
+if (userbuf)
+copy_to_user_real((void __force __user *) buf,
+  (void *) src, csize);
+else
+memcpy_real(buf, (void *) src, csize);
+}
+return csize;
+}
+
 /*
  * Copy one page from "oldmem"
  *
< at >< at > -31,15 +51,10 < at >< at > static char *elfcorebuf;
  *  - [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE] is mapped to [0 - OLDMEM_SIZE].
  *  - [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
  */
-ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
- size_t csize, unsigned long offset, int userbuf)
-{
-unsigned long src;
+static ssize_t copy_oldmem_page_kdump(char *buf, size_t csize,
+      unsigned long src, int userbuf)
 
-if (!csize)
-return 0;
-
-src = (pfn << PAGE_SHIFT) + offset;
+{
 if (src < OLDMEM_SIZE)
 src += OLDMEM_BASE;
 else if (src > OLDMEM_BASE &&
< at >< at > -54,6 +69,23 < at >< at > ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
 }
 
 /*
+ * Copy one page from "oldmem"
+ */
+ssize_t copy_oldmem_page(unsigned long pfn, char *buf, size_t csize,
+ unsigned long offset, int userbuf)
+{
+unsigned long src;
+if (!csize)
+return 0;
+src = (pfn << PAGE_SHIFT) + offset;
+
+if (OLDMEM_BASE)
+return copy_oldmem_page_kdump(buf, csize, src, userbuf);
+else
+return copy_oldmem_page_zfcpdump(buf, csize, src, userbuf);
+}
+
+/*
  * Copy memory from old kernel
  */
 int copy_from_oldmem(void *dest, void *src, size_t count)
< at >< at > -61,11 +93,21 < at >< at > int copy_from_oldmem(void *dest, void *src, size_t count)
 unsigned long copied = 0;
 int rc;
 
-if ((unsigned long) src < OLDMEM_SIZE) {
-copied = min(count, OLDMEM_SIZE - (unsigned long) src);
-rc = memcpy_real(dest, src + OLDMEM_BASE, copied);
-if (rc)
-return rc;
+if (OLDMEM_BASE) {
+if ((unsigned long) src < OLDMEM_SIZE) {
+copied = min(count, OLDMEM_SIZE - (unsigned long) src);
+rc = memcpy_real(dest, src + OLDMEM_BASE, copied);
+if (rc)
+return rc;
+}
+} else {
+if ((unsigned long) src < ZFCPDUMP_HSA_SIZE) {
+copied = min(count,
+     ZFCPDUMP_HSA_SIZE - (unsigned long) src);
+rc = memcpy_hsa(dest, (unsigned long) src, copied, 0);
+if (rc)
+return rc;
+}
 }
 return memcpy_real(dest + copied, src + copied, count - copied);
 }
< at >< at > -448,7 +490,9 < at >< at > void arch_free_crash_header(void)
  */
 static int setup_kdump_elfcorehdr(void)
 {
-if (!OLDMEM_BASE || is_kdump_kernel())
+if (!OLDMEM_BASE || (ipl_info.type != IPL_TYPE_FCP_DUMP))
+return -EINVAL;
+if (is_kdump_kernel())
 return -EINVAL;
 arch_vmcore_get_elf_hdr(&elfcorebuf, &elfcorebuf_sz);
 elfcorehdr_addr = ELFCORE_ADDR_NEWMEM;
< at >< at > -456,4 +500,4 < at >< at > static int setup_kdump_elfcorehdr(void)
 return 0;
 }
 
-subsys_initcall(setup_kdump_elfcorehdr);
+subsys_initcall_sync(setup_kdump_elfcorehdr);
diff --git a/drivers/s390/char/zcore.c b/drivers/s390/char/zcore.c
index 9e5e146..794820a 100644
--- a/drivers/s390/char/zcore.c
+++ b/drivers/s390/char/zcore.c
< at >< at > -30,8 +30,8 < at >< at >
 
 #define TRACE(x...) debug_sprintf_event(zcore_dbf, 1, x)
 
-#define TO_USER0
-#define TO_KERNEL1
+#define TO_USER1
+#define TO_KERNEL0
 #define CHUNK_INFO_SIZE34 /* 2 16-byte char, each followed by blank */
 
 enum arch_id {
< at >< at > -73,7 +73,7 < at >< at > static struct ipl_parameter_block *ipl_block;
  * < at >count: Size of buffer, which should be copied
  * < at >mode:  Either TO_KERNEL or TO_USER
  */
-static int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode)
+int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode)
 {
 int offs, blk_num;
 static char buf[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));

[PATCH 3/4] kexec-tools: Fix possible overflows and make use of dbg_memrange() macro

Thomas Renninger — 2013-05-22T08:57:35

add_memmap() will add another memrange, therefore we need an additional
array entry and need to check for
if (nr_entries >= CRASH_MAX_MEMMAP_NR - 1)

Same for delete_memmap: If a region has to be split an additional region is
added first, so we again have to check for:
if (nr_entries >= CRASH_MAX_MEMMAP_NR - 1)

In add_memmap we know the amount of range entries. No need to check for the
ugly:
-               if (mstart == 0 && mend == 0)
-                       break;
condition, just let the loop go until nr_entries.

Signed-off-by: Thomas Renninger <trenn-l3A5Bk7waGM< at >public.gmane.org>
Signed-off-by: Thomas Renninger <Thomas Renninger" trenn-l3A5Bk7waGM< at >public.gmane.org>
---
 kexec/arch/i386/crashdump-x86.c |   35 ++++++++---------------------------
 1 files changed, 8 insertions(+), 27 deletions(-)

diff --git a/kexec/arch/i386/crashdump-x86.c b/kexec/arch/i386/crashdump-x86.c
index 9b5a7cd..7fd1c5b 100644
--- a/kexec/arch/i386/crashdump-x86.c
+++ b/kexec/arch/i386/crashdump-x86.c
< at >< at > -545,14 +545,12 < at >< at > static int add_memmap(struct memory_range *memmap_p, unsigned long long addr,
 else
 nr_entries++;
 }
-if (nr_entries == CRASH_MAX_MEMMAP_NR)
+if (nr_entries >= CRASH_MAX_MEMMAP_NR - 1)
 return -1;
 
-for (i = 0; i < CRASH_MAX_MEMMAP_NR;  i++) {
+for (i = 0; i < nr_entries;  i++) {
 mstart = memmap_p[i].start;
 mend = memmap_p[i].end;
-if (mstart == 0 && mend == 0)
-break;
 if (mstart <= (addr+size-1) && mend >=addr)
 /* Overlapping region. */
 return -1;
< at >< at > -565,16 +563,8 < at >< at > static int add_memmap(struct memory_range *memmap_p, unsigned long long addr,
 memmap_p[tidx].start = addr;
 memmap_p[tidx].end = addr + size - 1;
 
-dbgprintf("Memmap after adding segment\n");
-for (i = 0; i < CRASH_MAX_MEMMAP_NR;  i++) {
-mstart = memmap_p[i].start;
-mend = memmap_p[i].end;
-if (mstart == 0 && mend == 0)
-break;
-dbgprintf("%016llx - %016llx\n",
-mstart, mend);
-}
-
+nr_entries++;
+dbg_memrange("Memmap after adding segment", &memmap_p, nr_entries);
 return 0;
 }
 
< at >< at > -600,8 +590,7 < at >< at > static int delete_memmap(struct memory_range *memmap_p, unsigned long long addr,
 else
 nr_entries++;
 }
-if (nr_entries == CRASH_MAX_MEMMAP_NR)
-/* List if full */
+if (nr_entries >= CRASH_MAX_MEMMAP_NR - 1)
 return -1;
 
 for (i = 0; i < CRASH_MAX_MEMMAP_NR;  i++) {
< at >< at > -643,25 +632,17 < at >< at > static int delete_memmap(struct memory_range *memmap_p, unsigned long long addr,
 for (j = nr_entries-1; j > tidx; j--)
 memmap_p[j+1] = memmap_p[j];
 memmap_p[tidx+1] = temp_region;
+nr_entries++;
 }
 if ((operation == -1) && tidx >=0) {
 /* Delete the exact match memory region. */
 for (j = i+1; j < CRASH_MAX_MEMMAP_NR; j++)
 memmap_p[j-1] = memmap_p[j];
 memmap_p[j-1].start = memmap_p[j-1].end = 0;
+nr_entries--;
 }
 
-dbgprintf("Memmap after deleting segment\n");
-for (i = 0; i < CRASH_MAX_MEMMAP_NR;  i++) {
-mstart = memmap_p[i].start;
-mend = memmap_p[i].end;
-if (mstart == 0 && mend == 0) {
-break;
-}
-dbgprintf("%016llx - %016llx\n",
-mstart, mend);
-}
-
+dbg_memrange("Memmap after deleting segment", &memmap_p, nr_entries);
 return 0;
 }

[PATCH 1/4] kexec-tools: Cleanup: Fix indentation

Thomas Renninger — 2013-05-22T08:57:33

Signed-off-by: Thomas Renninger <trenn-l3A5Bk7waGM< at >public.gmane.org>
Signed-off-by: Thomas Renninger <Thomas Renninger" trenn-l3A5Bk7waGM< at >public.gmane.org>
---
 kexec/arch/i386/crashdump-x86.c |   10 +++++-----
 1 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/kexec/arch/i386/crashdump-x86.c b/kexec/arch/i386/crashdump-x86.c
index e44fceb..17c8744 100644
--- a/kexec/arch/i386/crashdump-x86.c
+++ b/kexec/arch/i386/crashdump-x86.c
< at >< at > -559,11 +559,11 < at >< at > static int add_memmap(struct memory_range *memmap_p, unsigned long long addr,
 else if (addr > mend)
 tidx = i+1;
 }
-/* Insert the memory region. */
-for (j = nr_entries-1; j >= tidx; j--)
-memmap_p[j+1] = memmap_p[j];
-memmap_p[tidx].start = addr;
-memmap_p[tidx].end = addr + size - 1;
+/* Insert the memory region. */
+for (j = nr_entries-1; j >= tidx; j--)
+memmap_p[j+1] = memmap_p[j];
+memmap_p[tidx].start = addr;
+memmap_p[tidx].end = addr + size - 1;
 
 dbgprintf("Memmap after adding segment\n");
 for (i = 0; i < CRASH_MAX_MEMMAP_NR;  i++) {

[PATCH 4/4] kexec-tools: Add cgroup_disable=memory to crash kernel parameters

Thomas Renninger — 2013-05-22T08:57:36

cgroup memory subsystem pre-allocates quite some memory at boot up.
Example dmesg:
allocated 469762048 bytes of page_cgroup
please try 'cgroup_disable=memory' option if you don't want memory cgroups

Due to maxcpu=1 it is by far not that much than in a productive kernel.
It still seem to be around 4M statically as no Numa overhead exists with
only one active CPU. It is still worth to disable cgroup memory
pre-allocating in crash kernel environment.

Signed-off-by: Thomas Renninger <trenn-l3A5Bk7waGM< at >public.gmane.org>
Signed-off-by: Thomas Renninger <Thomas Renninger" trenn-l3A5Bk7waGM< at >public.gmane.org>
---
 kexec/arch/i386/crashdump-x86.c |   22 ++++++++++++++++++++++
 1 files changed, 22 insertions(+), 0 deletions(-)

diff --git a/kexec/arch/i386/crashdump-x86.c b/kexec/arch/i386/crashdump-x86.c
index 7fd1c5b..e6d60a9 100644
--- a/kexec/arch/i386/crashdump-x86.c
+++ b/kexec/arch/i386/crashdump-x86.c
< at >< at > -757,6 +757,23 < at >< at > static int cmdline_add_elfcorehdr(char *cmdline, unsigned long addr)
 return 0;
 }
 
+static void cmdline_disable_cgroup(char *cmdline)
+{
+int cmdlen;
+char str[30] = " cgroup_disable=memory";
+
+cmdlen = strlen(cmdline) + strlen(str);
+if (cmdlen > (COMMAND_LINE_SIZE - 1)) {
+/* Not fatal if cgroup memory is not disabled */
+dbgprintf(
+  "Command line overflow, cgroup memory not disabled\n");
+return;
+}
+strcat(cmdline, str);
+
+dbgprintf("Command line after adding adding cgroup_disable=memory\n");
+dbgprintf("%s\n", cmdline);
+}
 
 /*
  * This routine is specific to i386 architecture to maintain the
< at >< at > -1037,6 +1054,11 < at >< at > int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline,
 end = mem_range[i].end;
 cmdline_add_memmap_acpi(mod_cmdline, start, end);
 }
+/* 
+ * Always add disabling cgroup_diable=memory param at the end,
+ * it's not critical if it falls off
+ */
+cmdline_disable_cgroup(mod_cmdline);
 return 0;
 }

[PATCH 2/4] kexec-tools: Introduce dbg_memrange() macro and make use of it

Thomas Renninger — 2013-05-22T08:57:34

There are several places where memory range arrays are printed for debug
reasons. In load_crashdump_segments() the memory type is missing.

Unify printing memory ranges in --debug case in a macro and add the first
users.

Signed-off-by: Thomas Renninger <trenn-l3A5Bk7waGM< at >public.gmane.org>
Signed-off-by: Thomas Renninger <Thomas Renninger" trenn-l3A5Bk7waGM< at >public.gmane.org>
---
 kexec/arch/i386/crashdump-x86.c    |    5 +----
 kexec/arch/i386/kexec-x86-common.c |    6 +-----
 kexec/arch/ppc/crashdump-powerpc.c |    8 +-------
 kexec/kexec.h                      |   11 +++++++++++
 4 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/kexec/arch/i386/crashdump-x86.c b/kexec/arch/i386/crashdump-x86.c
index 17c8744..9b5a7cd 100644
--- a/kexec/arch/i386/crashdump-x86.c
+++ b/kexec/arch/i386/crashdump-x86.c
< at >< at > -959,10 +959,7 < at >< at > int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline,
 
 get_backup_area(info, mem_range, nr_ranges);
 
-dbgprintf("CRASH MEMORY RANGES\n");
-
-for(i = 0; i < nr_ranges; ++i)
-dbgprintf("%016Lx-%016Lx\n", mem_range[i].start, mem_range[i].end);
+dbg_memrange("CRASH MEMORY RANGES", &mem_range, nr_ranges);
 
 /*
  * if the core type has not been set on command line, set it here
diff --git a/kexec/arch/i386/kexec-x86-common.c b/kexec/arch/i386/kexec-x86-common.c
index ed6c950..015dcb6 100644
--- a/kexec/arch/i386/kexec-x86-common.c
+++ b/kexec/arch/i386/kexec-x86-common.c
< at >< at > -477,11 +477,7 < at >< at > int get_memory_ranges(struct memory_range **range, int *ranges,
 mem_max = end;
 }
 
-dbgprintf("MEMORY RANGES\n");
-for (i = 0; i < *ranges; i++) {
-dbgprintf("%016Lx-%016Lx (%d)\n", (*range)[i].start,
-  (*range)[i].end, (*range)[i].type);
-}
+dbg_memrange("MEMORY RANGES", range, *ranges);
 
 return ret;
 }
diff --git a/kexec/arch/ppc/crashdump-powerpc.c b/kexec/arch/ppc/crashdump-powerpc.c
index eee5b37..feb3cfd 100644
--- a/kexec/arch/ppc/crashdump-powerpc.c
+++ b/kexec/arch/ppc/crashdump-powerpc.c
< at >< at > -236,13 +236,7 < at >< at > static int get_crash_memory_ranges(struct memory_range **range, int *ranges)
 *ranges = memory_ranges;
 
 int j;
-dbgprintf("CRASH MEMORY RANGES\n");
-for (j = 0; j < *ranges; j++) {
-start = crash_memory_range[j].start;
-end = crash_memory_range[j].end;
-dbgprintf("%016Lx-%016Lx\n", start, end);
-}
-
+dbg_memrange("MEMORY RANGES", &crash_memory_range, *ranges);
 return 0;
 
 err:
diff --git a/kexec/kexec.h b/kexec/kexec.h
index 715b568..eea8c50 100644
--- a/kexec/kexec.h
+++ b/kexec/kexec.h
< at >< at > -121,6 +121,17 < at >< at > do { \
 fprintf(stderr, __VA_ARGS__); \
 } while(0)
 
+#define dbg_memrange(title, range, nr) \
+do { \
+ int i; \
+ dbgprintf(title "\n"); \
+ for (i = 0; i < nr; i++) { \
+ dbgprintf("%016Lx-%016Lx (%d)\n", (*range)[i].start,\
+   (*range)[i].end, (*range)[i].type);\
+ } \
+ } while (0)
+
+
 struct kexec_segment {
 const void *buf;
 size_t bufsz;

Different minor kexec cleanups

Thomas Renninger — 2013-05-22T08:57:32

Hi,

after some holidays and catching up, I like to re-visit the:
Pass memory ranges via e820 tables to crash kernel
work.
These are some cleanup patches on code I stumbled over while looking at
this. It would be great if these can get applied, so that my local branch
is in sync with mainline. I then like to proceed with further cleanups and
finally get to the point where a clean, split up in small patches submission
to implement above is possible.

Thanks,

       Thomas

Re: [PATCH] makedumpfile: turn off mmap for free page scan

HATAYAMA Daisuke — 2013-05-22T07:38:56

Also how about keeping mmap mode and reducing mapping size temporarily 
to 4KiB?


I don't know which this measured time indicates. Only free pages 
filtering or free pages filtering plus unnecessary pages filtering?

Re: [PATCH] makedumpfile: turn off mmap for free page scan

Atsushi Kumagai — 2013-05-22T06:57:12

On Wed, 15 May 2013 13:43:59 -0500
Cliff Wickman <cpw-sJ/iWh9BUns< at >public.gmane.org> wrote:


Sounds good.
BTW, do you have a speed measurement like your another patch ?



Thanks
Atsushi Kumagai

Re: [PATCH] makedumpfile: non-cyclic default

Jingbai Ma — 2013-05-21T02:53:52

I second leave default mode to cyclic. It's difficult to guess how much 
memory the secondary kernel needed. The memory requirement from 
different device driver also be very different, especially on machines 
with many I/O cards.
So we don't know if the memory is enough for non-cyclic.

Once we have kernel 3.9 and kexec-tools-2.0.4, We will have enough 
memory above 4GB address. And then, the next question will be how much 
memory we should reserve for crashkernel.

Re: [PATCH] makedumpfile: non-cyclic default

Atsushi Kumagai — 2013-05-21T02:15:16

On Wed, 15 May 2013 13:43:59 -0500
Cliff Wickman <cpw-sJ/iWh9BUns< at >public.gmane.org> wrote:


This change causes the failure due to lack of memory, again.

I think reliability is more important than performance, it's desirable
that anyone can use makedumpfile safely without any considerations.

Only experts who can set "crashkernel" appropriately based on physical
memory size should use --non-cyclic option manually for performance.


Thanks
Atsushi Kumagai

Re: [PATCH] makedumpfile: non-cyclic default

HATAYAMA Daisuke — 2013-05-21T00:36:28

Default behaviour should not be changed so easily, and I think 
performance of cyclic mode can be improved to some amount because 
cyclic-mode shows slow result even if the number of cycles is 1...


Is the '-Y' definitely necessary? I'm thinking this is hideded 
intentionally.

Re: [PATCH] makedumpfile: buddy identification when noncyclic

Atsushi Kumagai — 2013-05-20T09:50:38

On Wed, 15 May 2013 13:43:59 -0500
Cliff Wickman <cpw-sJ/iWh9BUns< at >public.gmane.org> wrote:


Looks good to me.
I'll merge this patch into v1.5.4.


Thanks
Atsushi Kumagai

Re: [PATCH] makedumpfile: warn on vmlinux without dwarf

Cliff Wickman — 2013-05-20T12:17:12

Agreed.  An error code is good.

-Cliff