Source: MontaVista Software, Inc. MR: 37433 Type: Enhancement Disposition: needs submitting to lkcd.sourceforge.net Signed-off-by: Vitaly Kuzmichev Description: Adding LKCD Vmcore validation (completeness checking) feature. diff -urpN crash-3.10-11.orig/check.c crash-3.10-11.new/check.c --- crash-3.10-11.orig/check.c 1970-01-01 03:00:00.000000000 +0300 +++ crash-3.10-11.new/check.c 2010-04-14 10:15:12.000000000 +0400 @@ -0,0 +1,234 @@ +/* check.c - core analysis suite + * + * Copyright (C) 2010 MontaVista Software LLC + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include "check_defs.h" + +int check_pages = 0, only_header = 0, endless = 0, + verbose = 0, silent = 0, + print_header = 1, print_asmheader = 0, print_pages = 0; +off_t dump_header_offset = 0; + +void usage(const char *argv0) +{ + printf("\n"); + printf("%s %s - LKCD vmcore files validation feature\n", + basename(argv0), build_version); + printf("Usage: %s [-abhHpPsSv] FILE\n", argv0); + printf("\t-h\tThis help page\n"); + printf("\t-a\tPrint asm header\n"); + printf("\t-b\tThe FILE is device or device raw dump\n"); + printf("\t-H\tDo not check end page, print only dump header\n"); + printf("\t-p\tCheck all pages in the dump\n"); + printf("\t-P\tPrint each page header verbosely\n"); + printf("\t-s\tBe silent, print only result\n"); + printf("\t-S\tDo not print anything (result will be in return code)\n"); + printf("\t-v\tBe verbose, print all information from dump headers\n"); + printf("\tFILE\tVmcore or device file to check\n"); + printf("\n"); +} + +int main(int argc, char **argv) +{ + uint64_t magic; + uint32_t version; + int fd, opt, result; + char *file; + struct stat sb; + + lkcd_helper + lkcd_check_header = 0, + lkcd_check_asmheader = 0, + lkcd_check_pages = 0, + lkcd_check_end = 0; + /* + * Get and verify command line options. + */ + opterr = 0; + optind = 0; + while((opt = getopt(argc, argv, "abhHpPsSv")) != -1) { + switch (opt) { + case 'a': + print_asmheader = 1; + break; + case 'b': + dump_header_offset = LKCD_DUMP_HEADER_OFFSET; + endless = 1; + break; + case 'h': + usage(argv[0]); + return E_BADARGS; + case 'H': + only_header = 1; + break; + case 'p': + check_pages = 1; + break; + case 'P': + check_pages = 1; + print_pages = 1; + break; + case 's': + silent = 1; + verbose = 0; + break; + case 'S': + silent = 2; + verbose = 0; + break; + case 'v': + silent = 0; + verbose = 1; + break; + default: + usage(argv[0]); + return E_BADARGS; + } + } + + if (optind + 1 != argc) { + usage(argv[0]); + return E_BADARGS; + } + file = argv[optind]; + + if (stat(file, &sb)) { + perror(file); + return E_NOFILE; + } + switch (sb.st_mode & S_IFMT) { + case S_IFBLK: + case S_IFCHR: + dump_header_offset = LKCD_DUMP_HEADER_OFFSET; + endless = 1; + break; + case S_IFREG: + break; + case S_IFLNK: + case S_IFIFO: + case S_IFSOCK: + case S_IFDIR: + default: + usage(argv[0]); + return E_BADARGS; + } + + fd = open(file, O_RDONLY); + if (fd < 0) { + perror(file); + return E_NOFILE; + } + if (silent < 2) { + field("File name"); + printf("%s\n", file); + } + + if (lseek(fd, dump_header_offset, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the dump header at " PRI2offs, + dump_header_offset, dump_header_offset); + goto bad; + } + if (read(fd, &magic, sizeof(uint64_t)) != sizeof(uint64_t)) { + incomplete("Can not read dump magic number"); + goto bad; + } + + if ((magic == LKCD_DUMP_MAGIC_NUMBER) || + (magic == LKCD_DUMP_MAGIC_LIVE)) + init_target_endianess(0); + else { + uint64_t magic2 = bswap_u64(magic); + if ((magic2 == LKCD_DUMP_MAGIC_NUMBER) || + (magic2 == LKCD_DUMP_MAGIC_LIVE)) + init_target_endianess(1); + else { + corrupted("Invalid magic number %" PRIu64 , magic); + goto bad; + } + } + magic = from_target_u64(magic); + + if (read(fd, &version, sizeof(uint32_t)) != sizeof(uint32_t)) { + incomplete("Can not find dump header"); + goto bad; + } + version = from_target_u32(version); + switch (version & ~(LKCD_DUMP_MCLX_V0|LKCD_DUMP_MCLX_V1)) { + case LKCD_DUMP_V1: + lkcd_check_header = lkcd_dump_check_header_v1; + lkcd_check_asmheader = lkcd_dump_check_asmheader_v1; + lkcd_check_pages = lkcd_dump_check_pages_v1; + lkcd_check_end = lkcd_dump_check_end_page_v1; + break; + + case LKCD_DUMP_V2: + case LKCD_DUMP_V3: + lkcd_check_header = lkcd_dump_check_header_v3; + lkcd_check_asmheader = lkcd_dump_check_asmheader_v3; + lkcd_check_pages = lkcd_dump_check_pages_v3; + lkcd_check_end = lkcd_dump_check_end_page_v3; + break; + + case LKCD_DUMP_V5: + case LKCD_DUMP_V6: + case LKCD_DUMP_V7: + lkcd_check_header = lkcd_dump_check_header_v5; + lkcd_check_asmheader = lkcd_dump_check_asmheader_v5; + lkcd_check_pages = lkcd_dump_check_pages_v5; + lkcd_check_end = lkcd_dump_check_end_page_v5; + break; + + case LKCD_DUMP_V8: + lkcd_check_header = lkcd_dump_check_header_v8; + lkcd_check_asmheader = lkcd_dump_check_asmheader_v8; + lkcd_check_pages = lkcd_dump_check_pages_v8; + lkcd_check_end = lkcd_dump_check_end_page_v8; + break; + + default: + corrupted("Unsupported LKCD dump version: %" PRIu32 " (%#" PRIx32 ")", + version & ~(LKCD_DUMP_MCLX_V0|LKCD_DUMP_MCLX_V1), version); + goto bad; + } + + result = lkcd_check_header(fd); + if(!result) + goto broken; + if(only_header) + goto done; + + result = lkcd_check_asmheader(fd); + if(!result) + goto broken; + + if (check_pages || endless) + result = lkcd_check_pages(fd); + else + result = lkcd_check_end(fd); + if (!result) + goto broken; + + complete(); +done: + close(fd); + return E_SUCCESS; +broken: + close(fd); + return E_BROKEN; +bad: + close(fd); + return E_BADFORMAT; +} + diff -urpN crash-3.10-11.orig/check_defs.h crash-3.10-11.new/check_defs.h --- crash-3.10-11.orig/check_defs.h 1970-01-01 03:00:00.000000000 +0300 +++ crash-3.10-11.new/check_defs.h 2010-04-14 10:15:12.000000000 +0400 @@ -0,0 +1,172 @@ +/* check_defs.h - core check suite + * + * Copyright (C) 2010 MontaVista Software LLC + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef __USE_GNU +#define __USE_GNU +#include +#undef __USE_GNU +#else +#include +#endif + +#include "target_types.h" +#undef from_target_u16 +#undef from_target_u32 +#undef from_target_u64 + +#define E_SUCCESS 0 +#define E_BROKEN 1 +#define E_BADFORMAT 2 +#define E_NOFILE 3 +#define E_BADARGS 4 + +#define LKCD_DUMP_MAGIC_NUMBER (0xa8190173618f23edULL) +#define LKCD_DUMP_MAGIC_LIVE (0xa8190173618f23cdULL) + +#define LKCD_DUMP_V1 (0x1) +#define LKCD_DUMP_V2 (0x2) +#define LKCD_DUMP_V3 (0x3) +#define LKCD_DUMP_V5 (0x5) +#define LKCD_DUMP_V6 (0x6) +#define LKCD_DUMP_V7 (0x7) +#define LKCD_DUMP_V8 (0x8) +#define LKCD_DUMP_VERSION_NUMBER_MASK (0xf) + +#define LKCD_DUMP_MCLX_V0 (0x80000000) /* MCLX mod of LKCD */ +#define LKCD_DUMP_MCLX_V1 (0x40000000) /* Extra page header data */ +#define LKCD_OFFSET_TO_FIRST_PAGE (64 * 1024) +#define LKCD_OFFSET_TO_FIRST_BIG_PAGE (256 * 1024) +#define LKCD_DUMP_HEADER_OFFSET (1 << 16) + +#if (defined(__USE_FILE_OFFSET64) || _FILE_OFFSET_BITS == 64 || __WORDSIZE == 64) +#define PRI_off_t(c) __PRI64_PREFIX c +#else +#define PRI_off_t(c) c +#endif +#define PRIuoff_t PRI_off_t("u") +#define PRIxoff_t PRI_off_t("x") +#define PRI2offs "%" PRIuoff_t " (%#" PRIxoff_t ")" +#define PRI2offsNL PRI2offs "\n" + +#undef TRUE +#undef FALSE + +#define TRUE (1) +#define FALSE (0) + +#ifdef CRASH_X86 +#define NR_CPUS (32) +#endif +#ifdef CRASH_X86_64 +#define NR_CPUS (32) +#endif +#ifdef CRASH_ALPHA +#define NR_CPUS (64) +#endif +#ifdef CRASH_PPC +#define NR_CPUS (32) +#endif +#ifdef CRASH_IA64 +#define NR_CPUS (512) +#endif +#ifdef CRASH_PPC64 +#define NR_CPUS (128) +#endif +#ifdef CRASH_S390 +#define NR_CPUS (64) +#endif +#ifdef CRASH_S390X +#define NR_CPUS (64) +#endif +#ifdef CRASH_ARM +#define NR_CPUS (32) +#endif + +struct new_utsname { + char sysname[65]; + char nodename[65]; + char release[65]; + char version[65]; + char machine[65]; + char domainname[65]; +}; + +typedef int (*lkcd_helper)(int fd); + +extern int silent; +extern int verbose; +extern int print_header; +extern int print_asmheader; +extern int print_pages; +extern int check_pages; +extern int only_header; +extern int endless; +extern off_t dump_header_offset; +extern char *build_version; + +uint16_t bswap_u16(uint16_t v); +uint32_t bswap_u32(uint32_t v); +uint64_t bswap_u64(uint64_t v); +uint16_t dummy_u16(uint16_t v); +uint32_t dummy_u32(uint32_t v); +uint64_t dummy_u64(uint64_t v); + +typedef uint16_t (*target_conv_u16)(uint16_t v); +typedef uint32_t (*target_conv_u32)(uint32_t v); +typedef uint64_t (*target_conv_u64)(uint64_t v); +extern target_conv_u16 from_target_u16; +extern target_conv_u32 from_target_u32; +extern target_conv_u64 from_target_u64; + +void init_target_endianess(int swap); + +int field(const char *str); +int corrupted(const char *fmt, ...) __attribute__ ((format (printf, 1, 2))); +int incomplete(const char *fmt, ...) __attribute__ ((format (printf, 1, 2))); +int complete(); + +void arch_print_pt_regs(struct target_pt_regs *regs); + +int lkcd_dump_check_header_v1(int fd); +int lkcd_dump_check_asmheader_v1(int fd); +int lkcd_dump_check_pages_v1(int fd); +int lkcd_dump_check_end_page_v1(int fd); + +int lkcd_dump_check_header_v3(int fd); +int lkcd_dump_check_asmheader_v3(int fd); +int lkcd_dump_check_pages_v3(int fd); +int lkcd_dump_check_end_page_v3(int fd); + +int lkcd_dump_check_header_v5(int fd); +int lkcd_dump_check_asmheader_v5(int fd); +int lkcd_dump_check_pages_v5(int fd); +int lkcd_dump_check_end_page_v5(int fd); + +int lkcd_dump_check_header_v8(int fd); +int lkcd_dump_check_asmheader_v8(int fd); +int lkcd_dump_check_pages_v8(int fd); +int lkcd_dump_check_end_page_v8(int fd); + diff -urpN crash-3.10-11.orig/check_tools.c crash-3.10-11.new/check_tools.c --- crash-3.10-11.orig/check_tools.c 1970-01-01 03:00:00.000000000 +0300 +++ crash-3.10-11.new/check_tools.c 2010-04-14 10:15:12.000000000 +0400 @@ -0,0 +1,125 @@ +/* check_tools.c - core analysis suite + * + * Copyright (C) 2010 MontaVista Software LLC + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include "check_defs.h" + +target_conv_u16 from_target_u16 = NULL; +target_conv_u32 from_target_u32 = NULL; +target_conv_u64 from_target_u64 = NULL; + +uint16_t bswap_u16(uint16_t v) +{ + return swap_target_u16(v); +} + +uint16_t dummy_u16(uint16_t v) +{ + return v; +} + +uint32_t bswap_u32(uint32_t v) +{ + return swap_target_u32(v); +} + +uint32_t dummy_u32(uint32_t v) +{ + return v; +} + +uint64_t bswap_u64(uint64_t v) +{ + return swap_target_u64(v); +} + +uint64_t dummy_u64(uint64_t v) +{ + return v; +} + +void init_target_endianess(int swap) +{ + if (swap) { + from_target_u16 = bswap_u16; + from_target_u32 = bswap_u32; + from_target_u64 = bswap_u64; + } else { + from_target_u16 = dummy_u16; + from_target_u32 = dummy_u32; + from_target_u64 = dummy_u64; + } +} + +int field(const char *str) +{ + int r; + + r = printf("%20s: ", str); + + return r; +} + +int corrupted(const char *fmt, ...) +{ + va_list args; + int r; + + if (silent > 1) + return 0; + + field("Result"); + printf("Vmcore file is corrupted\n"); + field("Details"); + va_start(args, fmt); + r = vprintf(fmt, args); + va_end(args); + printf("\n\n"); + + return r; +} + +int incomplete(const char *fmt, ...) +{ + va_list args; + int r; + + if (silent > 1) + return 0; + + field("Result"); + printf("Vmcore file is incomplete\n"); + field("Details"); + va_start(args, fmt); + r = vprintf(fmt, args); + va_end(args); + printf("\n\n"); + + return r; +} + +int complete() +{ + int r; + + if (silent > 1) + return 0; + + field("Result"); + r = printf("Vmcore file is complete\n\n"); + + return r; +} + diff -urpN crash-3.10-11.orig/lkcd_dump_v5.h crash-3.10-11.new/lkcd_dump_v5.h --- crash-3.10-11.orig/lkcd_dump_v5.h 2010-02-12 20:12:36.000000000 +0300 +++ crash-3.10-11.new/lkcd_dump_v5.h 2010-03-03 22:07:19.000000000 +0300 @@ -241,7 +241,7 @@ typedef struct __dump_header_asm { uint32_t dha_smp_current_task[DUMP_MAX_NUM_CPUS]; uint32_t dha_stack[DUMP_MAX_NUM_CPUS]; uint32_t dha_stack_ptr[DUMP_MAX_NUM_CPUS]; -} dump_header_asm_t __attribute__((packed)); +} __attribute__((packed)) dump_header_asm_t; /* Take care of target/host endians */ static void inline swap_asm_header(dump_header_asm_t *dh_asm) { diff -urpN crash-3.10-11.orig/lkcd_dump_v8.h crash-3.10-11.new/lkcd_dump_v8.h --- crash-3.10-11.orig/lkcd_dump_v8.h 2010-02-12 20:12:36.000000000 +0300 +++ crash-3.10-11.new/lkcd_dump_v8.h 2010-03-10 20:45:19.000000000 +0300 @@ -323,7 +323,7 @@ typedef struct __dump_header_asm { uint32_t dha_smp_current_task[DUMP_MAX_NUM_CPUS]; uint32_t dha_stack[DUMP_MAX_NUM_CPUS]; uint32_t dha_stack_ptr[DUMP_MAX_NUM_CPUS]; -} dump_header_asm_t __attribute__((packed)); +} __attribute__((packed)) dump_header_asm_t; /* Take care of target/host endians */ static void inline swap_asm_header(dump_header_asm_t *dh_asm) { @@ -345,12 +345,15 @@ static void inline swap_asm_header(dump_ reg = (uint32_t *)dh_asm->dha_smp_regs[cpu].dha_ARM_regs.uregs; for(i=0; idha_smp_regs[cpu].dha_ARM_spsr = from_target_u32( + dh_asm->dha_smp_regs[cpu].dha_ARM_spsr); } } /*end of CRASH_ARM*/ #elif defined (CRASH_PPC) -#define DUMP_MAX_NUM_CPUS 1 +#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ +#define DUMP_MAX_NUM_CPUS NR_CPUS typedef struct __dump_header_asm { @@ -379,7 +382,7 @@ typedef struct __dump_header_asm { uint32_t dha_smp_current_task[DUMP_MAX_NUM_CPUS]; uint32_t dha_stack[DUMP_MAX_NUM_CPUS]; uint32_t dha_stack_ptr[DUMP_MAX_NUM_CPUS]; -} dump_header_asm_t __attribute__((packed)); +} __attribute__((packed)) dump_header_asm_t; /* Take care of target/host endians */ static void inline swap_asm_header(dump_header_asm_t *dh_asm) { @@ -407,7 +410,8 @@ static void inline swap_asm_header(dump_ #elif defined (CRASH_X86) -#define DUMP_MAX_NUM_CPUS 32 +#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ +#define DUMP_MAX_NUM_CPUS NR_CPUS typedef struct __dump_header_asm { /* the dump magic number -- unique to verify dump is valid */ @@ -435,7 +439,7 @@ typedef struct __dump_header_asm { uint32_t dha_smp_current_task[DUMP_MAX_NUM_CPUS]; uint32_t dha_stack[DUMP_MAX_NUM_CPUS]; uint32_t dha_stack_ptr[DUMP_MAX_NUM_CPUS]; -} dump_header_asm_t __attribute__((packed)); +} __attribute__((packed)) dump_header_asm_t; /* Take care of target/host endians */ static void inline swap_asm_header(dump_header_asm_t *dh_asm) { @@ -464,7 +468,8 @@ static void inline swap_asm_header(dump_ #elif defined(CRASH_PPC64) -#define DUMP_MAX_NUM_CPUS 2 +#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ +#define DUMP_MAX_NUM_CPUS NR_CPUS typedef struct __dump_header_asm { @@ -487,7 +492,7 @@ typedef struct __dump_header_asm { uint64_t dha_smp_current_task[DUMP_MAX_NUM_CPUS]; uint64_t dha_stack[DUMP_MAX_NUM_CPUS]; uint64_t dha_stack_ptr[DUMP_MAX_NUM_CPUS]; -} dump_header_asm_t __attribute__((packed)); +} __attribute__((packed)) dump_header_asm_t; static inline void swap_asm_header(dump_header_asm_t *dh_asm) { int i, cpu, len; @@ -507,6 +512,123 @@ static inline void swap_asm_header(dump_ reg[i] = from_target_u64(reg[i]); } +#elif defined (CRASH_X86_64) + +#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ +#define DUMP_MAX_NUM_CPUS NR_CPUS + +typedef struct __dump_header_asm { + + /* the dump magic number -- unique to verify dump is valid */ + uint64_t dha_magic_number; + + /* the version number of this dump */ + uint32_t dha_version; + + /* the size of this header (in case we can't read it) */ + uint32_t dha_header_size; + + /* the dump registers */ + struct target_pt_regs dha_regs; + + /* smp specific */ + uint32_t dha_smp_num_cpus; + int dha_dumping_cpu; + struct target_pt_regs dha_smp_regs[DUMP_MAX_NUM_CPUS]; + uint64_t dha_smp_current_task[DUMP_MAX_NUM_CPUS]; + uint64_t dha_stack[DUMP_MAX_NUM_CPUS]; + uint64_t dha_stack_ptr[DUMP_MAX_NUM_CPUS]; +} __attribute__((packed)) dump_header_asm_t; + +/* Take care of target/host endians */ +static void inline swap_asm_header(dump_header_asm_t *dh_asm) { + int i, cpu, len; + uint64_t *reg; + + /* Convert only fileds we're carry about */ + dh_asm->dha_magic_number = from_target_u64(dh_asm->dha_magic_number); + dh_asm->dha_version = from_target_u32(dh_asm->dha_version); + dh_asm->dha_header_size = from_target_u32(dh_asm->dha_header_size); + + dh_asm->dha_smp_num_cpus = from_target_u32(dh_asm->dha_smp_num_cpus); + if (dh_asm->dha_smp_num_cpus > DUMP_MAX_NUM_CPUS) + dh_asm->dha_smp_num_cpus = DUMP_MAX_NUM_CPUS; + dh_asm->dha_dumping_cpu = from_target_u32(dh_asm->dha_dumping_cpu); + len = sizeof(struct target_pt_regs) / sizeof(target_ulong); + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + reg = (uint64_t *) (&dh_asm->dha_smp_regs[cpu]); + for(i=0; idha_magic_number = from_target_u64(dh_asm->dha_magic_number); + dh_asm->dha_version = from_target_u32(dh_asm->dha_version); + dh_asm->dha_header_size = from_target_u32(dh_asm->dha_header_size); + dh_asm->dha_pt_regs = from_target_u64(dh_asm->dha_pt_regs); + dh_asm->dha_rnat = from_target_u64(dh_asm->dha_rnat); + dh_asm->dha_pfs = from_target_u64(dh_asm->dha_pfs); + dh_asm->dha_bspstore = from_target_u64(dh_asm->dha_bspstore); + + dh_asm->dha_smp_num_cpus = from_target_u32(dh_asm->dha_smp_num_cpus); + if (dh_asm->dha_smp_num_cpus > DUMP_MAX_NUM_CPUS) + dh_asm->dha_smp_num_cpus = DUMP_MAX_NUM_CPUS; + dh_asm->dha_dumping_cpu = from_target_u32(dh_asm->dha_dumping_cpu); + len = sizeof(struct target_pt_regs) / sizeof(target_ulong); + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + reg = (uint64_t *) (&dh_asm->dha_smp_regs[cpu]); + for(i=0; idh_magic_number = from_target_u64(dh->dh_magic_number); + dh->dh_version = from_target_u32(dh->dh_version); + dh->dh_header_size = from_target_u32(dh->dh_header_size); + dh->dh_dump_level = from_target_u32(dh->dh_dump_level); + dh->dh_page_size = from_target_u32(dh->dh_page_size); + dh->dh_memory_size = from_target_u64(dh->dh_memory_size); + dh->dh_memory_start = from_target_u64(dh->dh_memory_start); + dh->dh_memory_end = from_target_u64(dh->dh_memory_end); + dh->dh_num_pages = from_target_u32(dh->dh_num_pages); + dh->dh_time.tv_sec = from_target_u64(dh->dh_time.tv_sec); + dh->dh_time.tv_usec = from_target_u64(dh->dh_time.tv_usec); + *(uint32_t *)(&dh->dh_current_task) = + from_target_u32(*(uint32_t *)(&dh->dh_current_task)); + + if (dh->dh_header_size != sizeof(dump_header_t)) { + corrupted("Header size paradox: dh_header_size = %" PRIu32 + ", sizeof(dump_header_t) = %zu", + dh->dh_header_size, sizeof(dump_header_t)); + return FALSE; + } + + if (silent || !print_header) + return TRUE; + + if (dump_header_offset != 0 || verbose) { + field("Dump header offset"); + printf(PRI2offsNL, dump_header_offset, dump_header_offset); + } + if (verbose) { + field("Magic number"); + printf("%#" PRIx64 " ", dh->dh_magic_number); + if (dh->dh_magic_number == DUMP_MAGIC_NUMBER) + printf("(DUMP_MAGIC_NUMBER)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 " (", dh->dh_version); + others = 0; + switch (dh->dh_version & LKCD_DUMP_VERSION_NUMBER_MASK) { + case LKCD_DUMP_V1: + printf("%sLKCD_DUMP_V1", others++ ? "|" : ""); + break; + case LKCD_DUMP_V2: + printf("%sLKCD_DUMP_V2", others++ ? "|" : ""); + break; + case LKCD_DUMP_V3: + printf("%sLKCD_DUMP_V3", others++ ? "|" : ""); + break; + } + if (dh->dh_version & LKCD_DUMP_MCLX_V0) + printf("%sLKCD_DUMP_MCLX_V0", others++ ? "|" : ""); + if (dh->dh_version & LKCD_DUMP_MCLX_V1) + printf("%sLKCD_DUMP_MCLX_V1", others++ ? "|" : ""); + printf(")\n"); + + field("Header size"); + printf("%" PRIu32 "\n", dh->dh_header_size); + } + + field("Dump level"); + printf("%#" PRIx32 " (", dh->dh_dump_level); + others = 0; + if (dh->dh_dump_level & DUMP_HEADER) + printf("%sDUMP_HEADER", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_KERN) + printf("%sDUMP_KERN", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_USED) + printf("%sDUMP_USED", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_ALL) + printf("%sDUMP_ALL", others++ ? "|" : ""); + printf(")\n"); + + field("Dump compression"); + printf("DUMP_COMPRESS_RLE\n"); + + if (verbose) { + field("Page size"); + printf("%" PRIu32 "\n", dh->dh_page_size); + + field("Memory size"); + printf("%#" PRIx64 "\n", dh->dh_memory_size); + + field("Memory start"); + printf("%#" PRIx64 "\n", dh->dh_memory_start); + + field("Memory end"); + printf("%#" PRIx64 "\n", dh->dh_memory_end); + + field("Num pages"); + printf("%" PRIu32 "\n", dh->dh_num_pages); + + field("Current task"); + printf("%#llx\n", (unsigned long long) dh->dh_current_task); + } + + field("Crash time"); + sec = dh->dh_time.tv_sec; + strftime(buf, sizeof(buf), "%a %b %e %H:%M:%S %Z %Y", + localtime(&sec)); + printf("%s\n", buf); + + field("Kernel name"); + printf("%s\n", dh->dh_utsname.sysname); + field("Node name"); + printf("%s\n", dh->dh_utsname.nodename); + field("Domain name"); + printf("%s\n", dh->dh_utsname.domainname); + field("Kernel release"); + printf("%s\n", dh->dh_utsname.release); + field("Kernel version"); + printf("%s\n", dh->dh_utsname.version); + field("Machine name"); + printf("%s\n", dh->dh_utsname.machine); + + field("Machine type"); + host = 1; + target = from_target_u16(host); + if ((*(char *) &host) && host == target) + printf("little endian\n"); + else + printf("big endian\n"); + + field("Panic message"); + printf("%s\n", dh->dh_panic_string); + + return TRUE; +} + +static void inline swap_asm_header(dump_header_t *dh) { + int i, len; + target_ulong *reg; + + /* Convert only fileds we're carry about */ + dh->dh_esp = from_target_u32(dh->dh_esp); + dh->dh_eip = from_target_u32(dh->dh_eip); + + len = sizeof(struct target_pt_regs) / sizeof(target_ulong); + reg = (target_ulong *) (&dh->dh_regs); + if (sizeof(target_ulong) == 64) + for(i=0; idh_page_size < LKCD_OFFSET_TO_FIRST_PAGE) + offs += LKCD_OFFSET_TO_FIRST_PAGE; + else + offs += LKCD_OFFSET_TO_FIRST_BIG_PAGE; + if (lseek(fd, offs, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the page No %lu (%#lx) at " + "%#" PRIxoff_t, pgcnt, pgcnt, offs); + return FALSE; + } + + if (!silent) + printf("\n"); + do { + if (read(fd, dp, sizeof(dump_page_t)) != sizeof(dump_page_t)) { + incomplete("Could not read page header for page No " + "%lu (%#lx)", pgcnt, pgcnt); + return FALSE; + } + + dp->dp_address = from_target_u64(dp->dp_address); + dp->dp_size = from_target_u32(dp->dp_size); + dp->dp_flags = from_target_u32(dp->dp_flags); + + if (dp->dp_flags & ~(DUMP_COMPRESSED|DUMP_RAW| + DUMP_END|LKCD_DUMP_MCLX_V0)) { + corrupted("Unknown page flag in the dump: %#" PRIx32 + ", page No %lu (%#lx)", + dp->dp_flags, pgcnt, pgcnt); + return FALSE; + } + + if (dp->dp_size > dh->dh_page_size) { + corrupted("Page size paradox: dp_size = %#" PRIx32 + ", dh_page_size = %#" PRIx32 + ", page No %lu (%#lx)", dp->dp_flags, + dh->dh_page_size, pgcnt, pgcnt); + return FALSE; + } + + if ((print_pages || (verbose && !pgcnt)) && !silent) { + field("Page No"); + printf("%lu (%#lx)\n", pgcnt, pgcnt); + + field("Page offset"); + printf(PRI2offsNL, offs, offs); + + field("Page address"); + printf("%#" PRIx64 "\n", dp->dp_address); + + field("Page size"); + printf("%" PRIu32 "\n", dp->dp_size); + + field("Page flags"); + printf("%#" PRIx32 " (", dp->dp_flags); + others = 0; + if (dp->dp_flags & DUMP_COMPRESSED) { + printf("%sDUMP_COMPRESSED", others++ ? "|" : ""); + cpgs++; + } + if (dp->dp_flags & DUMP_RAW) + printf("%sDUMP_RAW", others++ ? "|" : ""); + if (dp->dp_flags & DUMP_END) + printf("%sDUMP_END", others++ ? "|" : ""); + if (dp->dp_flags & LKCD_DUMP_MCLX_V0) + printf("%sLKCD_DUMP_MCLX_V0", others++ ? "|" : ""); + printf(")\n"); + } + + if (dp->dp_flags & DUMP_END) + break; + + pgcnt++; + if (lseek(fd, dp->dp_size, SEEK_CUR) == ((off_t)-1)) { + incomplete("Could not jump to the page No %lu (%#lx)", + pgcnt, pgcnt); + return FALSE; + } + offs += dp->dp_size + sizeof(dump_page_t); + } while (1); + + if (pgcnt > dh->dh_num_pages) { + corrupted("Page count paradox: pgcnt = %lu, dh_num_pages = " + "%" PRIu32, pgcnt, dh->dh_num_pages); + return FALSE; + } + + if (pgcnt < dh->dh_num_pages) { + incomplete("%lu pages lost", + (unsigned long) dh->dh_num_pages - pgcnt); + return FALSE; + } + + if (!silent) { + field("Total pages found"); + printf("%lu (%#lx)\n", pgcnt, pgcnt); + field("Compressed pages"); + printf("%lu\n", cpgs); + field("End-page offset"); + printf(PRI2offsNL, offs, offs); + } + + offs += sizeof(dump_page_t); + do { + rd = read(fd, buf, sizeof(buf)); + + for (i = 0; i < rd; i++) + if (buf[i] != 'm') { + offs += i; + if (endless && !silent) { + field("Dump end"); + printf(PRI2offsNL, offs, offs); + + return TRUE; + } + corrupted("Found wrong symbol inside end page " + "at %#" PRIxoff_t, offs); + return FALSE; + } + + offs += rd; + } while (rd > 0); + + return TRUE; +} + +int lkcd_dump_check_end_page_v1(int fd) +{ + dump_page_t *dp; + char buf[1024]; + ssize_t i, len = 0; + off_t offs; + + offs = lseek(fd, 0, SEEK_END); + while (offs > 0) { + offs -= sizeof(buf); + if (lseek(fd, offs, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the offset %#" PRIxoff_t, offs); + return FALSE; + } + if (read(fd, buf, sizeof(buf)) != sizeof(buf)) { + incomplete("Could not read last page at %#" PRIxoff_t, offs); + return FALSE; + } + for (i = sizeof(buf); i--; ) + if (buf[i] != 'm') { + i++; + if (i < sizeof(dump_page_t)) { + offs += sizeof(buf) / 2; + len -= sizeof(buf) / 2; + break; + } + i -= sizeof(dump_page_t); + goto found; + } + len += sizeof(buf); + } +found: + dp = (dump_page_t *)(buf + i); + offs += i; + if (from_target_u32(dp->dp_flags) == DUMP_END) + if(len) { + if (!silent) { + printf("\n"); + field("End-page offset"); + printf(PRI2offsNL, offs, offs); + } + + return TRUE; + } + + if(!len) + incomplete("Could not find final marker and page header for it."); + else + corrupted("Invalid page header before final marker."); + return FALSE; +} + +static int arch_print_asmheader_v1(dump_header_t *dh) +{ + if (verbose) { + printf("\n"); + arch_print_pt_regs(&dh->dh_regs); + } + return TRUE; +} + diff -urpN crash-3.10-11.orig/lkcd_v3_check.c crash-3.10-11.new/lkcd_v3_check.c --- crash-3.10-11.orig/lkcd_v3_check.c 1970-01-01 03:00:00.000000000 +0300 +++ crash-3.10-11.new/lkcd_v3_check.c 2010-04-14 10:15:12.000000000 +0400 @@ -0,0 +1,435 @@ +/* lkcd_v3_check.c - core analysis suite + * + * Copyright (C) 2010 MontaVista Software LLC + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include "check_defs.h" +#define CONFIG_VMDUMP +#include "lkcd_vmdump_v2_v3.h" + +static dump_header_t dump_header_v3 = { 0 }; +static dump_header_asm_t dump_header_asm_v3 = { 0 }; +static dump_page_t dump_page = { 0 }; +static int arch_print_asmheader_v3(dump_header_asm_t *dha); + +int lkcd_dump_check_header_v3(int fd) +{ + int others; + time_t sec; + uint16_t host, target; + char buf[64]; + dump_header_t *dh; + dh = &dump_header_v3; + + if (lseek(fd, dump_header_offset, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the dump header at " PRI2offs, + dump_header_offset, dump_header_offset); + return FALSE; + } + + if (read(fd, dh, sizeof(dump_header_t)) != sizeof(dump_header_t)) { + incomplete("Could not read dump header"); + return FALSE; + } + + /* Swap everything from the target endian to mine.*/ + dh->dh_magic_number = from_target_u64(dh->dh_magic_number); + dh->dh_version = from_target_u32(dh->dh_version); + dh->dh_header_size = from_target_u32(dh->dh_header_size); + dh->dh_dump_level = from_target_u32(dh->dh_dump_level); + dh->dh_page_size = from_target_u32(dh->dh_page_size); + dh->dh_memory_size = from_target_u64(dh->dh_memory_size); + dh->dh_memory_start = from_target_u64(dh->dh_memory_start); + dh->dh_memory_end = from_target_u64(dh->dh_memory_end); + dh->dh_num_pages = from_target_u32(dh->dh_num_pages); + dh->dh_time.tv_sec = from_target_u64(dh->dh_time.tv_sec); + dh->dh_time.tv_usec = from_target_u64(dh->dh_time.tv_usec); + *(uint32_t *)(&dh->dh_current_task) = + from_target_u32(*(uint32_t *)(&dh->dh_current_task)); + + if (dh->dh_header_size != sizeof(dump_header_t)) { + corrupted("Header size paradox: dh_header_size = %" PRIu32 + ", sizeof(dump_header_t) = %zu", + dh->dh_header_size, sizeof(dump_header_t)); + return FALSE; + } + + if (silent || !print_header) + return TRUE; + + if (dump_header_offset != 0 || verbose) { + field("Dump header offset"); + printf(PRI2offsNL, dump_header_offset, dump_header_offset); + } + if (verbose) { + field("Magic number"); + printf("%#" PRIx64 " ", dh->dh_magic_number); + if (dh->dh_magic_number == DUMP_MAGIC_NUMBER) + printf("(DUMP_MAGIC_NUMBER)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 " (", dh->dh_version); + others = 0; + switch (dh->dh_version & LKCD_DUMP_VERSION_NUMBER_MASK) { + case LKCD_DUMP_V1: + printf("%sLKCD_DUMP_V1", others++ ? "|" : ""); + break; + case LKCD_DUMP_V2: + printf("%sLKCD_DUMP_V2", others++ ? "|" : ""); + break; + case LKCD_DUMP_V3: + printf("%sLKCD_DUMP_V3", others++ ? "|" : ""); + break; + } + if (dh->dh_version & LKCD_DUMP_MCLX_V0) + printf("%sLKCD_DUMP_MCLX_V0", others++ ? "|" : ""); + if (dh->dh_version & LKCD_DUMP_MCLX_V1) + printf("%sLKCD_DUMP_MCLX_V1", others++ ? "|" : ""); + printf(")\n"); + + field("Header size"); + printf("%" PRIu32 "\n", dh->dh_header_size); + } + + field("Dump level"); + printf("%#" PRIx32 " (", dh->dh_dump_level); + others = 0; + if (dh->dh_dump_level & DUMP_HEADER) + printf("%sDUMP_HEADER", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_KERN) + printf("%sDUMP_KERN", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_USED) + printf("%sDUMP_USED", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_ALL) + printf("%sDUMP_ALL", others++ ? "|" : ""); + printf(")\n"); + + field("Dump compression"); + printf("DUMP_COMPRESS_RLE\n"); + + if (verbose) { + field("Page size"); + printf("%" PRIu32 "\n", dh->dh_page_size); + + field("Memory size"); + printf("%#" PRIx64 "\n", dh->dh_memory_size); + + field("Memory start"); + printf("%#" PRIx64 "\n", dh->dh_memory_start); + + field("Memory end"); + printf("%#" PRIx64 "\n", dh->dh_memory_end); + + field("Num pages"); + printf("%" PRIu32 "\n", dh->dh_num_pages); + + field("Current task"); + printf("%#llx\n", (unsigned long long) dh->dh_current_task); + } + + field("Crash time"); + sec = dh->dh_time.tv_sec; + strftime(buf, sizeof(buf), "%a %b %e %H:%M:%S %Z %Y", + localtime(&sec)); + printf("%s\n", buf); + + field("Kernel name"); + printf("%s\n", dh->dh_utsname.sysname); + field("Node name"); + printf("%s\n", dh->dh_utsname.nodename); + field("Domain name"); + printf("%s\n", dh->dh_utsname.domainname); + field("Kernel release"); + printf("%s\n", dh->dh_utsname.release); + field("Kernel version"); + printf("%s\n", dh->dh_utsname.version); + field("Machine name"); + printf("%s\n", dh->dh_utsname.machine); + + field("Machine type"); + host = 1; + target = from_target_u16(host); + if ((*(char *) &host) && host == target) + printf("little endian\n"); + else + printf("big endian\n"); + + field("Panic message"); + printf("%s\n", dh->dh_panic_string); + + return TRUE; +} + +static void inline swap_asm_header(dump_header_asm_t *dh_asm) +{ + int i, len; + target_ulong *reg; + + /* Convert only fileds we're carry about */ + dh_asm->dha_magic_number = from_target_u64(dh_asm->dha_magic_number); + dh_asm->dha_version = from_target_u32(dh_asm->dha_version); + dh_asm->dha_header_size = from_target_u32(dh_asm->dha_header_size); + dh_asm->dha_esp = from_target_u32(dh_asm->dha_esp); + dh_asm->dha_eip = from_target_u32(dh_asm->dha_eip); + + len = sizeof(struct target_pt_regs) / sizeof(target_ulong); + reg = (target_ulong *) (&dh_asm->dha_regs); + if (sizeof(target_ulong) == 64) + for(i=0; idh_page_size < LKCD_OFFSET_TO_FIRST_PAGE) + offs += LKCD_OFFSET_TO_FIRST_PAGE; + else + offs += LKCD_OFFSET_TO_FIRST_BIG_PAGE; + if (lseek(fd, offs, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the page No %lu (%#lx) at " + "%#" PRIxoff_t, pgcnt, pgcnt, offs); + return FALSE; + } + + if (!silent) + printf("\n"); + do { + if (read(fd, dp, sizeof(dump_page_t)) != sizeof(dump_page_t)) { + incomplete("Could not read page header for page No " + "%lu (%#lx)", pgcnt, pgcnt); + return FALSE; + } + + dp->dp_address = from_target_u64(dp->dp_address); + dp->dp_size = from_target_u32(dp->dp_size); + dp->dp_flags = from_target_u32(dp->dp_flags); + + if (dp->dp_flags & ~(DUMP_COMPRESSED|DUMP_RAW| + DUMP_END|LKCD_DUMP_MCLX_V0)) { + corrupted("Unknown page flag in the dump: %#" PRIx32 + ", page No %lu (%#lx)", + dp->dp_flags, pgcnt, pgcnt); + return FALSE; + } + + if (dp->dp_size > dh->dh_page_size) { + corrupted("Page size paradox: dp_size = %#" PRIx32 + ", dh_page_size = %#" PRIx32 + ", page No %lu (%#lx)", dp->dp_flags, + dh->dh_page_size, pgcnt, pgcnt); + return FALSE; + } + + if ((print_pages || (verbose && !pgcnt)) && !silent) { + field("Page No"); + printf("%lu (%#lx)\n", pgcnt, pgcnt); + + field("Page offset"); + printf(PRI2offsNL, offs, offs); + + field("Page address"); + printf("%#" PRIx64 "\n", dp->dp_address); + + field("Page size"); + printf("%" PRIu32 "\n", dp->dp_size); + + field("Page flags"); + printf("%#" PRIx32 " (", dp->dp_flags); + others = 0; + if (dp->dp_flags & DUMP_COMPRESSED) { + printf("%sDUMP_COMPRESSED", others++ ? "|" : ""); + cpgs++; + } + if (dp->dp_flags & DUMP_RAW) + printf("%sDUMP_RAW", others++ ? "|" : ""); + if (dp->dp_flags & DUMP_END) + printf("%sDUMP_END", others++ ? "|" : ""); + if (dp->dp_flags & LKCD_DUMP_MCLX_V0) + printf("%sLKCD_DUMP_MCLX_V0", others++ ? "|" : ""); + printf(")\n"); + } + + if (dp->dp_flags & DUMP_END) + break; + + pgcnt++; + if (lseek(fd, dp->dp_size, SEEK_CUR) == ((off_t)-1)) { + incomplete("Could not jump to the page No %lu (%#lx)", + pgcnt, pgcnt); + return FALSE; + } + offs += dp->dp_size + sizeof(dump_page_t); + } while (1); + + if (pgcnt > dh->dh_num_pages) { + corrupted("Page count paradox: pgcnt = %lu, dh_num_pages = " + "%" PRIu32, pgcnt, dh->dh_num_pages); + return FALSE; + } + + if (pgcnt < dh->dh_num_pages) { + incomplete("%lu pages lost", + (unsigned long) dh->dh_num_pages - pgcnt); + return FALSE; + } + + if (!silent) { + field("Total pages found"); + printf("%lu (%#lx)\n", pgcnt, pgcnt); + field("Compressed pages"); + printf("%lu\n", cpgs); + field("End-page offset"); + printf(PRI2offsNL, offs, offs); + } + + offs += sizeof(dump_page_t); + do { + rd = read(fd, buf, sizeof(buf)); + + for (i = 0; i < rd; i++) + if (buf[i] != 'm') { + offs += i; + if (endless && !silent) { + field("Dump end"); + printf(PRI2offsNL, offs, offs); + + return TRUE; + } + corrupted("Found wrong symbol inside end page " + "at %#" PRIxoff_t, offs); + return FALSE; + } + + offs += rd; + } while (rd > 0); + + return TRUE; +} + +int lkcd_dump_check_end_page_v3(int fd) +{ + dump_page_t *dp; + char buf[1024]; + ssize_t i, len = 0; + off_t offs; + + offs = lseek(fd, 0, SEEK_END); + while (offs > 0) { + offs -= sizeof(buf); + if (lseek(fd, offs, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the offset %#" PRIxoff_t, offs); + return FALSE; + } + if (read(fd, buf, sizeof(buf)) != sizeof(buf)) { + incomplete("Could not read last page at %#" PRIxoff_t, offs); + return FALSE; + } + for (i = sizeof(buf); i--; ) + if (buf[i] != 'm') { + i++; + if (i < sizeof(dump_page_t)) { + offs += sizeof(buf) / 2; + len -= sizeof(buf) / 2; + break; + } + i -= sizeof(dump_page_t); + goto found; + } + len += sizeof(buf); + } +found: + dp = (dump_page_t *)(buf + i); + offs += i; + if (from_target_u32(dp->dp_flags) == DUMP_END) + if(len) { + if (!silent) { + printf("\n"); + field("End-page offset"); + printf(PRI2offsNL, offs, offs); + } + + return TRUE; + } + + if(!len) + incomplete("Could not find final marker and page header for it."); + else + corrupted("Invalid page header before final marker."); + return FALSE; +} + +static int arch_print_asmheader_v3(dump_header_asm_t *dha) +{ + dump_header_t *dh; + dh = &dump_header_v3; + + printf("\n"); + field("ASM Magic number"); + printf("%#" PRIx64 "\n", dha->dha_magic_number); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + + if (verbose) { + arch_print_pt_regs(&dha->dha_regs); + } + return TRUE; +} + diff -urpN crash-3.10-11.orig/lkcd_v5_check.c crash-3.10-11.new/lkcd_v5_check.c --- crash-3.10-11.orig/lkcd_v5_check.c 1970-01-01 03:00:00.000000000 +0300 +++ crash-3.10-11.new/lkcd_v5_check.c 2010-04-14 10:15:12.000000000 +0400 @@ -0,0 +1,520 @@ +/* lkcd_v5_check.c - core analysis suite + * + * Copyright (C) 2010 MontaVista Software LLC + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include "check_defs.h" +#include "lkcd_dump_v5.h" + +#if !defined (CRASH_X86) + +typedef struct __dump_header_asm { + /* the dump magic number -- unique to verify dump is valid */ + uint64_t dha_magic_number; + + /* the version number of this dump */ + uint32_t dha_version; + + /* the size of this header (in case we can't read it) */ + uint32_t dha_header_size; +} __attribute__((packed)) dump_header_asm_t; + +#define swap_asm_header(dh_asm) + +#endif + +static dump_header_t dump_header_v5 = { 0 }; +static dump_header_asm_t dump_header_asm_v5 = { 0 }; +static dump_page_t dump_page = { 0 }; +static int arch_print_asmheader_v5(dump_header_asm_t *dha); + +int lkcd_dump_check_header_v5(int fd) +{ + int others; + time_t sec; + uint16_t host, target; + char buf[64]; + dump_header_t *dh; + dh = &dump_header_v5; + + if (lseek(fd, dump_header_offset, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the dump header at " PRI2offs, + dump_header_offset, dump_header_offset); + return FALSE; + } + + if (read(fd, dh, sizeof(dump_header_t)) != sizeof(dump_header_t)) { + incomplete("Could not read dump header"); + return FALSE; + } + + /* Swap everything from the target endian to mine.*/ + dh->dh_magic_number = from_target_u64(dh->dh_magic_number); + dh->dh_version = from_target_u32(dh->dh_version); + dh->dh_header_size = from_target_u32(dh->dh_header_size); + dh->dh_dump_level = from_target_u32(dh->dh_dump_level); + dh->dh_page_size = from_target_u32(dh->dh_page_size); + dh->dh_memory_size = from_target_u64(dh->dh_memory_size); + dh->dh_memory_start = from_target_u64(dh->dh_memory_start); + dh->dh_memory_end = from_target_u64(dh->dh_memory_end); + dh->dh_num_pages = from_target_u32(dh->dh_num_pages); + dh->dh_time.tv_sec = from_target_u64(dh->dh_time.tv_sec); + dh->dh_time.tv_usec = from_target_u64(dh->dh_time.tv_usec); + if (sizeof(target_ptr) == 64) + dh->dh_current_task = from_target_u64(dh->dh_current_task); + else + dh->dh_current_task = from_target_u32(dh->dh_current_task); + dh->dh_dump_compress = from_target_u32(dh->dh_dump_compress); + dh->dh_dump_flags = from_target_u32(dh->dh_dump_flags); + dh->dh_dump_device = from_target_u32(dh->dh_dump_device); + + if (dh->dh_header_size != sizeof(dump_header_t)) { + corrupted("Header size paradox: dh_header_size = %" PRIu32 + ", sizeof(dump_header_t) = %zu", + dh->dh_header_size, sizeof(dump_header_t)); + return FALSE; + } + + if (silent || !print_header) + return TRUE; + + if (dump_header_offset != 0 || verbose) { + field("Dump header offset"); + printf(PRI2offsNL, dump_header_offset, dump_header_offset); + } + if (verbose) { + field("Magic number"); + printf("%#" PRIx64 " ", dh->dh_magic_number); + if (dh->dh_magic_number == DUMP_MAGIC_NUMBER) + printf("(DUMP_MAGIC_NUMBER)\n"); + else if (dh->dh_magic_number == DUMP_MAGIC_LIVE) + printf("(DUMP_MAGIC_LIVE)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 " (", dh->dh_version); + others = 0; + switch (dh->dh_version & LKCD_DUMP_VERSION_NUMBER_MASK) { + case LKCD_DUMP_V1: + printf("%sLKCD_DUMP_V1", others++ ? "|" : ""); + break; + case LKCD_DUMP_V2: + printf("%sLKCD_DUMP_V2", others++ ? "|" : ""); + break; + case LKCD_DUMP_V3: + printf("%sLKCD_DUMP_V3", others++ ? "|" : ""); + break; + case LKCD_DUMP_V5: + printf("%sLKCD_DUMP_V5", others++ ? "|" : ""); + break; + case LKCD_DUMP_V6: + printf("%sLKCD_DUMP_V6", others++ ? "|" : ""); + break; + case LKCD_DUMP_V7: + printf("%sLKCD_DUMP_V7", others++ ? "|" : ""); + break; + case LKCD_DUMP_V8: + printf("%sLKCD_DUMP_V8", others++ ? "|" : ""); + break; + } + if (dh->dh_version & LKCD_DUMP_MCLX_V0) + printf("%sLKCD_DUMP_MCLX_V0", others++ ? "|" : ""); + if (dh->dh_version & LKCD_DUMP_MCLX_V1) + printf("%sLKCD_DUMP_MCLX_V1", others++ ? "|" : ""); + printf(")\n"); + + field("Header size"); + printf("%" PRIu32 "\n", dh->dh_header_size); + } + + field("Dump level"); + printf("%#" PRIx32 " (", dh->dh_dump_level); + others = 0; + if (dh->dh_dump_level & DUMP_LEVEL_HEADER) + printf("%sDUMP_LEVEL_HEADER", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_LEVEL_KERN) + printf("%sDUMP_LEVEL_KERN", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_LEVEL_USED) + printf("%sDUMP_LEVEL_USED", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_LEVEL_ALL) + printf("%sDUMP_LEVEL_ALL", others++ ? "|" : ""); + printf(")\n"); + + field("Dump compression"); + printf("%#" PRIx32 " (", dh->dh_dump_compress); + others = 0; + if (dh->dh_dump_compress == DUMP_COMPRESS_NONE) + printf("%sDUMP_COMPRESS_NONE", others++ ? "|" : ""); + if (dh->dh_dump_compress & DUMP_COMPRESS_RLE) + printf("%sDUMP_COMPRESS_RLE", others++ ? "|" : ""); + if (dh->dh_dump_compress & DUMP_COMPRESS_GZIP) + printf("%sDUMP_COMPRESS_GZIP", others++ ? "|" : ""); + printf(")\n"); + + if (verbose) { + field("Dump flags"); + others = 0; + printf("%#" PRIx32 " (", dh->dh_dump_flags); + if (dh->dh_dump_flags & DUMP_FLAGS_NONDISRUPT) + printf("%sDUMP_FLAGS_NONDISRUPT", others++ ? "|" : ""); + printf(")\n"); + + field("Dump device"); + printf("%" PRIu32 "\n", dh->dh_dump_device); + + field("Page size"); + printf("%" PRIu32 "\n", dh->dh_page_size); + + field("Memory size"); + printf("%#" PRIx64 "\n", dh->dh_memory_size); + + field("Memory start"); + printf("%#" PRIx64 "\n", dh->dh_memory_start); + + field("Memory end"); + printf("%#" PRIx64 "\n", dh->dh_memory_end); + + field("Num pages"); + printf("%" PRIu32 "\n", dh->dh_num_pages); + + field("Current task"); + printf("%#llx\n", (unsigned long long) dh->dh_current_task); + } + + field("Crash time"); + sec = dh->dh_time.tv_sec; + strftime(buf, sizeof(buf), "%a %b %e %H:%M:%S %Z %Y", + localtime(&sec)); + printf("%s\n", buf); + + field("Kernel name"); + printf("%s\n", dh->dh_utsname_sysname); + field("Node name"); + printf("%s\n", dh->dh_utsname_nodename); + field("Domain name"); + printf("%s\n", dh->dh_utsname_domainname); + field("Kernel release"); + printf("%s\n", dh->dh_utsname_release); + field("Kernel version"); + printf("%s\n", dh->dh_utsname_version); + field("Machine name"); + printf("%s\n", dh->dh_utsname_machine); + + field("Machine type"); + host = 1; + target = from_target_u16(host); + if ((*(char *) &host) && host == target) + printf("little endian\n"); + else + printf("big endian\n"); + + field("Panic message"); + printf("%s\n", dh->dh_panic_string); + + return TRUE; +} + +int lkcd_dump_check_asmheader_v5(int fd) +{ + dump_header_asm_t *dh_asm; + dh_asm = &dump_header_asm_v5; + + if (lseek(fd, dump_header_offset + sizeof(dump_header_t), SEEK_SET) + == ((off_t)-1)) { + incomplete("Could not jump to the asm header at %#" PRIxoff_t, + dump_header_offset + sizeof(dump_header_t)); + return FALSE; + } + + if (read(fd, dh_asm, sizeof(dump_header_asm_t)) != + sizeof(dump_header_asm_t)) { + incomplete("Could not read asm header at %#" PRIxoff_t, + dump_header_offset + sizeof(dump_header_t)); + return FALSE; + } + + swap_asm_header(dh_asm); + + if (silent || !print_asmheader) + return TRUE; + + return arch_print_asmheader_v5(dh_asm); +} + +int lkcd_dump_check_pages_v5(int fd) +{ + int others; + unsigned long pgcnt = 0, cpgs = 0; + ssize_t i, rd; + off_t offs; + char buf[1024]; + dump_page_t *dp; + dump_header_t *dh; + dh = &dump_header_v5; + dp = &dump_page; + + offs = dump_header_offset; + if (dh->dh_page_size < LKCD_OFFSET_TO_FIRST_PAGE) + offs += LKCD_OFFSET_TO_FIRST_PAGE; + else + offs += LKCD_OFFSET_TO_FIRST_BIG_PAGE; + if (lseek(fd, offs, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the page No %lu (%#lx) at " + "%#" PRIxoff_t, pgcnt, pgcnt, offs); + return FALSE; + } + + if (!silent) + printf("\n"); + do { + if (read(fd, dp, sizeof(dump_page_t)) != sizeof(dump_page_t)) { + incomplete("Could not read page header for page No " + "%lu (%#lx)", pgcnt, pgcnt); + return FALSE; + } + + dp->dp_address = from_target_u64(dp->dp_address); + dp->dp_size = from_target_u32(dp->dp_size); + dp->dp_flags = from_target_u32(dp->dp_flags); + + if (dp->dp_flags & ~(DUMP_DH_COMPRESSED|DUMP_DH_RAW| + DUMP_DH_END|LKCD_DUMP_MCLX_V0)) { + corrupted("Unknown page flag in the dump: %#" PRIx32 + ", page No %lu (%#lx)", + dp->dp_flags, pgcnt, pgcnt); + return FALSE; + } + + if (dp->dp_size > dh->dh_page_size) { + corrupted("Page size paradox: dp_size = %#" PRIx32 + ", dh_page_size = %#" PRIx32 + ", page No %lu (%#lx)", dp->dp_flags, + dh->dh_page_size, pgcnt, pgcnt); + return FALSE; + } + + if ((print_pages || (verbose && !pgcnt)) && !silent) { + field("Page No"); + printf("%lu (%#lx)\n", pgcnt, pgcnt); + + field("Page offset"); + printf(PRI2offsNL, offs, offs); + + field("Page address"); + printf("%#" PRIx64 "\n", dp->dp_address); + + field("Page size"); + printf("%" PRIu32 "\n", dp->dp_size); + + field("Page flags"); + printf("%#" PRIx32 " (", dp->dp_flags); + others = 0; + if (dp->dp_flags & DUMP_DH_COMPRESSED) { + printf("%sDUMP_DH_COMPRESSED", others++ ? "|" : ""); + cpgs++; + } + if (dp->dp_flags & DUMP_DH_RAW) + printf("%sDUMP_DH_RAW", others++ ? "|" : ""); + if (dp->dp_flags & DUMP_DH_END) + printf("%sDUMP_DH_END", others++ ? "|" : ""); + if (dp->dp_flags & LKCD_DUMP_MCLX_V0) + printf("%sLKCD_DUMP_MCLX_V0", others++ ? "|" : ""); + printf(")\n"); + } + + if (dp->dp_flags & DUMP_DH_END) + break; + + pgcnt++; + if (lseek(fd, dp->dp_size, SEEK_CUR) == ((off_t)-1)) { + incomplete("Could not jump to the page No %lu (%#lx)", + pgcnt, pgcnt); + return FALSE; + } + offs += dp->dp_size + sizeof(dump_page_t); + } while (1); + + if (pgcnt > dh->dh_num_pages) { + corrupted("Page count paradox: pgcnt = %lu, dh_num_pages = " + "%" PRIu32, pgcnt, dh->dh_num_pages); + return FALSE; + } + + if (pgcnt < dh->dh_num_pages) { + incomplete("%lu pages lost", + (unsigned long) dh->dh_num_pages - pgcnt); + return FALSE; + } + + if (!silent) { + field("Total pages found"); + printf("%lu (%#lx)\n", pgcnt, pgcnt); + field("Compressed pages"); + printf("%lu\n", cpgs); + field("End-page offset"); + printf(PRI2offsNL, offs, offs); + } + + offs += sizeof(dump_page_t); + do { + rd = read(fd, buf, sizeof(buf)); + + for (i = 0; i < rd; i++) + if (buf[i] != 'm') { + offs += i; + if (endless && !silent) { + field("Dump end"); + printf(PRI2offsNL, offs, offs); + + return TRUE; + } + corrupted("Found wrong symbol inside end page " + "at %#" PRIxoff_t, offs); + return FALSE; + } + + offs += rd; + } while (rd > 0); + + return TRUE; +} + +int lkcd_dump_check_end_page_v5(int fd) +{ + dump_page_t *dp; + char buf[1024]; + ssize_t i, len = 0; + off_t offs; + + offs = lseek(fd, 0, SEEK_END); + while (offs > 0) { + offs -= sizeof(buf); + if (lseek(fd, offs, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the offset %#" PRIxoff_t, offs); + return FALSE; + } + if (read(fd, buf, sizeof(buf)) != sizeof(buf)) { + incomplete("Could not read last page at %#" PRIxoff_t, offs); + return FALSE; + } + for (i = sizeof(buf); i--; ) + if (buf[i] != 'm') { + i++; + if (i < sizeof(dump_page_t)) { + offs += sizeof(buf) / 2; + len -= sizeof(buf) / 2; + break; + } + i -= sizeof(dump_page_t); + goto found; + } + len += sizeof(buf); + } +found: + dp = (dump_page_t *)(buf + i); + offs += i; + if (from_target_u32(dp->dp_flags) == DUMP_DH_END) + if(len) { + if (!silent) { + printf("\n"); + field("End-page offset"); + printf(PRI2offsNL, offs, offs); + } + + return TRUE; + } + + if(!len) + incomplete("Could not find final marker and page header for it."); + else + corrupted("Invalid page header before final marker."); + return FALSE; +} + +#if defined (CRASH_X86) + +static int arch_print_asmheader_v5(dump_header_asm_t *dha) +{ + int cpu; + struct target_pt_regs *regs; + const char *fmt = "%#" PRIx32 "\n"; + dump_header_t *dh; + dh = &dump_header_v5; + + if (strcasecmp(dh->dh_utsname_machine, "i686") && + strcasecmp(dh->dh_utsname_machine, "i586") && + strcasecmp(dh->dh_utsname_machine, "i486") && + strcasecmp(dh->dh_utsname_machine, "i386") && + strcasecmp(dh->dh_utsname_machine, "athlon")) { + corrupted("Unsupported architecture: %s", dh->dh_utsname_machine); + return FALSE; + } + + printf("\n"); + if (verbose) { + field("ASM Magic number"); + printf("%#" PRIx64 "\n", dha->dha_magic_number); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + } + + field("Num CPUs"); + printf("%" PRIu32 "\n", dha->dha_smp_num_cpus); + + field("Dumping CPU"); + printf("%" PRIu32 "\n", dha->dha_dumping_cpu); + + if (verbose) { + field("ESP register"); + printf(fmt, dha->dha_esp); + + field("EIP register"); + printf(fmt, dha->dha_eip); + + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + regs = &dha->dha_smp_regs[cpu]; + + field("CPU"); + printf("%d\n", cpu); + + arch_print_pt_regs(regs); + } + } + + return TRUE; +} + +#else + +static int arch_print_asmheader_v5(dump_header_asm_t *dha) +{ + printf("\n"); + field("ASM Magic number"); + printf("%#" PRIx64 "\n", dha->dha_magic_number); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + + return TRUE; +} + +#endif /* if defined(CRASH_)*/ diff -urpN crash-3.10-11.orig/lkcd_v8_check.c crash-3.10-11.new/lkcd_v8_check.c --- crash-3.10-11.orig/lkcd_v8_check.c 1970-01-01 03:00:00.000000000 +0300 +++ crash-3.10-11.new/lkcd_v8_check.c 2010-04-14 10:15:12.000000000 +0400 @@ -0,0 +1,1015 @@ +/* lkcd_v8_check.c - core analysis suite + * + * Copyright (C) 2010 MontaVista Software LLC + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include "check_defs.h" +#include "lkcd_dump_v8.h" + +static dump_header_t dump_header_v8 = { 0 }; +static dump_header_asm_t dump_header_asm_v8 = { 0 }; +static dump_page_t dump_page = { 0 }; +static int arch_print_asmheader_v8(dump_header_asm_t *dha); + +int lkcd_dump_check_header_v8(int fd) +{ + int others; + time_t sec; + uint16_t host, target; + char buf[64]; + dump_header_t *dh; + dh = &dump_header_v8; + + if (lseek(fd, dump_header_offset, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the dump header at " PRI2offs, + dump_header_offset, dump_header_offset); + return FALSE; + } + + if (read(fd, dh, sizeof(dump_header_t)) != sizeof(dump_header_t)) { + incomplete("Could not read dump header"); + return FALSE; + } + + /* Swap everything from the target endian to mine.*/ + dh->dh_magic_number = from_target_u64(dh->dh_magic_number); + dh->dh_version = from_target_u32(dh->dh_version); + dh->dh_header_size = from_target_u32(dh->dh_header_size); + dh->dh_dump_level = from_target_u32(dh->dh_dump_level); + dh->dh_page_size = from_target_u32(dh->dh_page_size); + dh->dh_memory_size = from_target_u64(dh->dh_memory_size); + dh->dh_memory_start = from_target_u64(dh->dh_memory_start); + dh->dh_memory_end = from_target_u64(dh->dh_memory_end); + dh->dh_num_pages = from_target_u32(dh->dh_num_pages); + dh->dh_time.tv_sec = from_target_u64(dh->dh_time.tv_sec); + dh->dh_time.tv_usec = from_target_u64(dh->dh_time.tv_usec); + dh->dh_current_task = from_target_u64(dh->dh_current_task); + dh->dh_dump_compress = from_target_u32(dh->dh_dump_compress); + dh->dh_dump_flags = from_target_u32(dh->dh_dump_flags); + dh->dh_dump_device = from_target_u32(dh->dh_dump_device); + + if (dh->dh_header_size != sizeof(dump_header_t)) { + corrupted("Header size paradox: dh_header_size = %" PRIu32 + ", sizeof(dump_header_t) = %zu", + dh->dh_header_size, sizeof(dump_header_t)); + return FALSE; + } + + if (silent || !print_header) + return TRUE; + + if (dump_header_offset != 0 || verbose) { + field("Dump header offset"); + printf(PRI2offsNL, dump_header_offset, dump_header_offset); + } + if (verbose) { + field("Magic number"); + printf("%#" PRIx64 " ", dh->dh_magic_number); + if (dh->dh_magic_number == DUMP_MAGIC_NUMBER) + printf("(DUMP_MAGIC_NUMBER)\n"); + else if (dh->dh_magic_number == DUMP_MAGIC_LIVE) + printf("(DUMP_MAGIC_LIVE)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 " (", dh->dh_version); + others = 0; + switch (dh->dh_version & LKCD_DUMP_VERSION_NUMBER_MASK) { + case LKCD_DUMP_V1: + printf("%sLKCD_DUMP_V1", others++ ? "|" : ""); + break; + case LKCD_DUMP_V2: + printf("%sLKCD_DUMP_V2", others++ ? "|" : ""); + break; + case LKCD_DUMP_V3: + printf("%sLKCD_DUMP_V3", others++ ? "|" : ""); + break; + case LKCD_DUMP_V5: + printf("%sLKCD_DUMP_V5", others++ ? "|" : ""); + break; + case LKCD_DUMP_V6: + printf("%sLKCD_DUMP_V6", others++ ? "|" : ""); + break; + case LKCD_DUMP_V7: + printf("%sLKCD_DUMP_V7", others++ ? "|" : ""); + break; + case LKCD_DUMP_V8: + printf("%sLKCD_DUMP_V8", others++ ? "|" : ""); + break; + } + if (dh->dh_version & LKCD_DUMP_MCLX_V0) + printf("%sLKCD_DUMP_MCLX_V0", others++ ? "|" : ""); + if (dh->dh_version & LKCD_DUMP_MCLX_V1) + printf("%sLKCD_DUMP_MCLX_V1", others++ ? "|" : ""); + printf(")\n"); + + field("Header size"); + printf("%" PRIu32 "\n", dh->dh_header_size); + } + + field("Dump level"); + printf("%#" PRIx32 " (", dh->dh_dump_level); + others = 0; + if (dh->dh_dump_level & DUMP_LEVEL_HEADER) + printf("%sDUMP_LEVEL_HEADER", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_LEVEL_KERN) + printf("%sDUMP_LEVEL_KERN", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_LEVEL_USED) + printf("%sDUMP_LEVEL_USED", others++ ? "|" : ""); + if (dh->dh_dump_level & DUMP_LEVEL_ALL) + printf("%sDUMP_LEVEL_ALL", others++ ? "|" : ""); + printf(")\n"); + + field("Dump compression"); + printf("%#" PRIx32 " (", dh->dh_dump_compress); + others = 0; + if (dh->dh_dump_compress == DUMP_COMPRESS_NONE) + printf("%sDUMP_COMPRESS_NONE", others++ ? "|" : ""); + if (dh->dh_dump_compress & DUMP_COMPRESS_RLE) + printf("%sDUMP_COMPRESS_RLE", others++ ? "|" : ""); + if (dh->dh_dump_compress & DUMP_COMPRESS_GZIP) + printf("%sDUMP_COMPRESS_GZIP", others++ ? "|" : ""); + printf(")\n"); + + if (verbose) { + field("Dump flags"); + others = 0; + printf("%#" PRIx32 " (", dh->dh_dump_flags); + if (dh->dh_dump_flags & DUMP_FLAGS_NONDISRUPT) + printf("%sDUMP_FLAGS_NONDISRUPT", others++ ? "|" : ""); + printf(")\n"); + + field("Dump device"); + printf("%" PRIu32 "\n", dh->dh_dump_device); + + field("Page size"); + printf("%" PRIu32 "\n", dh->dh_page_size); + + field("Memory size"); + printf("%#" PRIx64 "\n", dh->dh_memory_size); + + field("Memory start"); + printf("%#" PRIx64 "\n", dh->dh_memory_start); + + field("Memory end"); + printf("%#" PRIx64 "\n", dh->dh_memory_end); + + field("Num pages"); + printf("%" PRIu32 "\n", dh->dh_num_pages); + + field("Current task"); + printf("%#" PRIx64 "\n", dh->dh_current_task); + } + + field("Crash time"); + sec = dh->dh_time.tv_sec; + strftime(buf, sizeof(buf), "%a %b %e %H:%M:%S %Z %Y", + localtime(&sec)); + printf("%s\n", buf); + + field("Kernel name"); + printf("%s\n", dh->dh_utsname_sysname); + field("Node name"); + printf("%s\n", dh->dh_utsname_nodename); + field("Domain name"); + printf("%s\n", dh->dh_utsname_domainname); + field("Kernel release"); + printf("%s\n", dh->dh_utsname_release); + field("Kernel version"); + printf("%s\n", dh->dh_utsname_version); + field("Machine name"); + printf("%s\n", dh->dh_utsname_machine); + + field("Machine type"); + host = 1; + target = from_target_u16(host); + if ((*(char *) &host) && host == target) + printf("little endian\n"); + else + printf("big endian\n"); + + field("Panic message"); + printf("%s\n", dh->dh_panic_string); + + return TRUE; +} + +int lkcd_dump_check_asmheader_v8(int fd) +{ + dump_header_asm_t *dh_asm; + dh_asm = &dump_header_asm_v8; + + if (lseek(fd, dump_header_offset + sizeof(dump_header_t), SEEK_SET) + == ((off_t)-1)) { + incomplete("Could not jump to the asm header at %#" PRIxoff_t, + dump_header_offset + sizeof(dump_header_t)); + return FALSE; + } + + if (read(fd, dh_asm, sizeof(dump_header_asm_t)) != + sizeof(dump_header_asm_t)) { + incomplete("Could not read asm header at %#" PRIxoff_t, + dump_header_offset + sizeof(dump_header_t)); + return FALSE; + } + + swap_asm_header(dh_asm); + + if (silent || !print_asmheader) + return TRUE; + + return arch_print_asmheader_v8(dh_asm); +} + +int lkcd_dump_check_pages_v8(int fd) +{ + int others; + unsigned long pgcnt = 0, cpgs = 0; + ssize_t i, rd; + off_t offs; + char buf[1024]; + dump_page_t *dp; + dump_header_t *dh; + dh = &dump_header_v8; + dp = &dump_page; + + offs = dump_header_offset; + if (dh->dh_page_size < LKCD_OFFSET_TO_FIRST_PAGE) + offs += LKCD_OFFSET_TO_FIRST_PAGE; + else + offs += LKCD_OFFSET_TO_FIRST_BIG_PAGE; + if (lseek(fd, offs, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the page No %lu (%#lx) at " + "%#" PRIxoff_t, pgcnt, pgcnt, offs); + return FALSE; + } + + if (!silent) + printf("\n"); + do { + if (read(fd, dp, sizeof(dump_page_t)) != sizeof(dump_page_t)) { + incomplete("Could not read page header for page No " + "%lu (%#lx)", pgcnt, pgcnt); + return FALSE; + } + + dp->dp_address = from_target_u64(dp->dp_address); + dp->dp_size = from_target_u32(dp->dp_size); + dp->dp_flags = from_target_u32(dp->dp_flags); + + if (dp->dp_flags & ~(DUMP_DH_COMPRESSED|DUMP_DH_RAW| + DUMP_DH_END|LKCD_DUMP_MCLX_V0)) { + corrupted("Unknown page flag in the dump: %#" PRIx32 + ", page No %lu (%#lx)", + dp->dp_flags, pgcnt, pgcnt); + return FALSE; + } + + if (dp->dp_size > dh->dh_page_size) { + corrupted("Page size paradox: dp_size = %#" PRIx32 + ", dh_page_size = %#" PRIx32 + ", page No %lu (%#lx)", dp->dp_flags, + dh->dh_page_size, pgcnt, pgcnt); + return FALSE; + } + + if ((print_pages || (verbose && !pgcnt)) && !silent) { + field("Page No"); + printf("%lu (%#lx)\n", pgcnt, pgcnt); + + field("Page offset"); + printf(PRI2offsNL, offs, offs); + + field("Page address"); + printf("%#" PRIx64 "\n", dp->dp_address); + + field("Page size"); + printf("%" PRIu32 "\n", dp->dp_size); + + field("Page flags"); + printf("%#" PRIx32 " (", dp->dp_flags); + others = 0; + if (dp->dp_flags & DUMP_DH_COMPRESSED) { + printf("%sDUMP_DH_COMPRESSED", others++ ? "|" : ""); + cpgs++; + } + if (dp->dp_flags & DUMP_DH_RAW) + printf("%sDUMP_DH_RAW", others++ ? "|" : ""); + if (dp->dp_flags & DUMP_DH_END) + printf("%sDUMP_DH_END", others++ ? "|" : ""); + if (dp->dp_flags & LKCD_DUMP_MCLX_V0) + printf("%sLKCD_DUMP_MCLX_V0", others++ ? "|" : ""); + printf(")\n"); + } + + if (dp->dp_flags & DUMP_DH_END) + break; + + pgcnt++; + if (lseek(fd, dp->dp_size, SEEK_CUR) == ((off_t)-1)) { + incomplete("Could not jump to the page No %lu (%#lx)", + pgcnt, pgcnt); + return FALSE; + } + offs += dp->dp_size + sizeof(dump_page_t); + } while (1); + + if (pgcnt > dh->dh_num_pages) { + corrupted("Page count paradox: pgcnt = %lu, dh_num_pages = " + "%" PRIu32, pgcnt, dh->dh_num_pages); + return FALSE; + } + + if (pgcnt < dh->dh_num_pages) { + incomplete("%lu pages lost", + (unsigned long) dh->dh_num_pages - pgcnt); + return FALSE; + } + + if (!silent) { + field("Total pages found"); + printf("%lu (%#lx)\n", pgcnt, pgcnt); + field("Compressed pages"); + printf("%lu\n", cpgs); + field("End-page offset"); + printf(PRI2offsNL, offs, offs); + } + + offs += sizeof(dump_page_t); + do { + rd = read(fd, buf, sizeof(buf)); + + for (i = 0; i < rd; i++) + if (buf[i] != 'm') { + offs += i; + if (endless && !silent) { + field("Dump end"); + printf(PRI2offsNL, offs, offs); + + return TRUE; + } + corrupted("Found wrong symbol inside end page " + "at %#" PRIxoff_t, offs); + return FALSE; + } + + offs += rd; + } while (rd > 0); + + return TRUE; +} + +int lkcd_dump_check_end_page_v8(int fd) +{ + dump_page_t *dp; + char buf[1024]; + ssize_t i, len = 0; + off_t offs; + + offs = lseek(fd, 0, SEEK_END); + while (offs > 0) { + offs -= sizeof(buf); + if (lseek(fd, offs, SEEK_SET) == ((off_t)-1)) { + incomplete("Could not jump to the offset %#" PRIxoff_t, offs); + return FALSE; + } + if (read(fd, buf, sizeof(buf)) != sizeof(buf)) { + incomplete("Could not read last page at %#" PRIxoff_t, offs); + return FALSE; + } + for (i = sizeof(buf); i--; ) + if (buf[i] != 'm') { + i++; + if (i < sizeof(dump_page_t)) { + offs += sizeof(buf) / 2; + len -= sizeof(buf) / 2; + break; + } + i -= sizeof(dump_page_t); + goto found; + } + len += sizeof(buf); + } +found: + dp = (dump_page_t *)(buf + i); + offs += i; + if (from_target_u32(dp->dp_flags) == DUMP_DH_END) + if(len) { + if (!silent) { + printf("\n"); + field("End-page offset"); + printf(PRI2offsNL, offs, offs); + } + + return TRUE; + } + + if(!len) + incomplete("Could not find final marker and page header for it."); + else + corrupted("Invalid page header before final marker."); + return FALSE; +} + +#if defined (CRASH_ARM) + +void arch_print_pt_regs(struct target_pt_regs *regs) +{ + int i; + char buf[20]; + const char *fmt = "%#" PRIx32 "\n"; + + for (i=0; i<18; i++) { + sprintf(buf, "UREG[%d]", i); + field(buf); + printf(fmt, regs->uregs[i]); + } +} + +static int arch_print_asmheader_v8(dump_header_asm_t *dha) +{ + int cpu; + const char *fmt = "%#" PRIx32 "\n"; + _dump_regs_t *regs; + dump_header_t *dh; + dh = &dump_header_v8; + + if (strncasecmp(dh->dh_utsname_machine, "arm", 3)) { + corrupted("Unsupported architecture: %s", dh->dh_utsname_machine); + return FALSE; + } + + printf("\n"); + if (verbose) { + field("ASM Magic number"); + printf("%#" PRIx64 "\n", dha->dha_magic_number); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + } + + field("Num CPUs"); + printf("%" PRIu32 "\n", dha->dha_smp_num_cpus); + + field("Dumping CPU"); + printf("%" PRIu32 "\n", dha->dha_dumping_cpu); + + if (verbose) { + field("Physical start"); + printf(fmt, dha->dha_physaddr_start); + + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + regs = &dha->dha_smp_regs[cpu]; + + field("CPU"); + printf("%d\n", cpu); + + field("Saved PSR"); + printf(fmt, regs->dha_ARM_spsr); + + arch_print_pt_regs(®s->dha_ARM_regs); + } + } + + return TRUE; +} + +#elif defined (CRASH_PPC) + +void arch_print_pt_regs(struct target_pt_regs *regs) +{ + int i; + char buf[20]; + const char *fmt = "%#" PRIx32 "\n"; + + for (i=0; i<32; i++) { + sprintf(buf, "GPR[%d]", i); + field(buf); + printf(fmt, regs->gpr[i]); + } + field("NIP"); + printf(fmt, regs->nip); + field("MSR"); + printf(fmt, regs->msr); + field("Orig. GPR3"); + printf(fmt, regs->orig_gpr3); + field("CTR"); + printf(fmt, regs->ctr); + field("LINK"); + printf(fmt, regs->link); + field("XER"); + printf(fmt, regs->xer); + field("CCR"); + printf(fmt, regs->ccr); + field("MQ"); + printf(fmt, regs->mq); + field("TRAP"); + printf(fmt, regs->trap); + field("DAR"); + printf(fmt, regs->dar); + field("DSISR"); + printf(fmt, regs->dsisr); + field("RESULT"); + printf(fmt, regs->result); +} + +static int arch_print_asmheader_v8(dump_header_asm_t *dha) +{ + int cpu; + const char *fmt = "%#" PRIx32 "\n"; + struct target_pt_regs *regs; + dump_header_t *dh; + dh = &dump_header_v8; + + if (strcasecmp(dh->dh_utsname_machine, "ppc") && + strcasecmp(dh->dh_utsname_machine, "ppc32")) { + corrupted("Unsupported architecture: %s", dh->dh_utsname_machine); + return FALSE; + } + + if (dha->dha_version != 0x2) { + corrupted("Unsupported ASM header version: %#" PRIx32, + dha->dha_version); + return FALSE; + } + + printf("\n"); + if (verbose) { + field("ASM Magic number"); + printf("%#" PRIx64 " ", dha->dha_magic_number); + if (dha->dha_magic_number == DUMP_ASM_MAGIC_NUMBER) + printf("(DUMP_ASM_MAGIC_NUMBER)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + } + + field("Num CPUs"); + printf("%" PRIu32 "\n", dha->dha_smp_num_cpus); + + field("Dumping CPU"); + printf("%" PRIu32 "\n", dha->dha_dumping_cpu); + + if (verbose) { + field("R1 (SP) register"); + printf(fmt, dha->dha_r1); + + field("NIP register"); + printf(fmt, dha->dha_nip); + + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + regs = &dha->dha_smp_regs[cpu]; + + field("CPU"); + printf("%d\n", cpu); + + arch_print_pt_regs(regs); + } + } + + return TRUE; +} + +#elif defined (CRASH_X86) + +void arch_print_pt_regs(struct target_pt_regs *regs) +{ + const char *fmt = "%#" PRIx32 "\n"; + + field("EAX"); + printf(fmt, regs->eax); + field("Orig. EAX"); + printf(fmt, regs->orig_eax); + field("EBX"); + printf(fmt, regs->ebx); + field("ECX"); + printf(fmt, regs->ecx); + field("EDX"); + printf(fmt, regs->edx); + field("ESI"); + printf(fmt, regs->esi); + field("EDI"); + printf(fmt, regs->edi); + field("EBP"); + printf(fmt, regs->ebp); + field("ESP"); + printf(fmt, regs->esp); + field("EIP"); + printf(fmt, regs->eip); + field("XDS"); + printf(fmt, regs->xds); + field("XES"); + printf(fmt, regs->xes); + field("XCS"); + printf(fmt, regs->xcs); + field("XSS"); + printf(fmt, regs->xss); + field("EFLAGS"); + printf(fmt, regs->eflags); +} + +static int arch_print_asmheader_v8(dump_header_asm_t *dha) +{ + int cpu; + struct target_pt_regs *regs; + const char *fmt = "%#" PRIx32 "\n"; + dump_header_t *dh; + dh = &dump_header_v8; + + if (strcasecmp(dh->dh_utsname_machine, "i686") && + strcasecmp(dh->dh_utsname_machine, "i586") && + strcasecmp(dh->dh_utsname_machine, "i486") && + strcasecmp(dh->dh_utsname_machine, "i386") && + strcasecmp(dh->dh_utsname_machine, "athlon")) { + corrupted("Unsupported architecture: %s", dh->dh_utsname_machine); + return FALSE; + } + + if (dha->dha_version != 0x3) { + corrupted("Unsupported ASM header version: %#" PRIx32, + dha->dha_version); + return FALSE; + } + + printf("\n"); + if (verbose) { + field("ASM Magic number"); + printf("%#" PRIx64 " ", dha->dha_magic_number); + if (dha->dha_magic_number == DUMP_ASM_MAGIC_NUMBER) + printf("(DUMP_ASM_MAGIC_NUMBER)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + } + + field("Num CPUs"); + printf("%" PRIu32 "\n", dha->dha_smp_num_cpus); + + field("Dumping CPU"); + printf("%" PRIu32 "\n", dha->dha_dumping_cpu); + + if (verbose) { + field("ESP register"); + printf(fmt, dha->dha_esp); + + field("EIP register"); + printf(fmt, dha->dha_eip); + + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + regs = &dha->dha_smp_regs[cpu]; + + field("CPU"); + printf("%d\n", cpu); + + arch_print_pt_regs(regs); + } + } + + return TRUE; +} + +#elif defined (CRASH_PPC64) + +void arch_print_pt_regs(struct target_pt_regs *regs) +{ + int i; + char buf[20]; + const char *fmt = "%#" PRIx64 "\n"; + + for (i=0; i<32; i++) { + sprintf(buf, "GPR[%d]", i); + field(buf); + printf(fmt, regs->gpr[i]); + } + field("NIP"); + printf(fmt, regs->nip); + field("MSR"); + printf(fmt, regs->msr); + field("Orig. GPR3"); + printf(fmt, regs->orig_gpr3); + field("CTR"); + printf(fmt, regs->ctr); + field("LINK"); + printf(fmt, regs->link); + field("XER"); + printf(fmt, regs->xer); + field("CCR"); + printf(fmt, regs->ccr); + field("SOFTE"); + printf(fmt, regs->softe); + field("TRAP"); + printf(fmt, regs->trap); + field("DAR"); + printf(fmt, regs->dar); + field("DSISR"); + printf(fmt, regs->dsisr); + field("RESULT"); + printf(fmt, regs->result); +} + +static int arch_print_asmheader_v8(dump_header_asm_t *dha) +{ + int cpu; + struct target_pt_regs *regs; + dump_header_t *dh; + dh = &dump_header_v8; + + if (strncasecmp(dh->dh_utsname_machine, "ppc64", 5)) { + corrupted("Unsupported architecture: %s", dh->dh_utsname_machine); + return FALSE; + } + + if (dha->dha_version != 0x5) { + corrupted("Unsupported ASM header version: %#" PRIx32, + dha->dha_version); + return FALSE; + } + + printf("\n"); + if (verbose) { + field("ASM Magic number"); + printf("%#" PRIx64 " ", dha->dha_magic_number); + if (dha->dha_magic_number == DUMP_ASM_MAGIC_NUMBER) + printf("(DUMP_ASM_MAGIC_NUMBER)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + } + + field("Num CPUs"); + printf("%" PRIu32 "\n", dha->dha_smp_num_cpus); + + field("Dumping CPU"); + printf("%" PRIu32 "\n", dha->dha_dumping_cpu); + + if (verbose) { + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + regs = &dha->dha_smp_regs[cpu]; + + field("CPU"); + printf("%d\n", cpu); + + arch_print_pt_regs(regs); + } + } + + return TRUE; +} + +#elif defined (CRASH_X86_64) + +void arch_print_pt_regs(struct target_pt_regs *regs) +{ + const char *fmt = "%#" PRIx64 "\n"; + + field("RAX"); + printf(fmt, regs->rax); + field("Orig. RAX"); + printf(fmt, regs->orig_rax); + field("RBX"); + printf(fmt, regs->rbx); + field("RCX"); + printf(fmt, regs->rcx); + field("RDX"); + printf(fmt, regs->rdx); + field("RSI"); + printf(fmt, regs->rsi); + field("RDI"); + printf(fmt, regs->rdi); + field("RBP"); + printf(fmt, regs->rbp); + field("RSP"); + printf(fmt, regs->rsp); + field("RIP"); + printf(fmt, regs->rip); + field("CS"); + printf(fmt, regs->cs); + field("SS"); + printf(fmt, regs->ss); + field("EFLAGS"); + printf(fmt, regs->eflags); + field("R8"); + printf(fmt, regs->r8); + field("R9"); + printf(fmt, regs->r9); + field("R10"); + printf(fmt, regs->r10); + field("R11"); + printf(fmt, regs->r11); + field("R12"); + printf(fmt, regs->r12); + field("R13"); + printf(fmt, regs->r13); + field("R14"); + printf(fmt, regs->r14); + field("R15"); + printf(fmt, regs->r15); +} + +static int arch_print_asmheader_v8(dump_header_asm_t *dha) +{ + int cpu; + struct target_pt_regs *regs; + dump_header_t *dh; + dh = &dump_header_v8; + + if (strcasecmp(dh->dh_utsname_machine, "x86_64")) { + corrupted("Unsupported architecture: %s", dh->dh_utsname_machine); + return FALSE; + } + + if (dha->dha_version != 0x2) { + corrupted("Unsupported ASM header version: %#" PRIx32, + dha->dha_version); + return FALSE; + } + + printf("\n"); + if (verbose) { + field("ASM Magic number"); + printf("%#" PRIx64 " ", dha->dha_magic_number); + if (dha->dha_magic_number == DUMP_ASM_MAGIC_NUMBER) + printf("(DUMP_ASM_MAGIC_NUMBER)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + } + + field("Num CPUs"); + printf("%" PRIu32 "\n", dha->dha_smp_num_cpus); + + field("Dumping CPU"); + printf("%" PRIu32 "\n", dha->dha_dumping_cpu); + + if (verbose) { + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + regs = &dha->dha_smp_regs[cpu]; + + field("CPU"); + printf("%d\n", cpu); + + arch_print_pt_regs(regs); + } + } + + return TRUE; +} + +#elif defined (CRASH_IA64) + +void arch_print_pt_regs(struct target_pt_regs *regs) +{ + const char *fmt = "%#" PRIx64 "\n"; + + field("CR_IPSR"); + printf(fmt, regs->cr_ipsr); + field("CR_IIP"); + printf(fmt, regs->cr_iip); + field("CR_IFS"); + printf(fmt, regs->cr_ifs); + field("AR_UNAT"); + printf(fmt, regs->ar_unat); + field("AR_PFS"); + printf(fmt, regs->ar_pfs); + field("AR_RSC"); + printf(fmt, regs->ar_rsc); + field("AR_RNAT"); + printf(fmt, regs->ar_rnat); + field("AR_BSPSTORE"); + printf(fmt, regs->ar_bspstore); + field("PR"); + printf(fmt, regs->pr); + field("B0"); + printf(fmt, regs->b0); + field("LOADRS"); + printf(fmt, regs->loadrs); + field("R1"); + printf(fmt, regs->r1); + field("R12"); + printf(fmt, regs->r12); + field("R13"); + printf(fmt, regs->r13); +} + +static int arch_print_asmheader_v8(dump_header_asm_t *dha) +{ + int cpu; + struct target_pt_regs *regs; + const char *fmt = "%#" PRIx64 "\n"; + dump_header_t *dh; + dh = &dump_header_v8; + + if (strcasecmp(dh->dh_utsname_machine, "ia64")) { + corrupted("Unsupported architecture: %s", dh->dh_utsname_machine); + return FALSE; + } + + if (dha->dha_version != 0x4) { + corrupted("Unsupported ASM header version: %#" PRIx32, + dha->dha_version); + return FALSE; + } + + printf("\n"); + if (verbose) { + field("ASM Magic number"); + printf("%#" PRIx64 " ", dha->dha_magic_number); + if (dha->dha_magic_number == DUMP_ASM_MAGIC_NUMBER) + printf("(DUMP_ASM_MAGIC_NUMBER)\n"); + else + printf("(?)\n"); + + field("Version"); + printf("%#" PRIx32 "\n", dha->dha_version); + + field("Header size"); + printf("%" PRIu32 "\n", dha->dha_header_size); + } + + field("Num CPUs"); + printf("%" PRIu32 "\n", dha->dha_smp_num_cpus); + + field("Dumping CPU"); + printf("%" PRIu32 "\n", dha->dha_dumping_cpu); + + if (verbose) { + field("Saved RNAT"); + printf(fmt, dha->dha_rnat); + + field("Saved PFS"); + printf(fmt, dha->dha_pfs); + + field("Saved BSPSTORE"); + printf(fmt, dha->dha_bspstore); + + for (cpu=0; cpudha_smp_num_cpus; cpu++) { + regs = &dha->dha_smp_regs[cpu]; + + field("CPU"); + printf("%d\n", cpu); + + arch_print_pt_regs(regs); + } + } + + return TRUE; +} + +#else + +/* + * Arches other than x86, ppc, ppc64 and arm don't have lkcd support + */ + +void arch_print_pt_regs(struct target_pt_regs *regs) +{ +} + +static int arch_print_asmheader_v8(dump_header_asm_t *dha) +{ + printf("\n"); + field("ASM Magic number"); + printf("%#" PRIx64 "\n", dha->dha_magic_number); +/* + field("Dumping CPU"); + printf("%" PRIu32 "\n", dha->dha_dumping_cpu); +*/ + return TRUE; +} + +#endif /* if defined(CRASH_)*/ diff -urpN crash-3.10-11.orig/target_types.h crash-3.10-11.new/target_types.h --- crash-3.10-11.orig/target_types.h 2010-02-12 20:12:36.000000000 +0300 +++ crash-3.10-11.new/target_types.h 2010-03-03 22:07:19.000000000 +0300 @@ -250,6 +250,89 @@ typedef uint32_t target_uint; typedef uint16_t target_ushort; typedef uint64_t target_ptr; +struct ia64_fpreg { + union { + target_ulong bits[2]; + long double __dummy; /* force 16-byte alignment */ + } u; +}; + +struct target_pt_regs { + /* The following registers are saved by SAVE_MIN: */ + target_ulong b6; /* scratch */ + target_ulong b7; /* scratch */ + + target_ulong ar_csd; /* used by cmp8xchg16 (scratch) */ + target_ulong ar_ssd; /* reserved for future use (scratch) */ + + target_ulong r8; /* scratch (return value register 0) */ + target_ulong r9; /* scratch (return value register 1) */ + target_ulong r10; /* scratch (return value register 2) */ + target_ulong r11; /* scratch (return value register 3) */ + + target_ulong cr_ipsr; /* interrupted task's psr */ + target_ulong cr_iip; /* interrupted task's instruction pointer */ + /* + * interrupted task's function state; if bit 63 is cleared, it + * contains syscall's ar.pfs.pfm: + */ + target_ulong cr_ifs; + + target_ulong ar_unat; /* interrupted task's NaT register (preserved) */ + target_ulong ar_pfs; /* prev function state */ + target_ulong ar_rsc; /* RSE configuration */ + /* The following two are valid only if cr_ipsr.cpl > 0: */ + target_ulong ar_rnat; /* RSE NaT */ + target_ulong ar_bspstore; /* RSE bspstore */ + + target_ulong pr; /* 64 predicate registers (1 bit each) */ + target_ulong b0; /* return pointer (bp) */ + target_ulong loadrs; /* size of dirty partition << 16 */ + + target_ulong r1; /* the gp pointer */ + target_ulong r12; /* interrupted task's memory stack pointer */ + target_ulong r13; /* thread pointer */ + + target_ulong ar_fpsr; /* floating point status (preserved) */ + target_ulong r15; /* scratch */ + + /* The remaining registers are NOT saved for system calls. */ + + target_ulong r14; /* scratch */ + target_ulong r2; /* scratch */ + target_ulong r3; /* scratch */ + + /* The following registers are saved by SAVE_REST: */ + target_ulong r16; /* scratch */ + target_ulong r17; /* scratch */ + target_ulong r18; /* scratch */ + target_ulong r19; /* scratch */ + target_ulong r20; /* scratch */ + target_ulong r21; /* scratch */ + target_ulong r22; /* scratch */ + target_ulong r23; /* scratch */ + target_ulong r24; /* scratch */ + target_ulong r25; /* scratch */ + target_ulong r26; /* scratch */ + target_ulong r27; /* scratch */ + target_ulong r28; /* scratch */ + target_ulong r29; /* scratch */ + target_ulong r30; /* scratch */ + target_ulong r31; /* scratch */ + + target_ulong ar_ccv; /* compare/exchange value (scratch) */ + + /* + * Floating point registers that the kernel considers scratch: + */ + struct ia64_fpreg f6; /* scratch */ + struct ia64_fpreg f7; /* scratch */ + struct ia64_fpreg f8; /* scratch */ + struct ia64_fpreg f9; /* scratch */ + struct ia64_fpreg f10; /* scratch */ + struct ia64_fpreg f11; /* scratch */ +}; + #define CRASH_SA_INTERRUPT 0x20000000 #define CRASH_SA_PROBE 0x80000000 #define CRASH_SA_SAMPLE_RANDOM 0x10000000 @@ -271,30 +354,30 @@ typedef uint16_t target_ushort; typedef uint64_t target_ptr; struct target_pt_regs { - unsigned long r15; - unsigned long r14; - unsigned long r13; - unsigned long r12; - unsigned long rbp; - unsigned long rbx; + target_ulong r15; + target_ulong r14; + target_ulong r13; + target_ulong r12; + target_ulong rbp; + target_ulong rbx; /* arguments: non interrupts/non tracing syscalls only save upto here*/ - unsigned long r11; - unsigned long r10; - unsigned long r9; - unsigned long r8; - unsigned long rax; - unsigned long rcx; - unsigned long rdx; - unsigned long rsi; - unsigned long rdi; - unsigned long orig_rax; + target_ulong r11; + target_ulong r10; + target_ulong r9; + target_ulong r8; + target_ulong rax; + target_ulong rcx; + target_ulong rdx; + target_ulong rsi; + target_ulong rdi; + target_ulong orig_rax; /* end of arguments */ /* cpu exception frame or undefined */ - unsigned long rip; - unsigned long cs; - unsigned long eflags; - unsigned long rsp; - unsigned long ss; + target_ulong rip; + target_ulong cs; + target_ulong eflags; + target_ulong rsp; + target_ulong ss; /* top of stack page */ }; diff -urpN crash-3.10-11.orig/Makefile crash-3.10-11.new/Makefile --- crash-3.10-11.orig/Makefile 2010-02-12 22:16:52.000000000 +0300 +++ crash-3.10-11.new/Makefile 2010-03-12 22:51:38.000000000 +0300 @@ -80,6 +80,7 @@ REDHAT_HFILES=netdump.h diskdump.h LKCD_DUMP_HFILES=lkcd_vmdump_v1.h lkcd_vmdump_v2_v3.h lkcd_dump_v5.h \ lkcd_dump_v7.h lkcd_dump_v8.h lkcd_fix_mem.h LKCD_TRACE_HFILES=lkcd_x86_trace.h +LKCD_CHECK_HFILES=check_defs.h IBM_HFILES=ibm_common.h UNWIND_HFILES=unwind.h unwind_i.h rse.h @@ -91,9 +92,13 @@ CFILES=main.c tools.c global_data.c memo lkcd_fix_mem.c s390_dump.c s390x_dump.c lkcd_x86_trace.c \ netdump.c diskdump.c unwind.c unwind_decoder.c +LKCD_CHECK_CFILES=check.c check_tools.c \ + lkcd_v1_check.c lkcd_v3_check.c lkcd_v5_check.c lkcd_v8_check.c + SOURCE_FILES=${CFILES} ${GENERIC_HFILES} ${MCORE_HFILES} \ ${REDHAT_CFILES} ${REDHAT_HFILES} ${UNWIND_HFILES} \ - ${LKCD_DUMP_HFILES} ${LKCD_TRACE_HFILES} ${IBM_HFILES} + ${LKCD_DUMP_HFILES} ${LKCD_TRACE_HFILES} ${IBM_HFILES} \ + ${LKCD_CHECK_HFILES} ${LKCD_CHECK_CFILES} OBJECT_FILES=main.o tools.o global_data.o memory.o filesys.o help.o task.o \ build_data.o kernel.o test.o gdb_interface.o net.o dev.o \ @@ -103,6 +108,9 @@ OBJECT_FILES=main.o tools.o global_data. lkcd_fix_mem.o s390_dump.o s390x_dump.o netdump.o diskdump.o \ lkcd_x86_trace.o unwind_v1.o unwind_v2.o unwind_v3.o +LKCD_CHECK_OBJFILES=build_data.o check.o check_tools.o \ + lkcd_v1_check.o lkcd_v3_check.o lkcd_v5_check.o lkcd_v8_check.o + DAEMON_OBJECT_FILES=remote_daemon.o va_server.o va_server_v1.o \ lkcd_common.o lkcd_v1.o lkcd_v2_v3.o lkcd_v5.o lkcd_v7.o lkcd_v8.o \ s390_dump.o s390x_dump.o netdump_daemon.o @@ -220,6 +228,7 @@ REDHATFLAGS=-DREDHAT all: make_configure ./configure -p "RPMPKG=${RPMPKG}" -t ${FORCE_TARGET} -b make --no-print-directory gdb_merge + make --no-print-directory checklkcd gen_target_config: @echo "#ifndef ${TARGET}" >config_target.h @@ -420,6 +429,24 @@ unwind_v3.o: ${GENERIC_HFILES} ${UNWIND_ lkcd_fix_mem.o: ${GENERIC_HFILES} ${LKCD_HFILES} lkcd_fix_mem.c $(CC) -c ${CFLAGS} lkcd_fix_mem.c ${WARNING_OPTIONS} ${WARNING_ERROR} +check.o: ${LKCD_CHECK_HFILES} check.c + $(CC) -c ${CFLAGS} check.c ${WARNING_OPTIONS} ${WARNING_ERROR} + +check_tools.o: ${LKCD_CHECK_HFILES} check_tools.c + $(CC) -c ${CFLAGS} check_tools.c ${WARNING_OPTIONS} ${WARNING_ERROR} + +lkcd_v1_check.o: ${GENERIC_HFILES} ${LKCD_DUMP_HFILES} ${LKCD_CHECK_HFILES} lkcd_v1_check.c + $(CC) -c ${CFLAGS} -DMCLX lkcd_v1_check.c ${WARNING_OPTIONS} ${WARNING_ERROR} + +lkcd_v3_check.o: ${GENERIC_HFILES} ${LKCD_DUMP_HFILES} ${LKCD_CHECK_HFILES} lkcd_v3_check.c + $(CC) -c ${CFLAGS} -DMCLX lkcd_v3_check.c ${WARNING_OPTIONS} ${WARNING_ERROR} + +lkcd_v5_check.o: ${GENERIC_HFILES} ${LKCD_DUMP_HFILES} ${LKCD_CHECK_HFILES} lkcd_v5_check.c + $(CC) -c ${CFLAGS} -DMCLX lkcd_v5_check.c ${WARNING_OPTIONS} ${WARNING_ERROR} + +lkcd_v8_check.o: ${GENERIC_HFILES} ${LKCD_DUMP_HFILES} ${LKCD_CHECK_HFILES} lkcd_v8_check.c + $(CC) -c ${CFLAGS} -DMCLX lkcd_v8_check.c ${WARNING_OPTIONS} ${WARNING_ERROR} + ${PROGRAM}: force make --no-print-directory all @@ -436,6 +463,9 @@ ${PROGRAM}d: daemon_deprecated make_conf daemon: ${DAEMON_OBJECT_FILES} $(CC) ${LDFLAGS} -o ${PROGRAM}d ${DAEMON_OBJECT_FILES} build_data.o -lz +checklkcd: ${LKCD_CHECK_OBJFILES} + $(CC) ${LDFLAGS} -o $@ ${LKCD_CHECK_OBJFILES} + files: make_configure ./configure -q -b make --no-print-directory show_files