gmane.linux.kernel.kexec

Kexec corrupts command line in x86-linux-setup.c setup_edd_info()

Dmitry Trikoz — 2012-05-24T17:26:51

Hi,
I've been chasing strange problem with kdump kernel. It was crashing on 
boot without any messages to the console.
Finally I found that kdump kernel command line was corrupt.
Digging down I found the problem in  setup_edd_info() and 
add_edd_entry(). It doesn't check for array size of
real_mode->eddbuf[] and real_mode->edd_mbr_sig_buffer[]
So when it overruns eddbuf[] it corrupts command_line that follows it.

Here is the fix:

--- a/kexec-tools/kexec/arch/i386/x86-linux-setup.c
+++ b/kexec-tools/kexec/arch/i386/x86-linux-setup.c
< at >< at > -275,9 +275,9 < at >< at > static int add_edd_entry(struct 
x86_linux_param_header *real_mode,
                                 "must not be NULL", __FUNCTION__);
                 return -1;
         }
-
-       edd_info = &real_mode->eddbuf[*current_edd];
-       memset(edd_info, 0, sizeof(struct edd_info));
+       if (*current_mbr >= EDD_MBR_SIG_MAX) {
+               return 0;
+       }

         /* extract the device number */
         if (sscanf(basename(sysfs_name), "int13_dev%hhx", &devnum) != 1) {
< at >< at > -293,12 +293,21 < at >< at > static int add_edd_entry(struct 
x86_linux_param_header *real_mode,
                 dbgprintf("EDD Device 0x%x: mbr_sig=0x%x\n", devnum, 
mbr_sig);
         }

+       if (*current_edd >= EDDMAXNR) {
+               return 0;
+       }
+
+       edd_info = &real_mode->eddbuf[*current_edd];
+       memset(edd_info, 0, sizeof(struct edd_info));
+
         /* set the device number */
         edd_info->device = devnum;

         /* set the version */
-       if (file_scanf(sysfs_name, "version", "0x%hhx", &version) != 1)
+       if (file_scanf(sysfs_name, "version", "0x%hhx", &version) != 1) {
+               fprintf(stderr, "sysfs_name %s version file error\n", 
sysfs_name);
                 return -1;
+       }

         edd_info->version = version;

Sincerely,

Dmitry Trikoz

dmitry.trikoz-7+ureL1bLXNBDgjK7y7TUQ< at >public.gmane.org

[PATCH v2] kexec: simply pass LINUX_REBOOT_CMD_KEXEC to reboot

maximilian attems — 2012-05-22T16:59:47

While trying to port kexec cleanly to klibc,
came across this syscall usage for reboot(2).
Calling reboot directly simplifies the code.

Signed-off-by: maximilian attems <max-U9r9yeDMy7A< at >public.gmane.org>
---
 kexec/kexec-syscall.h |   18 ------------------
 kexec/kexec.c         |    3 ++-
 2 files changed, 2 insertions(+), 19 deletions(-)

v2: keep LINUX_REBOOT_CMD_KEXEC defines, thus no need of <linux/reboot.h>.
    (The packagers don't like linux header deps..)

The next TODO item is to add proper syscall kexec_load() to glibc.
Funnily here klibc has an head start! -maks

diff --git a/kexec/kexec-syscall.h b/kexec/kexec-syscall.h
index f4df45c..b56cb00 100644
--- a/kexec/kexec-syscall.h
+++ b/kexec/kexec-syscall.h
< at >< at > -5,18 +5,6 < at >< at >
 #include <sys/syscall.h>
 #include <unistd.h>
 
-#defineLINUX_REBOOT_MAGIC10xfee1dead
-#defineLINUX_REBOOT_MAGIC2672274793
-#defineLINUX_REBOOT_MAGIC2A85072278
-#defineLINUX_REBOOT_MAGIC2B369367448
-
-#defineLINUX_REBOOT_CMD_RESTART0x01234567
-#defineLINUX_REBOOT_CMD_HALT0xCDEF0123
-#defineLINUX_REBOOT_CMD_CAD_ON0x89ABCDEF
-#defineLINUX_REBOOT_CMD_CAD_OFF0x00000000
-#defineLINUX_REBOOT_CMD_POWER_OFF0x4321FEDC
-#defineLINUX_REBOOT_CMD_RESTART20xA1B2C3D4
-#define LINUX_REBOOT_CMD_EXEC_KERNEL    0x18273645
 #define LINUX_REBOOT_CMD_KEXEC_OLD0x81726354
 #define LINUX_REBOOT_CMD_KEXEC_OLD20x18263645
 #define LINUX_REBOOT_CMD_KEXEC0x45584543
< at >< at > -70,12 +58,6 < at >< at > static inline long kexec_load(void *entry, unsigned long nr_segments,
 return (long) syscall(__NR_kexec_load, entry, nr_segments, segments, flags);
 }
 
-static inline long kexec_reboot(void)
-{
-return (long) syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_KEXEC, 0);
-}
-
-
 #define KEXEC_ON_CRASH0x00000001
 #define KEXEC_PRESERVE_CONTEXT0x00000002
 #define KEXEC_ARCH_MASK0xffff0000
diff --git a/kexec/kexec.c b/kexec/kexec.c
index d2d05a8..3572c5b 100644
--- a/kexec/kexec.c
+++ b/kexec/kexec.c
< at >< at > -28,6 +28,7 < at >< at >
 #include <limits.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/reboot.h>
 #include <unistd.h>
 #include <fcntl.h>
 #ifndef _O_BINARY
< at >< at > -822,7 +823,7 < at >< at > static int my_shutdown(void)
  */
 static int my_exec(void)
 {
-kexec_reboot();
+reboot(LINUX_REBOOT_CMD_KEXEC);
 /* I have failed if I make it here */
 fprintf(stderr, "kexec failed: %s\n", 
 strerror(errno));

[PATCH] kexec: simply pass LINUX_REBOOT_CMD_KEXEC to reboot

maximilian attems — 2012-05-22T16:09:58

While trying to port kexec cleanly to klibc,
came across this syscall usage for reboot(2).
Calling reboot directly simplifies the code.

Signed-off-by: maximilian attems <max-U9r9yeDMy7A< at >public.gmane.org>
---
 kexec/kexec-syscall.h |   20 --------------------
 kexec/kexec.c         |    4 +++-
 2 files changed, 3 insertions(+), 21 deletions(-)

The next TODO item is to add proper syscall kexec_load() to glibc.
Funnily here klibc has an head start! -maks

diff --git a/kexec/kexec-syscall.h b/kexec/kexec-syscall.h
index f4df45c..415fbd7 100644
--- a/kexec/kexec-syscall.h
+++ b/kexec/kexec-syscall.h
< at >< at > -5,22 +5,6 < at >< at >
 #include <sys/syscall.h>
 #include <unistd.h>
 
-#defineLINUX_REBOOT_MAGIC10xfee1dead
-#defineLINUX_REBOOT_MAGIC2672274793
-#defineLINUX_REBOOT_MAGIC2A85072278
-#defineLINUX_REBOOT_MAGIC2B369367448
-
-#defineLINUX_REBOOT_CMD_RESTART0x01234567
-#defineLINUX_REBOOT_CMD_HALT0xCDEF0123
-#defineLINUX_REBOOT_CMD_CAD_ON0x89ABCDEF
-#defineLINUX_REBOOT_CMD_CAD_OFF0x00000000
-#defineLINUX_REBOOT_CMD_POWER_OFF0x4321FEDC
-#defineLINUX_REBOOT_CMD_RESTART20xA1B2C3D4
-#define LINUX_REBOOT_CMD_EXEC_KERNEL    0x18273645
-#define LINUX_REBOOT_CMD_KEXEC_OLD0x81726354
-#define LINUX_REBOOT_CMD_KEXEC_OLD20x18263645
-#define LINUX_REBOOT_CMD_KEXEC0x45584543
-
 #ifndef __NR_kexec_load
 #ifdef __i386__
 #define __NR_kexec_load283
< at >< at > -70,10 +54,6 < at >< at > static inline long kexec_load(void *entry, unsigned long nr_segments,
 return (long) syscall(__NR_kexec_load, entry, nr_segments, segments, flags);
 }
 
-static inline long kexec_reboot(void)
-{
-return (long) syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_KEXEC, 0);
-}
 
 
 #define KEXEC_ON_CRASH0x00000001
diff --git a/kexec/kexec.c b/kexec/kexec.c
index d2d05a8..ee23b5e 100644
--- a/kexec/kexec.c
+++ b/kexec/kexec.c
< at >< at > -28,6 +28,8 < at >< at >
 #include <limits.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/reboot.h>
+#include <linux/reboot.h>
 #include <unistd.h>
 #include <fcntl.h>
 #ifndef _O_BINARY
< at >< at > -822,7 +824,7 < at >< at > static int my_shutdown(void)
  */
 static int my_exec(void)
 {
-kexec_reboot();
+reboot(LINUX_REBOOT_CMD_KEXEC);
 /* I have failed if I make it here */
 fprintf(stderr, "kexec failed: %s\n", 
 strerror(errno));

[PATCH] Use HOSTCC for build utilities

Baruch Even — 2012-05-20T00:00:05

Subject: [PATCH] Use HOSTCC for build utilities

bin-to-hex is used during the build and needs to be compiled with the host
compiler to be able to run during the build.

Signed-off-by: Baruch Even <baruch-6P1Dz+XQpLLYtjvyW6yDsg< at >public.gmane.org>
---
 util/Makefile |    4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/util/Makefile b/util/Makefile
index 948ee63..82c7407 100644
--- a/util/Makefile
+++ b/util/Makefile
< at >< at > -4,8 +4,8 < at >< at > $(BIN_TO_HEX): $(srcdir)/util/bin-to-hex.c
 < at >$(MKDIR) -p $(< at >D)
 $(LINK.o) $(CFLAGS) -o $< at > $^

-$(BIN_TO_HEX): CC=$(BUILD_CC)
-$(BIN_TO_HEX): CFLAGS=$(BUILD_CFLAGS)
+$(BIN_TO_HEX): CC=$(HOSTCC)
+$(BIN_TO_HEX): CFLAGS=$(HOST_CFLAGS)
 $(BIN_TO_HEX): LDFLAGS=

 dist += util/Makefile util/bin-to-hex.c

Your Mailbox Is Almost Full

Cerda, Weston — 2012-05-18T07:33:42

Your Mailbox Is Almost Full "CLICK HERE<https://docs.google.com/spreadsheet/viewform?formkey=dE1tZWZNRzVyalFmbG9JOUNERzF5enc6MQ>" Update Your MailBox And Increase Your Account. Thanks System Administrator.

[v2 PATCH] ppc: move DEBUG code to --debug

Cong Wang — 2012-05-14T06:34:56

From: Cong Wang <xiyou.wangcong-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org>


From: Cong Wang <xiyou.wangcong-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org>
V2: Fix a compile error

Like commit 28d4ab53280853d2aeefdfb7c369331e89ab9ac2
("Add generic debug option"), this one moves code
under #if DEBUG to --debug on ppc arch.

Sorry that I still can't find a ppc32 machine to test this.

Cc: Simon Horman <horms-/R6kz+dDXgpPR4JQBCEnsQ< at >public.gmane.org>
Signed-off-by: Cong Wang <xiyou.wangcong-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org>
---
 kexec/arch/ppc/crashdump-powerpc.c |   18 ++++++++----------
 kexec/arch/ppc/fixup_dtb.c         |   32 ++++++++++++++------------------
 kexec/arch/ppc/fs2dt.c             |    6 +++---
 kexec/arch/ppc/kexec-ppc.c         |   17 ++++++++---------
 kexec/arch/ppc/libfdt-wrapper.c    |    4 ++--
 kexec/arch/ppc64/crashdump-ppc64.c |   16 ++++++----------
 kexec/arch/ppc64/kexec-elf-ppc64.c |   23 +++++++++++------------
 kexec/arch/ppc64/kexec-ppc64.c     |    9 +++------
 8 files changed, 55 insertions(+), 70 deletions(-)

diff --git a/kexec/arch/ppc/crashdump-powerpc.c b/kexec/arch/ppc/crashdump-powerpc.c
index 7c9dbff..1bef69b 100644
--- a/kexec/arch/ppc/crashdump-powerpc.c
+++ b/kexec/arch/ppc/crashdump-powerpc.c
< at >< at > -226,15 +226,15 < at >< at > static int get_crash_memory_ranges(struct memory_range **range, int *ranges)
 
 *range = crash_memory_range;
 *ranges = memory_ranges;
-#if DEBUG
+
 int j;
-printf("CRASH MEMORY RANGES\n");
+dbgprintf("CRASH MEMORY RANGES\n");
 for (j = 0; j < *ranges; j++) {
 start = crash_memory_range[j].start;
 end = crash_memory_range[j].end;
-fprintf(stderr, "%016Lx-%016Lx\n", start, end);
+dbgprintf("%016Lx-%016Lx\n", start, end);
 }
-#endif
+
 return 0;
 
 err:
< at >< at > -289,9 +289,9 < at >< at > static int add_cmdline_param(char *cmdline, unsigned long long addr,
 if (cmdlen > (COMMAND_LINE_SIZE - 1))
 die("Command line overflow\n");
 strcat(cmdline, str);
-#if DEBUG
-fprintf(stderr, "Command line after adding elfcorehdr: %s\n", cmdline);
-#endif
+
+dbgprintf("Command line after adding elfcorehdr: %s\n", cmdline);
+
 return 0;
 }
 
< at >< at > -403,10 +403,8 < at >< at > void add_usable_mem_rgns(unsigned long long base, unsigned long long size)
 usablemem_rgns.ranges[usablemem_rgns.size].start = base;
 usablemem_rgns.ranges[usablemem_rgns.size++].end = end;
 
-#ifdef DEBUG
-fprintf(stderr, "usable memory rgns size:%u base:%llx size:%llx\n",
+dbgprintf("usable memory rgns size:%u base:%llx size:%llx\n",
 usablemem_rgns.size, base, size);
-#endif
 }
 
 int is_crashkernel_mem_reserved(void)
diff --git a/kexec/arch/ppc/fixup_dtb.c b/kexec/arch/ppc/fixup_dtb.c
index 189e0c7..e9890a4 100644
--- a/kexec/arch/ppc/fixup_dtb.c
+++ b/kexec/arch/ppc/fixup_dtb.c
< at >< at > -17,25 +17,26 < at >< at >
 
 const char proc_dts[] = "/proc/device-tree";
 
-#ifdef DEBUG
-static void print_fdt_reserve_regions(void)
+static void print_fdt_reserve_regions(char *blob_buf)
 {
 int i, num;
 
+if (!kexec_debug)
+return;
 /* Print out a summary of the final reserve regions */
 num =  fdt_num_mem_rsv(blob_buf);
-printf ("reserve regions: %d\n", num);
+dbgprintf ("reserve regions: %d\n", num);
 for (i = 0; i < num; i++) {
 uint64_t offset, size;
 
 if (fdt_get_mem_rsv(blob_buf, i, &offset, &size) == 0) {
-printf("%d: offset: %llx, size: %llx\n", i, offset, size);
+dbgprintf("%d: offset: %llx, size: %llx\n", i, offset, size);
 } else {
-printf("Error retreiving reserved region\n");
+dbgprintf("Error retreiving reserved region\n");
 }
 }
 }
-#endif
+
 
 static void fixup_nodes(char *nodes[])
 {
< at >< at > -201,11 +202,8 < at >< at > static void fixup_reserve_regions(struct kexec_info *info, char *blob_buf)
 "device_type", "cpu", 4);
 }
 
-out:;
-
-#ifdef DEBUG
-print_fdt_reserve_regions();
-#endif
+out:
+print_fdt_reserve_regions(blob_buf);
 }
 
 static void fixup_memory(struct kexec_info *info, char *blob_buf)
< at >< at > -369,23 +367,23 < at >< at > char *fixup_dtb_init(struct kexec_info *info, char *blob_buf, off_t *blob_size,
 return blob_buf;
 }
 
-#ifdef DEBUG
 static void save_fixed_up_dtb(char *blob_buf, off_t blob_size)
 {
 FILE *fp;
 
+if (!kexec_debug)
+return;
 fp = fopen("debug.dtb", "w");
 if (fp) {
 if ( blob_size == fwrite(blob_buf, sizeof(char), blob_size, fp)) {
-printf("debug.dtb written\n");
+dbgprintf("debug.dtb written\n");
 } else {
-printf("Unable to write debug.dtb\n");
+dbgprintf("Unable to write debug.dtb\n");
 }
 } else {
-printf("Unable to dump flat device tree to debug.dtb\n");
+dbgprintf("Unable to dump flat device tree to debug.dtb\n");
 }
 }
-#endif
 
 char *fixup_dtb_finalize(struct kexec_info *info, char *blob_buf, off_t *blob_size,
 char *nodes[], char *cmdline)
< at >< at > -400,9 +398,7 < at >< at > char *fixup_dtb_finalize(struct kexec_info *info, char *blob_buf, off_t *blob_si
 blob_buf = (char *)dt_ops.finalize();
 *blob_size = fdt_totalsize(blob_buf);
 
-#ifdef DEBUG
 save_fixed_up_dtb(blob_buf, *blob_size);
-#endif
 
 return blob_buf;
 }
diff --git a/kexec/arch/ppc/fs2dt.c b/kexec/arch/ppc/fs2dt.c
index 733515a..cdae69e 100644
--- a/kexec/arch/ppc/fs2dt.c
+++ b/kexec/arch/ppc/fs2dt.c
< at >< at > -273,9 +273,9 < at >< at > static void putprops(char *fn, struct dirent **nlist, int numlist)
 memcpy(dt, local_cmdline, cmd_len);
 len = cmd_len;
 *dt_len = cmd_len;
-#ifDEBUG
-fprintf(stderr, "Modified cmdline:%s\n", local_cmdline);
-#endif
+
+dbgprintf("Modified cmdline:%s\n", local_cmdline);
+
 }
 
 dt += (len + 3)/4;
diff --git a/kexec/arch/ppc/kexec-ppc.c b/kexec/arch/ppc/kexec-ppc.c
index 57852dc..6075477 100644
--- a/kexec/arch/ppc/kexec-ppc.c
+++ b/kexec/arch/ppc/kexec-ppc.c
< at >< at > -378,9 +378,9 < at >< at > static int get_base_ranges(void)
 nr_memory_ranges = local_memory_ranges;
 sort_base_ranges();
 memory_max = base_memory_range[nr_memory_ranges - 1].end;
-#ifdef DEBUG
-fprintf(stderr, "get base memory ranges:%d\n", nr_memory_ranges);
-#endif
+
+dbgprintf("get base memory ranges:%d\n", nr_memory_ranges);
+
 return 0;
 }
 
< at >< at > -716,13 +716,13 < at >< at > static int get_devtree_details(unsigned long kexec_flags)
 
 sort_ranges();
 
-#ifdef DEBUG
+
 int k;
 for (k = 0; k < i; k++)
-fprintf(stderr, "exclude_range sorted exclude_range[%d] "
+dbgprintf("exclude_range sorted exclude_range[%d] "
 "start:%llx, end:%llx\n", k, exclude_range[k].start,
 exclude_range[k].end);
-#endif
+
 return 0;
 
 error_openfile:
< at >< at > -812,13 +812,12 < at >< at > static int setup_memory_ranges(unsigned long kexec_flags)
 } else
 nr_memory_ranges = j;
 
-#ifdef DEBUG
+
 int k;
 for (k = 0; k < j; k++)
-fprintf(stderr, "setup_memory_ranges memory_range[%d] "
+dbgprintf("setup_memory_ranges memory_range[%d] "
 "start:%llx, end:%llx\n", k, memory_range[k].start,
 memory_range[k].end);
-#endif
 return 0;
 
 out:
diff --git a/kexec/arch/ppc/libfdt-wrapper.c b/kexec/arch/ppc/libfdt-wrapper.c
index f56ccc0..5fbd3a8 100644
--- a/kexec/arch/ppc/libfdt-wrapper.c
+++ b/kexec/arch/ppc/libfdt-wrapper.c
< at >< at > -27,15 +27,15 < at >< at >
 #include <page.h>
 #include <libfdt.h>
 #include "ops.h"
+#include "../../kexec.h"
 
-#define DEBUG0
 #define BAD_ERROR(err)(((err) < 0) \
  && ((err) != -FDT_ERR_NOTFOUND) \
  && ((err) != -FDT_ERR_EXISTS))
 
 #define check_err(err) \
 ({ \
-if (BAD_ERROR(err) || ((err < 0) && DEBUG)) \
+if (BAD_ERROR(err) || ((err < 0) && kexec_debug)) \
 printf("%s():%d  %s\n\r", __func__, __LINE__, \
        fdt_strerror(err)); \
 if (BAD_ERROR(err)) \
diff --git a/kexec/arch/ppc64/crashdump-ppc64.c b/kexec/arch/ppc64/crashdump-ppc64.c
index b5ec2c8..30ef443 100644
--- a/kexec/arch/ppc64/crashdump-ppc64.c
+++ b/kexec/arch/ppc64/crashdump-ppc64.c
< at >< at > -304,15 +304,15 < at >< at > static int get_crash_memory_ranges(struct memory_range **range, int *ranges)
 
 *range = crash_memory_range;
 *ranges = memory_ranges;
-#if DEBUG
+
 int j;
-printf("CRASH MEMORY RANGES\n");
+dbgprintf("CRASH MEMORY RANGES\n");
 for(j = 0; j < *ranges; j++) {
 start = crash_memory_range[j].start;
 end = crash_memory_range[j].end;
-fprintf(stderr, "%016Lx-%016Lx\n", start, end);
+dbgprintf("%016Lx-%016Lx\n", start, end);
 }
-#endif
+
 return 0;
 
 err:
< at >< at > -367,9 +367,7 < at >< at > static int add_cmdline_param(char *cmdline, uint64_t addr, char *cmdstr,
 if (cmdlen > (COMMAND_LINE_SIZE - 1))
 die("Command line overflow\n");
 strcat(cmdline, str);
-#if DEBUG
-fprintf(stderr, "Command line after adding elfcorehdr: %s\n", cmdline);
-#endif
+dbgprintf("Command line after adding elfcorehdr: %s\n", cmdline);
 return 0;
 }
 
< at >< at > -490,10 +488,8 < at >< at > void add_usable_mem_rgns(unsigned long long base, unsigned long long size)
 usablemem_rgns.ranges[usablemem_rgns.size].start = base;
 usablemem_rgns.ranges[usablemem_rgns.size++].end = end;
 
-#ifdef DEBUG
-fprintf(stderr, "usable memory rgns size:%u base:%llx size:%llx\n",
+dbgprintf("usable memory rgns size:%u base:%llx size:%llx\n",
 usablemem_rgns.size, base, size);
-#endif
 }
 
 int is_crashkernel_mem_reserved(void)
diff --git a/kexec/arch/ppc64/kexec-elf-ppc64.c b/kexec/arch/ppc64/kexec-elf-ppc64.c
index abd83dd..f68f2bc 100644
--- a/kexec/arch/ppc64/kexec-elf-ppc64.c
+++ b/kexec/arch/ppc64/kexec-elf-ppc64.c
< at >< at > -294,7 +294,7 < at >< at > int elf_ppc64_load(int argc, char **argv, const char *buf, off_t len,
 
 /* Set debug */
 elf_rel_set_symbol(&info->rhdr, "debug", &my_debug, sizeof(my_debug));
-#ifdef DEBUG
+
 my_kernel = 0;
 my_dt_offset = 0;
 my_panic_kernel = 0;
< at >< at > -318,19 +318,18 < at >< at > int elf_ppc64_load(int argc, char **argv, const char *buf, off_t len,
 sizeof(toc_addr));
 elf_rel_get_symbol(&info->rhdr, "debug", &my_debug, sizeof(my_debug));
 
-fprintf(stderr, "info->entry is %p\n", info->entry);
-fprintf(stderr, "kernel is %llx\n", (unsigned long long)my_kernel);
-fprintf(stderr, "dt_offset is %llx\n",
+dbgprintf("info->entry is %p\n", info->entry);
+dbgprintf("kernel is %llx\n", (unsigned long long)my_kernel);
+dbgprintf("dt_offset is %llx\n",
 (unsigned long long)my_dt_offset);
-fprintf(stderr, "run_at_load flag is %x\n", my_run_at_load);
-fprintf(stderr, "panic_kernel is %x\n", my_panic_kernel);
-fprintf(stderr, "backup_start is %llx\n",
+dbgprintf("run_at_load flag is %x\n", my_run_at_load);
+dbgprintf("panic_kernel is %x\n", my_panic_kernel);
+dbgprintf("backup_start is %llx\n",
 (unsigned long long)my_backup_start);
-fprintf(stderr, "stack is %llx\n", (unsigned long long)my_stack);
-fprintf(stderr, "toc_addr is %llx\n", (unsigned long long)toc_addr);
-fprintf(stderr, "purgatory size is %zu\n", purgatory_size);
-fprintf(stderr, "debug is %d\n", my_debug);
-#endif
+dbgprintf("stack is %llx\n", (unsigned long long)my_stack);
+dbgprintf("toc_addr is %llx\n", (unsigned long long)toc_addr);
+dbgprintf("purgatory size is %zu\n", purgatory_size);
+dbgprintf("debug is %d\n", my_debug);
 
 for (i = 0; i < info->nr_segments; i++)
 fprintf(stderr, "segment[%d].mem:%p memsz:%zu\n", i,
diff --git a/kexec/arch/ppc64/kexec-ppc64.c b/kexec/arch/ppc64/kexec-ppc64.c
index 48ea421..2f12907 100644
--- a/kexec/arch/ppc64/kexec-ppc64.c
+++ b/kexec/arch/ppc64/kexec-ppc64.c
< at >< at > -594,13 +594,12 < at >< at > static int get_devtree_details(unsigned long kexec_flags)
 
 sort_ranges();
 
-#ifdef DEBUG
 int k;
 for (k = 0; k < i; k++)
-fprintf(stderr, "exclude_range sorted exclude_range[%d] "
+dbgprintf("exclude_range sorted exclude_range[%d] "
 "start:%llx, end:%llx\n", k, exclude_range[k].start,
 exclude_range[k].end);
-#endif
+
 return 0;
 
 error_openfile:
< at >< at > -687,13 +686,11 < at >< at > int setup_memory_ranges(unsigned long kexec_flags)
 }
 nr_memory_ranges = j;
 
-#ifdef DEBUG
 int k;
 for (k = 0; k < j; k++)
-fprintf(stderr, "setup_memory_ranges memory_range[%d] "
+dbgprintf("setup_memory_ranges memory_range[%d] "
 "start:%llx, end:%llx\n", k, memory_range[k].start,
 memory_range[k].end);
-#endif
 return 0;
 
 out:

kexec from live image failing periodically

2012-05-10T20:12:11

Hello,

I am trying to run kexec into the RHEL62 kickstart installer from a RHEL62
LiveCD.

It works most of the time, but sometimes it fails with a kernel crash
stack.

The last message before the crash is always:

"Trying to unpack rootfs image as initramfs...."


Below is a sample stack from the crash.

Does any one have any clues on tracking down this issue?

Cheers,
Ivan


BUG: soft lockup - CPU#0 stuck for 67s! [swapper:1]
Modules linked in:
CPU 0 
Modules linked in:

Pid: 1, comm: swapper Not tainted 2.6.32-220.el6.x86_64 #1 EMC
S2600GZ/S2600GZ
RIP: 0010:[<ffffffff81c4c8d8>]  [<ffffffff81c4c8d8>] rc_get_bit+0x6/0x79
RSP: 0018:ffff88102ceadce8  EFLAGS: 00000246
RAX: 0000000000000007 RBX: ffff88102ceadcf0 RCX: 0000000000000000
RDX: ffff88102ceaddfc RSI: ffffc90016e47686 RDI: ffff88102ceaddb0
RBP: ffffffff8100bc0e R08: ffffc90016e47678 R09: 0000000000000003
R10: 0000000000000003 R11: 0000000000000000 R12: 0000000004000605
R13: 000000000acff908 R14: ffffc90016e47644 R15: 0000000000000003
FS:  0000000000000000(0000) GS:ffff880044600000(0000)
knlGS:0000000000000000
CS:  0010 DS: 0018 ES: 0018 CR0: 000000008005003b
CR2: 00007f42971e7730 CR3: 0000000001a85000 CR4: 00000000000406f0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
Process swapper (pid: 1, threadinfo ffff88102ceac000, task
ffff88082c9554c0)
Stack:
 0000000000000000 ffff88102ceade30 ffffffff81c4d449 ffff881000000003
<0> ffffc90016e47678 ffffffff00000000 ffffffff81dd32b8 0000000000000000
<0> ffff88007e3b7000 ffff88007e3b7000 0000000000000003 0000000000000051
Call Trace:
 [<ffffffff81c4d449>] ? unlzma+0xa73/0xd21
 [<ffffffff8115e832>] ? fallback_alloc+0x12/0x270
 [<ffffffff81c21b25>] ? flush_buffer+0x0/0xa3
 [<ffffffff8126aa30>] ? nofill+0x0/0x10
 [<ffffffff81c228d2>] ? unpack_to_rootfs+0x1d9/0x2ec
 [<ffffffff81c21995>] ? error+0x0/0x17
 [<ffffffff81c4e381>] ? pci_apply_final_quirks+0x0/0x35
 [<ffffffff81c22a88>] ? populate_rootfs+0x0/0xd3
 [<ffffffff81c22ae3>] ? populate_rootfs+0x5b/0xd3
 [<ffffffff8100204c>] ? do_one_initcall+0x3c/0x1d0
 [<ffffffff81c1f8cb>] ? kernel_init+0x29d/0x2f9
 [<ffffffff8100c14a>] ? child_rip+0xa/0x20
 [<ffffffff81c1f62e>] ? kernel_init+0x0/0x2f9
 [<ffffffff8100c140>] ? child_rip+0x0/0x20
Code: 08 09 d0 89 43 24 0f b7 06 8b 53 28 c1 ea 0b 0f af c2 39 43 24 89 43
2c 0f 92 c0 48 83 c4 18 0f b6 c0 5b c9 c3 55 48 89 e5 41 55 <49> 89 d5 41
54 49 89 f4 53 48 89 fb 48 83 ec 08 e8 7c ff ff ff
Call Trace:
 [<ffffffff81c4d449>] ? unlzma+0xa73/0xd21
 [<ffffffff8115e832>] ? fallback_alloc+0x12/0x270
 [<ffffffff81c21b25>] ? flush_buffer+0x0/0xa3
 [<ffffffff8126aa30>] ? nofill+0x0/0x10
 [<ffffffff81c228d2>] ? unpack_to_rootfs+0x1d9/0x2ec
 [<ffffffff81c21995>] ? error+0x0/0x17
 [<ffffffff81c4e381>] ? pci_apply_final_quirks+0x0/0x35
 [<ffffffff81c22a88>] ? populate_rootfs+0x0/0xd3
 [<ffffffff81c22ae3>] ? populate_rootfs+0x5b/0xd3
 [<ffffffff8100204c>] ? do_one_initcall+0x3c/0x1d0
 [<ffffffff81c1f8cb>] ? kernel_init+0x29d/0x2f9
 [<ffffffff8100c14a>] ? child_rip+0xa/0x20
 [<ffffffff81c1f62e>] ? kernel_init+0x0/0x2f9
 [<ffffffff8100c140>] ? child_rip+0x0/0x20

PROJECT(reply via gaddafisaadi-dbdLmdGazhY< at >public.gmane.org )

Contact — 2012-05-10T09:28:50

I would like to discuss a project with you.Please email me back.via gaddafisaadi-dbdLmdGazhY< at >public.gmane.org  if interested

WESTERN UNION

Western Union Money Transfer — 2012-04-28T21:22:06

Attn, We are grateful to contact you and announce to you that your e-mail was
among the listed beneficiary that won our western union on-line award.
 
Contact us upon receipt of this mail with the requested information below to
enable us file your information to your location country payment zone:
 
1*First Name :...........
2*Last Name :..............
3*Gender :..........
4*Occupation:.........
5*Home Telephone Number :...............
6*Mobile Telephone Number :..............
7*State :..........
8*Country :......................
9*Age:...................
 
Once again congratulation, and have a nice day.
NOTE: Due to poor network service HERE,You may receive this Notification as 
junk/spam
 
Name: Manager Mr Christopher Roland
Tel: +2348071169011
western.union.money.trasfer.westafrica-FmXjaEvEckLQT0dZR+AlfA< at >public.gmane.org
©2012- Western Union Holdings

makedumpfile availability for x86 3.2 kernels

Bouchard Louis — 2012-04-26T20:27:31

Hello Kumagai-san,

Do you have an idea of the availability of makedumpfile for 3.2 flavor
kernels ?

Ubuntu 12.04 Precise have just been released today and, since it is
based on a 3.2 kernel, makedumpfile no longer works for it.

Kind regards,

...Louis

[RFC PATCH V2] Disable Bus Master bit on PCI device shutdown

Khalid Aziz — 2012-04-26T18:30:42

Eric suggested I disable bus master bit in PCI susbsystem instead
and that makes perfect sense. So here is take 2 on this patch. Please
review and let me know if I missed anything.


Subject: [PATCH] Disable Bus Master bit on the device in
 pci_device_shutdown() to ensure PCI devices do not continue
 to DMA data after shutdown. This can cause memory
 corruption in case of a kexec where the current kernel
 shuts down and transfers control to a new kernel while a
 PCI device continues to DMA to memory that does not belong
 to it any more in the new kernel.


Signed-off-by: Khalid Aziz <khalid.aziz-VXdhtT5mjnY< at >public.gmane.org>
---
 drivers/pci/pci-driver.c |    6 ++++++
 1 files changed, 6 insertions(+), 0 deletions(-)

diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 6b54b23..9db5940 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
< at >< at > -420,6 +420,12 < at >< at > static void pci_device_shutdown(struct device *dev)
 pci_msi_shutdown(pci_dev);
 pci_msix_shutdown(pci_dev);
 
+/* 
+ * Turn off Bus Master bit on the device to tell it to not
+ * continue to do DMA
+ */
+pci_disable_device(pci_dev);
+
 /*
  * Devices may be enabled to wake up by runtime PM, but they need not
  * be supposed to wake up the system from its "power off" state (e.g.

[PATCH] Correct section number for shutdown and clarify what -e does in manpage

Khalid Aziz — 2012-04-20T16:39:14

Another patch that I have been carrying in debian kexec-tools package. 
It corrects the section number for shutdown in the man page. This
patch also adds little more descriptive note for the -e option to
clarify that this does not do an orderly shutdown.

Please apply.

Signed-off-by: Khalid Aziz <khalid.aziz-VXdhtT5mjnY< at >public.gmane.org>
---
 kexec/kexec.8 |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/kexec/kexec.8 b/kexec/kexec.8
index da03c40..aff674c 100644
--- a/kexec/kexec.8
+++ b/kexec/kexec.8
< at >< at > -71,7 +71,7 < at >< at > It's also possible to invoke
 .B kexec
 without an option parameter. In that case, kexec loads the specified
 kernel and then invokes
-.BR shutdown (1).
+.BR shutdown (8).
 If the shutdown scripts of your Linux distribution support
 kexec-based rebooting, they then call
 .B kexec
< at >< at > -105,13 +105,13 < at >< at > command:
 .SH OPTIONS
 .TP
 .B \-e\ (\-\-exec)
-Run the currently loaded kernel.
+Run the currently loaded kernel. Note that it will reboot into the loaded kernel without calling shutdown(8).
 .TP
 .B \-f\ (\-\-force)
 Force an immediate
 .B kexec
 call, do not call
-.BR shutdown (1)
+.BR shutdown (8)
 (contrary to the default action without any option parameter). This option
 performs the same actions like executing
 .IR -l

[PATCH] kexec-tools: Fix CRC calculation for padded uImage

Helmut Schaa — 2012-04-20T09:58:16

Instead of calulating the CRC on the whole file just calculate the CRC
on the actual uImage length as given by the uImage header. This fixes
loading padded uImages, for example from a mtd partition.

Signed-off-by: Helmut Schaa <helmut.schaa-gM/Ye1E23mwN+BqQ9rBEUg< at >public.gmane.org>
---
 kexec/kexec-uImage.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

diff --git a/kexec/kexec-uImage.c b/kexec/kexec-uImage.c
index 409e516..83e7910 100644
--- a/kexec/kexec-uImage.c
+++ b/kexec/kexec-uImage.c
< at >< at > -72,7 +72,7 < at >< at > int uImage_probe(const unsigned char *buf, off_t len, unsigned int arch)
 return -1;
 }
 #ifdef HAVE_LIBZ
-crc = crc32(0, (void *)buf + sizeof(header), len - sizeof(header));
+crc = crc32(0, (void *)buf + sizeof(header), be32_to_cpu(header.ih_size));
 if (crc != be32_to_cpu(header.ih_dcrc)) {
 printf("The data CRC does not match. Computed: %08x "
 "expected %08x\n", crc,

(unknown)

Nasy Merly Ysea — 2012-04-14T04:02:37


Dear Sir/Madam
----------------------------------------------------------------------------------------

____________________________AVISO LEGAL_______________________________

Este mensaje es privado y confidencial, y esta dirigido exclusivamente
a su(s) destinatario(s).   Si usted ha recibido este mensaje por 
error, debe abstenerse de distribuirlo, copiarlo o usarlo en cualquier
sentido. Asi mismo, le agradecemos comunicarlo al remitente y borrar el 
mensaje y cualquier documento adjunto. 
Cualquier opinión contenida en este mensaje pertenece unicamente al
autor remitente y no representa necesariamente la opinión del
Ministerio del Poder Popular del Despacho de la Presidencia, a menos
que ello se señale en forma expresa.
Eventualmente, los correos electronicos pueden ser interceptados o
alterados, llegar con demora o incompletos. Al respecto, el Ministerio
del Poder Popular del Despacho de la Presidencia no se hace
responsable por los errores, defectos u omisiones que pudieran afectar
al mensaje original, con motivo de su envio por correo electronico.

_______________________________________________
kexec mailing list
kexec< at >lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kexec

[PATCH] Add more debug infos when usable memory range changing

Han Pingtian — 2012-04-13T09:32:42

In the past, we did neglected some usable memory range
changing infos. With those deubg code added, we can now
catch them.
---
 kexec/arch/ppc64/crashdump-ppc64.c |   12 ++++++++++++
 1 files changed, 12 insertions(+), 0 deletions(-)

diff --git a/kexec/arch/ppc64/crashdump-ppc64.c b/kexec/arch/ppc64/crashdump-ppc64.c
index d52b438..b5ec2c8 100644
--- a/kexec/arch/ppc64/crashdump-ppc64.c
+++ b/kexec/arch/ppc64/crashdump-ppc64.c
< at >< at > -465,12 +465,24 < at >< at > void add_usable_mem_rgns(unsigned long long base, unsigned long long size)
 if (base < ustart && end > uend) {
 usablemem_rgns.ranges[i].start = base;
 usablemem_rgns.ranges[i].end = end;
+#ifdef DEBUG
+fprintf(stderr, "usable memory rgn %u: new base:%llx new size:%llx\n",
+i, base, size);
+#endif
 return;
 } else if (base < ustart) {
 usablemem_rgns.ranges[i].start = base;
+#ifdef DEBUG
+fprintf(stderr, "usable memory rgn %u: new base:%llx new size:%llx",
+i, base, usablemem_rgns.ranges[i].end - base);
+#endif
 return;
 } else if (end > uend){
 usablemem_rgns.ranges[i].end = end;
+#ifdef DEBUG
+fprintf(stderr, "usable memory rgn %u: new end:%llx, new size:%llx",
+i, end, end - usablemem_rgns.ranges[i].start);
+#endif
 return;
 }
 }

012/03/ZYO12

Tu email ha ganado £375.000

(unknown)

2012-03-29T16:48:25



RS LOANS is now providing financial services & loans .

Are you a business man or woman ? Do you need a loan or funding for any
reason such as : Personal Loan,Business Expansion, Business
Start-up,Education, Hard Money Loans, Investment Loans, etc.

For more information, inquiries and Application, Please Contact our
representative via this e-mail:  jan737.b-j+4cLNCRU+OzR313v1King< at >public.gmane.org

makedumpfile memory usage grows with system memory size

Don Zickus — 2012-03-28T21:22:04

Hello Ken'ichi-san,

I was talking to Vivek about kdump memory requirements and he mentioned
that they vary based on how much system memory is used.

I was interested in knowing why that was and again he mentioned that
makedumpfile needed lots of memory if it was running on a large machine
(for example 1TB of system memory).

Looking through the makedumpfile README and using what Vivek remembered of
makedumpfile, we gathered that as the number of pages grows, the more
makedumpfile has to temporarily store the information in memory.  The
possible reason was to calculate the size of the file before it was copied
to its final destination?

I was curious if that was true and if it was, would it be possible to only
process memory in chunks instead of all at once.

The idea is that a machine with 4Gigs of memory should consume the same
the amount of kdump runtime memory as a 1TB memory system.

Just trying to research ways to keep the memory requirements consistent
across all memory ranges.

Thanks,
Don

Add a descriptive error message for kexec load failure

Khalid Aziz — 2012-03-28T19:09:02

kexec-tools package for debian includes a patch that adds a more 
descriptive error message when someone tries to laod a crash kernel 
and didn't remember to boot up with crashkernel= parameter. This 
patch would be of general interest. This patch was originally written 
by Alastair McKinstry.

Please apply.

Signed-off-by: Khalid Aziz <khalid.aziz-VXdhtT5mjnY< at >public.gmane.org>
---
 kexec/arch/i386/crashdump-x86.c |   10 ++++++----
 kexec/kexec.c                   |   18 ++++++++++++++----
 kexec/kexec.h                   |    6 ++++++
 3 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/kexec/arch/i386/crashdump-x86.c b/kexec/arch/i386/crashdump-x86.c
index 590c883..2af090c 100644
--- a/kexec/arch/i386/crashdump-x86.c
+++ b/kexec/arch/i386/crashdump-x86.c
< at >< at > -776,7 +776,9 < at >< at > int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline,
 memset(memmap_p, 0, sz);
 add_memmap(memmap_p, info->backup_src_start, info->backup_src_size);
 sz = crash_reserved_mem.end - crash_reserved_mem.start +1;
-add_memmap(memmap_p, crash_reserved_mem.start, sz);
+if (add_memmap(memmap_p, crash_reserved_mem.start, sz) < 0) {
+return ENOCRASHKERNEL;
+}
 
 /* Create a backup region segment to store backup data*/
 if (!(info->kexec_flags & KEXEC_PRESERVE_CONTEXT)) {
< at >< at > -788,7 +790,7 < at >< at > int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline,
 dbgprintf("Created backup segment at 0x%lx\n",
   info->backup_start);
 if (delete_memmap(memmap_p, info->backup_start, sz) < 0)
-return -1;
+return EFAILED;
 }
 
 /* Create elf header segment and store crash image data. */
< at >< at > -797,14 +799,14 < at >< at > int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline,
        crash_memory_range, nr_ranges,
        &tmp, &bufsz,
        ELF_CORE_HEADER_ALIGN) < 0)
-return -1;
+return EFAILED;
 }
 else {
 if (crash_create_elf32_headers(info, &elf_info,
        crash_memory_range, nr_ranges,
        &tmp, &bufsz,
        ELF_CORE_HEADER_ALIGN) < 0)
-return -1;
+return EFAILED;
 }
 /* the size of the elf headers allocated is returned in 'bufsz' */
 
diff --git a/kexec/kexec.c b/kexec/kexec.c
index 19133fa..84dab70 100644
--- a/kexec/kexec.c
+++ b/kexec/kexec.c
< at >< at > -718,10 +718,20 < at >< at > static int my_load(const char *type, int fileind, int argc, char **argv,
 }
 info.kexec_flags |= native_arch;
 
-if (file_type[i].load(argc, argv, kernel_buf,
-      kernel_size, &info) < 0) {
-fprintf(stderr, "Cannot load %s\n", kernel);
-return -1;
+result = file_type[i].load(argc, argv, kernel_buf, kernel_size, &info);
+if (result < 0) {
+switch (result) {
+case ENOCRASHKERNEL:
+fprintf(stderr,
+"No crash kernel segment found in /proc/iomem\n"
+"Please check the crashkernel= boot parameter.\n");
+break;
+case EFAILED:
+default:
+fprintf(stderr, "Cannot load %s\n", kernel);
+break;
+}
+return result;
 }
 /* If we are not in native mode setup an appropriate trampoline */
 if (arch_compat_trampoline(&info) < 0) {
diff --git a/kexec/kexec.h b/kexec/kexec.h
index dfd3630..279dfdf 100644
--- a/kexec/kexec.h
+++ b/kexec/kexec.h
< at >< at > -57,6 +57,12 < at >< at >
 #error unknwon BYTE_ORDER
 #endif
 
+/*
+ * Document some of the reasons why crashdump may fail, so we can give
+ * better error messages
+ */
+#define EFAILED-1/* default error code */
+#define ENOCRASHKERNEL-2/* no memory reserved for crashkernel */
 
 /*
  * This function doesn't actually exist.  The idea is that when someone

Fwd: RE: Fwd: Re: makedumpfile security key enhancement using SIAL

Aravinda Prasad — 2012-03-28T17:00:59

Thanks Luc. We will let you know if in case we need any info/help.

I am also forwarding this mail to kexec mailing list.

Regards,
Aravinda


-------- Original Message --------
Subject: RE: Fwd: Re: makedumpfile security key enhancement using SIAL
Date: Wed, 28 Mar 2012 07:07:49 -0400
From: Luc Chouinard <LChouinard-NWkMez96xTsAvxtiuMwx3w< at >public.gmane.org>
To: Aravinda Prasad <aravinda-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>

  Libsial is meant to be a pluggable entity and as such should not 
require other pieces to be there ( crash or gdb).
I want to create project and associated git for the library soon. For 
now you can extract libsial from the crash tar ball and manage any 
modifications using a simple patch mechanism. When the git is available, 
we can merge any fixes or enhancements you created for support of 
makedumpfile.

Makedumpfile and crash would then feed off of specific branches/versions 
of the git repository.
If you have any suggestions or want to help in setting up a public git / 
project page for sial, please let me know.


    -Luc

Hello

2012-03-27T12:57:03

Hello xxxxx,
 How are you doing over there? My name is Laura, Please let
me know if i got the right address so we can open
communication, here is my email address I am waiting for
your confirmation with care Laura...