September 2021 - Crash-utility - Crash Utility List Archives

[PATCH v3] diskdump: Add support for reading dumpfiles compressed by Zstandard

by HAGIO KAZUHITO(萩尾　一仁)

Add support for reading dumpfiles compressed by Zstandard (zstd) using makedumpfile. To build crash with zstd support, type "make zstd". Signed-off-by: Kazuhito Hagio <k-hagio-ab(a)nec.com> --- v2 -> v3 - add a 'For zstd:' section in the comment above add_extra_lib() - move ZSTD_createDCtx() into cache_page() and add an error when it cannot create dctx - add a sanity check on retlen Makefile | 4 ++++ README | 4 ++-- configure.c | 24 +++++++++++++++++++++--- defs.h | 4 ++++ diskdump.c | 38 ++++++++++++++++++++++++++++++++++++++ diskdump.h | 1 + help.c | 4 ++-- 7 files changed, 72 insertions(+), 7 deletions(-) diff --git a/Makefile b/Makefile index ece13069a029..eae023c54bdd 100644 --- a/Makefile +++ b/Makefile @@ -333,6 +333,10 @@ snappy: make_configure @./configure -x snappy ${CONF_TARGET_FLAG} -w -b @make --no-print-directory gdb_merge +zstd: make_configure + @./configure -x zstd ${CONF_TARGET_FLAG} -w -b + @make --no-print-directory gdb_merge + valgrind: make_configure @./configure -x valgrind ${CONF_TARGET_FLAG} -w -b @make --no-print-directory gdb_merge diff --git a/README b/README index 50179742e620..4962f272074b 100644 --- a/README +++ b/README @@ -102,8 +102,8 @@ Traditionally when vmcores are compressed via the makedumpfile(8) facility the libz compression library is used, and by default the crash utility only supports libz. Recently makedumpfile has been enhanced to optionally - use either the LZO or snappy compression libraries. To build crash with - either or both of those libraries, type "make lzo" or "make snappy". + use the LZO, snappy or zstd compression libraries. To build crash with any + or all of those libraries, type "make lzo", "make snappy" or "make zstd". crash supports valgrind Memcheck tool on the crash's custom memory allocator. To build crash with this feature enabled, type "make valgrind" and then run diff --git a/configure.c b/configure.c index e8f619a3c061..b691a139b960 100644 --- a/configure.c +++ b/configure.c @@ -1738,6 +1738,10 @@ get_extra_flags(char *filename, char *initial) * - enter -DSNAPPY in the CFLAGS.extra file * - enter -lsnappy in the LDFLAGS.extra file * + * For zstd: + * - enter -DZSTD in the CFLAGS.extra file + * - enter -lzstd in the LDFLAGS.extra file + * * For valgrind: * - enter -DVALGRIND in the CFLAGS.extra file */ @@ -1746,6 +1750,7 @@ add_extra_lib(char *option) { int lzo, add_DLZO, add_llzo2; int snappy, add_DSNAPPY, add_lsnappy; + int zstd, add_DZSTD, add_lzstd; int valgrind, add_DVALGRIND; char *cflags, *ldflags; FILE *fp_cflags, *fp_ldflags; @@ -1754,6 +1759,7 @@ add_extra_lib(char *option) lzo = add_DLZO = add_llzo2 = 0; snappy = add_DSNAPPY = add_lsnappy = 0; + zstd = add_DZSTD = add_lzstd = 0; valgrind = add_DVALGRIND = 0; ldflags = get_extra_flags("LDFLAGS.extra", NULL); @@ -1775,13 +1781,21 @@ add_extra_lib(char *option) add_lsnappy++; } + if (strcmp(option, "zstd") == 0) { + zstd++; + if (!cflags || !strstr(cflags, "-DZSTD")) + add_DZSTD++; + if (!ldflags || !strstr(ldflags, "-lzstd")) + add_lzstd++; + } + if (strcmp(option, "valgrind") == 0) { valgrind++; if (!cflags || !strstr(cflags, "-DVALGRIND")) add_DVALGRIND++; } - if ((lzo || snappy) && + if ((lzo || snappy || zstd) && file_exists("diskdump.o") && (unlink("diskdump.o") < 0)) { perror("diskdump.o"); return; @@ -1806,24 +1820,28 @@ add_extra_lib(char *option) return; } - if (add_DLZO || add_DSNAPPY || add_DVALGRIND) { + if (add_DLZO || add_DSNAPPY || add_DZSTD || add_DVALGRIND) { while (fgets(inbuf, 512, fp_cflags)) ; if (add_DLZO) fputs("-DLZO\n", fp_cflags); if (add_DSNAPPY) fputs("-DSNAPPY\n", fp_cflags); + if (add_DZSTD) + fputs("-DZSTD\n", fp_cflags); if (add_DVALGRIND) fputs("-DVALGRIND\n", fp_cflags); } - if (add_llzo2 || add_lsnappy) { + if (add_llzo2 || add_lsnappy || add_lzstd) { while (fgets(inbuf, 512, fp_ldflags)) ; if (add_llzo2) fputs("-llzo2\n", fp_ldflags); if (add_lsnappy) fputs("-lsnappy\n", fp_ldflags); + if (add_lzstd) + fputs("-lzstd\n", fp_ldflags); } fclose(fp_cflags); diff --git a/defs.h b/defs.h index eb1c71b5333a..b2e94722c92b 100644 --- a/defs.h +++ b/defs.h @@ -54,6 +54,9 @@ #ifdef SNAPPY #include <snappy-c.h> #endif +#ifdef ZSTD +#include <zstd.h> +#endif #ifndef ATTRIBUTE_UNUSED #define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) @@ -327,6 +330,7 @@ struct number_option { #define NO_ELF_NOTES (0x20) #define LZO_SUPPORTED (0x40) #define SNAPPY_SUPPORTED (0x80) +#define ZSTD_SUPPORTED (0x100) #define DISKDUMP_VALID() (dd->flags & DISKDUMP_LOCAL) #define KDUMP_CMPRS_VALID() (dd->flags & KDUMP_CMPRS_LOCAL) #define KDUMP_SPLIT() (dd->flags & DUMPFILE_SPLIT) diff --git a/diskdump.c b/diskdump.c index de3eeb2c720c..9e80cd3d6f52 100644 --- a/diskdump.c +++ b/diskdump.c @@ -96,6 +96,10 @@ static struct diskdump_data **dd_list = NULL; static int num_dd = 0; static int num_dumpfiles = 0; +#ifdef ZSTD +static ZSTD_DCtx *dctx = NULL; +#endif + int dumpfile_is_split(void) { return KDUMP_SPLIT(); @@ -1001,6 +1005,9 @@ is_diskdump(char *file) #ifdef SNAPPY dd->flags |= SNAPPY_SUPPORTED; #endif +#ifdef ZSTD + dd->flags |= ZSTD_SUPPORTED; +#endif pc->read_vmcoreinfo = vmcoreinfo_read_string; @@ -1251,6 +1258,33 @@ cache_page(physaddr_t paddr) ret); return READ_ERROR; } +#endif + } else if (pd.flags & DUMP_DH_COMPRESSED_ZSTD) { + + if (!(dd->flags & ZSTD_SUPPORTED)) { + error(INFO, "%s: uncompess failed: no zstd compression support\n", + DISKDUMP_VALID() ? "diskdump" : "compressed kdump"); + return READ_ERROR; + } +#ifdef ZSTD + if (!dctx) + dctx = ZSTD_createDCtx(); + + if (!dctx) { + error(INFO, "%s: uncompess failed: cannot create ZSTD_DCtx\n", + DISKDUMP_VALID() ? "diskdump" : "compressed kdump"); + return READ_ERROR; + } + + retlen = ZSTD_decompressDCtx(dctx, + dd->page_cache_hdr[i].pg_bufptr, block_size, + dd->compressed_page, pd.size); + if (ZSTD_isError(retlen) || (retlen != block_size)) { + error(INFO, "%s: uncompress failed: %d (%s)\n", + DISKDUMP_VALID() ? "diskdump" : "compressed kdump", + retlen, ZSTD_getErrorName(retlen)); + return READ_ERROR; + } #endif } else memcpy(dd->page_cache_hdr[i].pg_bufptr, @@ -1806,6 +1840,8 @@ __diskdump_memory_dump(FILE *fp) fprintf(fp, "%sLZO_SUPPORTED", others++ ? "|" : ""); if (dd->flags & SNAPPY_SUPPORTED) fprintf(fp, "%sSNAPPY_SUPPORTED", others++ ? "|" : ""); + if (dd->flags & ZSTD_SUPPORTED) + fprintf(fp, "%sZSTD_SUPPORTED", others++ ? "|" : ""); fprintf(fp, ") %s\n", FLAT_FORMAT() ? "[FLAT]" : ""); fprintf(fp, " dfd: %d\n", dd->dfd); fprintf(fp, " ofp: %lx\n", (ulong)dd->ofp); @@ -1872,6 +1908,8 @@ __diskdump_memory_dump(FILE *fp) fprintf(fp, "DUMP_DH_COMPRESSED_LZO"); if (dh->status & DUMP_DH_COMPRESSED_SNAPPY) fprintf(fp, "DUMP_DH_COMPRESSED_SNAPPY"); + if (dh->status & DUMP_DH_COMPRESSED_ZSTD) + fprintf(fp, "DUMP_DH_COMPRESSED_ZSTD"); if (dh->status & DUMP_DH_COMPRESSED_INCOMPLETE) fprintf(fp, "DUMP_DH_COMPRESSED_INCOMPLETE"); if (dh->status & DUMP_DH_EXCLUDED_VMEMMAP) diff --git a/diskdump.h b/diskdump.h index 28713407b841..c152c7b86616 100644 --- a/diskdump.h +++ b/diskdump.h @@ -86,6 +86,7 @@ struct kdump_sub_header { #define DUMP_DH_COMPRESSED_SNAPPY 0x4 /* page is compressed with snappy */ #define DUMP_DH_COMPRESSED_INCOMPLETE 0x8 /* dumpfile is incomplete */ #define DUMP_DH_EXCLUDED_VMEMMAP 0x10 /* unused vmemmap pages are excluded */ +#define DUMP_DH_COMPRESSED_ZSTD 0x20 /* page is compressed with zstd */ /* descriptor of each page for vmcore */ typedef struct page_desc { diff --git a/help.c b/help.c index 6c262a3ffcbb..f34838d59908 100644 --- a/help.c +++ b/help.c @@ -9420,8 +9420,8 @@ README_ENTER_DIRECTORY, " Traditionally when vmcores are compressed via the makedumpfile(8) facility", " the libz compression library is used, and by default the crash utility", " only supports libz. Recently makedumpfile has been enhanced to optionally", -" use either the LZO or snappy compression libraries. To build crash with", -" either or both of those libraries, type \"make lzo\" or \"make snappy\".", +" use the LZO, snappy or zstd compression libraries. To build crash with any", +" or all of those libraries, type \"make lzo\", \"make snappy\" or \"make zstd\".", "", " crash supports valgrind Memcheck tool on the crash's custom memory allocator.", " To build crash with this feature enabled, type \"make valgrind\" and then run", -- 2.27.0

2 years, 9 months

1
0
0 / 0

[PATCH v2] diskdump: Add support for reading dumpfiles compressed by Zstandard

by HAGIO KAZUHITO(萩尾　一仁)

-----Original Message----- > @@ -1002,6 +1006,11 @@ is_diskdump(char *file) > dd->flags |= SNAPPY_SUPPORTED; > #endif > > +#ifdef ZSTD > + if ((dctx = ZSTD_createDCtx()) != NULL) > + dd->flags |= ZSTD_SUPPORTED; I found that this part allocates dctx superfluously for split dumpfiles, so sending v2. -- From: Kazuhito Hagio <k-hagio(a)ab.jp.nec.com> Subject: [PATCH] diskdump: Add support for reading dumpfiles compressed by Zstandard Add support for reading dumpfiles compressed by Zstandard (zstd) using makedumpfile. To build crash with zstd support, type "make zstd". Signed-off-by: Kazuhito Hagio <k-hagio-ab(a)nec.com> --- Makefile | 4 ++++ README | 4 ++-- configure.c | 20 +++++++++++++++++--- defs.h | 4 ++++ diskdump.c | 33 +++++++++++++++++++++++++++++++++ diskdump.h | 1 + help.c | 4 ++-- 7 files changed, 63 insertions(+), 7 deletions(-) diff --git a/Makefile b/Makefile index ece13069a029..eae023c54bdd 100644 --- a/Makefile +++ b/Makefile @@ -333,6 +333,10 @@ snappy: make_configure @./configure -x snappy ${CONF_TARGET_FLAG} -w -b @make --no-print-directory gdb_merge +zstd: make_configure + @./configure -x zstd ${CONF_TARGET_FLAG} -w -b + @make --no-print-directory gdb_merge + valgrind: make_configure @./configure -x valgrind ${CONF_TARGET_FLAG} -w -b @make --no-print-directory gdb_merge diff --git a/README b/README index 50179742e620..4962f272074b 100644 --- a/README +++ b/README @@ -102,8 +102,8 @@ Traditionally when vmcores are compressed via the makedumpfile(8) facility the libz compression library is used, and by default the crash utility only supports libz. Recently makedumpfile has been enhanced to optionally - use either the LZO or snappy compression libraries. To build crash with - either or both of those libraries, type "make lzo" or "make snappy". + use the LZO, snappy or zstd compression libraries. To build crash with any + or all of those libraries, type "make lzo", "make snappy" or "make zstd". crash supports valgrind Memcheck tool on the crash's custom memory allocator. To build crash with this feature enabled, type "make valgrind" and then run diff --git a/configure.c b/configure.c index e8f619a3c061..9548720ef64a 100644 --- a/configure.c +++ b/configure.c @@ -1746,6 +1746,7 @@ add_extra_lib(char *option) { int lzo, add_DLZO, add_llzo2; int snappy, add_DSNAPPY, add_lsnappy; + int zstd, add_DZSTD, add_lzstd; int valgrind, add_DVALGRIND; char *cflags, *ldflags; FILE *fp_cflags, *fp_ldflags; @@ -1754,6 +1755,7 @@ add_extra_lib(char *option) lzo = add_DLZO = add_llzo2 = 0; snappy = add_DSNAPPY = add_lsnappy = 0; + zstd = add_DZSTD = add_lzstd = 0; valgrind = add_DVALGRIND = 0; ldflags = get_extra_flags("LDFLAGS.extra", NULL); @@ -1775,13 +1777,21 @@ add_extra_lib(char *option) add_lsnappy++; } + if (strcmp(option, "zstd") == 0) { + zstd++; + if (!cflags || !strstr(cflags, "-DZSTD")) + add_DZSTD++; + if (!ldflags || !strstr(ldflags, "-lzstd")) + add_lzstd++; + } + if (strcmp(option, "valgrind") == 0) { valgrind++; if (!cflags || !strstr(cflags, "-DVALGRIND")) add_DVALGRIND++; } - if ((lzo || snappy) && + if ((lzo || snappy || zstd) && file_exists("diskdump.o") && (unlink("diskdump.o") < 0)) { perror("diskdump.o"); return; @@ -1806,24 +1816,28 @@ add_extra_lib(char *option) return; } - if (add_DLZO || add_DSNAPPY || add_DVALGRIND) { + if (add_DLZO || add_DSNAPPY || add_DZSTD || add_DVALGRIND) { while (fgets(inbuf, 512, fp_cflags)) ; if (add_DLZO) fputs("-DLZO\n", fp_cflags); if (add_DSNAPPY) fputs("-DSNAPPY\n", fp_cflags); + if (add_DZSTD) + fputs("-DZSTD\n", fp_cflags); if (add_DVALGRIND) fputs("-DVALGRIND\n", fp_cflags); } - if (add_llzo2 || add_lsnappy) { + if (add_llzo2 || add_lsnappy || add_lzstd) { while (fgets(inbuf, 512, fp_ldflags)) ; if (add_llzo2) fputs("-llzo2\n", fp_ldflags); if (add_lsnappy) fputs("-lsnappy\n", fp_ldflags); + if (add_lzstd) + fputs("-lzstd\n", fp_ldflags); } fclose(fp_cflags); diff --git a/defs.h b/defs.h index eb1c71b5333a..b2e94722c92b 100644 --- a/defs.h +++ b/defs.h @@ -54,6 +54,9 @@ #ifdef SNAPPY #include <snappy-c.h> #endif +#ifdef ZSTD +#include <zstd.h> +#endif #ifndef ATTRIBUTE_UNUSED #define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) @@ -327,6 +330,7 @@ struct number_option { #define NO_ELF_NOTES (0x20) #define LZO_SUPPORTED (0x40) #define SNAPPY_SUPPORTED (0x80) +#define ZSTD_SUPPORTED (0x100) #define DISKDUMP_VALID() (dd->flags & DISKDUMP_LOCAL) #define KDUMP_CMPRS_VALID() (dd->flags & KDUMP_CMPRS_LOCAL) #define KDUMP_SPLIT() (dd->flags & DUMPFILE_SPLIT) diff --git a/diskdump.c b/diskdump.c index de3eeb2c720c..029f363ccffc 100644 --- a/diskdump.c +++ b/diskdump.c @@ -96,6 +96,10 @@ static struct diskdump_data **dd_list = NULL; static int num_dd = 0; static int num_dumpfiles = 0; +#ifdef ZSTD +static ZSTD_DCtx *dctx = NULL; +#endif + int dumpfile_is_split(void) { return KDUMP_SPLIT(); @@ -1002,6 +1006,13 @@ is_diskdump(char *file) dd->flags |= SNAPPY_SUPPORTED; #endif +#ifdef ZSTD + if (!dctx) + dctx = ZSTD_createDCtx(); + if (dctx) + dd->flags |= ZSTD_SUPPORTED; +#endif + pc->read_vmcoreinfo = vmcoreinfo_read_string; if ((pc->flags2 & GET_LOG) && KDUMP_CMPRS_VALID()) { @@ -1251,6 +1262,24 @@ cache_page(physaddr_t paddr) ret); return READ_ERROR; } +#endif + } else if (pd.flags & DUMP_DH_COMPRESSED_ZSTD) { + + if (!(dd->flags & ZSTD_SUPPORTED)) { + error(INFO, "%s: uncompess failed: no zstd compression support\n", + DISKDUMP_VALID() ? "diskdump" : "compressed kdump"); + return READ_ERROR; + } +#ifdef ZSTD + retlen = ZSTD_decompressDCtx(dctx, + dd->page_cache_hdr[i].pg_bufptr, block_size, + dd->compressed_page, pd.size); + if (ZSTD_isError(retlen)) { + error(INFO, "%s: uncompress failed: %d (%s)\n", + DISKDUMP_VALID() ? "diskdump" : "compressed kdump", + retlen, ZSTD_getErrorName(retlen)); + return READ_ERROR; + } #endif } else memcpy(dd->page_cache_hdr[i].pg_bufptr, @@ -1806,6 +1835,8 @@ __diskdump_memory_dump(FILE *fp) fprintf(fp, "%sLZO_SUPPORTED", others++ ? "|" : ""); if (dd->flags & SNAPPY_SUPPORTED) fprintf(fp, "%sSNAPPY_SUPPORTED", others++ ? "|" : ""); + if (dd->flags & ZSTD_SUPPORTED) + fprintf(fp, "%sZSTD_SUPPORTED", others++ ? "|" : ""); fprintf(fp, ") %s\n", FLAT_FORMAT() ? "[FLAT]" : ""); fprintf(fp, " dfd: %d\n", dd->dfd); fprintf(fp, " ofp: %lx\n", (ulong)dd->ofp); @@ -1872,6 +1903,8 @@ __diskdump_memory_dump(FILE *fp) fprintf(fp, "DUMP_DH_COMPRESSED_LZO"); if (dh->status & DUMP_DH_COMPRESSED_SNAPPY) fprintf(fp, "DUMP_DH_COMPRESSED_SNAPPY"); + if (dh->status & DUMP_DH_COMPRESSED_ZSTD) + fprintf(fp, "DUMP_DH_COMPRESSED_ZSTD"); if (dh->status & DUMP_DH_COMPRESSED_INCOMPLETE) fprintf(fp, "DUMP_DH_COMPRESSED_INCOMPLETE"); if (dh->status & DUMP_DH_EXCLUDED_VMEMMAP) diff --git a/diskdump.h b/diskdump.h index 28713407b841..c152c7b86616 100644 --- a/diskdump.h +++ b/diskdump.h @@ -86,6 +86,7 @@ struct kdump_sub_header { #define DUMP_DH_COMPRESSED_SNAPPY 0x4 /* page is compressed with snappy */ #define DUMP_DH_COMPRESSED_INCOMPLETE 0x8 /* dumpfile is incomplete */ #define DUMP_DH_EXCLUDED_VMEMMAP 0x10 /* unused vmemmap pages are excluded */ +#define DUMP_DH_COMPRESSED_ZSTD 0x20 /* page is compressed with zstd */ /* descriptor of each page for vmcore */ typedef struct page_desc { diff --git a/help.c b/help.c index 6c262a3ffcbb..f34838d59908 100644 --- a/help.c +++ b/help.c @@ -9420,8 +9420,8 @@ README_ENTER_DIRECTORY, " Traditionally when vmcores are compressed via the makedumpfile(8) facility", " the libz compression library is used, and by default the crash utility", " only supports libz. Recently makedumpfile has been enhanced to optionally", -" use either the LZO or snappy compression libraries. To build crash with", -" either or both of those libraries, type \"make lzo\" or \"make snappy\".", +" use the LZO, snappy or zstd compression libraries. To build crash with any", +" or all of those libraries, type \"make lzo\", \"make snappy\" or \"make zstd\".", "", " crash supports valgrind Memcheck tool on the crash's custom memory allocator.", " To build crash with this feature enabled, type \"make valgrind\" and then run", -- 2.27.0

2 years, 9 months

2
2
0 / 0

[PATCH] arm64 : assign page_offset and kvbase based on VA_BITS passed

by Ankur Bansal

assign page_offset and kvbase based on VA_BITS passed Change-Id: I525f3c7fd91e1f06e909c2f4c1749c44c068baea Signed-off-by: Ankur Bansal <er.ankurbansal(a)gmail.com> --- arm64.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/arm64.c b/arm64.c index 7069312..2dc77f7 100644 --- a/arm64.c +++ b/arm64.c @@ -220,10 +220,17 @@ arm64_init(int when) /* vabits_actual introduced after mm flip, so it should be flipped layout */ if (ms->VA_BITS_ACTUAL) { - ms->page_offset = ARM64_FLIP_PAGE_OFFSET; - /* useless on arm64 */ - machdep->identity_map_base = ARM64_FLIP_PAGE_OFFSET; - machdep->kvbase = ARM64_FLIP_PAGE_OFFSET; + if ((pc->flags2 & SNAP)) { + ms->page_offset = ARM64_FLIP_PAGE_OFFSET; + /* useless on arm64 */ + machdep->identity_map_base = ARM64_FLIP_PAGE_OFFSET; + machdep->kvbase = ARM64_FLIP_PAGE_OFFSET; + } + else{ + ms->page_offset = ARM64_FLIP_PAGE_OFFSET_ACTUAL; + machdep->identity_map_base = ARM64_FLIP_PAGE_OFFSET_ACTUAL; + machdep->kvbase = ARM64_FLIP_PAGE_OFFSET_ACTUAL; + } ms->userspace_top = ARM64_USERSPACE_TOP_ACTUAL; } else { ms->page_offset = ARM64_PAGE_OFFSET; -- 2.7.4

2 years, 9 months

1
0
0 / 0

Inaccurate timestamps in log -T output

by Moore, Martin (Linux ERT)

Hello, As the current maintainer of the PyKdump extension, I have been investigating a reported discrepancy between the timestamps generated by crash's log -T and PyKdump's tslog command, which provides the same functionality of timestamping the kernel log entries. What I have found is that *both* log -T and tslog generate some inaccurate timestamps on vmcores with more than a small amount of uptime, but in different ways. Specifically, log -T timestamps are accurate at boot time but become less accurate later in the log, while tslog timestamps are just the opposite: they're accurate around crash time but less accurate earlier in the log. Here's an example from a panic on a kernel 3.10.0-957.5.1 system with a moderate uptime: DATE: Tue Jul 6 09:50:58 +03 2021 UPTIME: 32 days, 16:29:29 PANIC: "BUG: unable to handle kernel " Crash correctly computes the boot time based on the date (crash time) and uptime shown above. From "help -k": boot_date: Thu Jun 3 17:21:29 +03 2021 log -T shows the correct timestamps of the boot messages: [Thu Jun 3 17:21:29 +03 2021] Initializing cgroup subsys cpuset [Thu Jun 3 17:21:29 +03 2021] Initializing cgroup subsys cpu [Thu Jun 3 17:21:29 +03 2021] Initializing cgroup subsys cpuacct However, the timestamps of the BUG and surrounding messages are off by 150 seconds or 2.5 minutes (09:53:28, but the crash occurred at 09:50:58): [Tue Jul 6 09:53:28 +03 2021] BUG: unable to handle kernel [Tue Jul 6 09:53:28 +03 2021] NULL pointer dereference at (null) [Tue Jul 6 09:53:28 +03 2021] IP: [<ffffffff91cd6e66>] scsi_uninit_cmd+0x26/0x40 For comparison, tslog has the correct timestamps around the crash: 2021-07-06 09:50:58 [2824319.188837] BUG: unable to handle kernel 2021-07-06 09:50:58 [2824319.193440] NULL pointer dereference at (null) 2021-07-06 09:50:58 [2824319.197853] IP: [<ffffffff91cd6e66>] scsi_uninit_cmd+0x26/0x40 But it's off by the same 2.5-minute interval during the boot messages (17:18:59, but it should be 17:21:29): 2021-06-03 17:18:59 [ 0.000000] Initializing cgroup subsys cpuset 2021-06-03 17:18:59 [ 0.000000] Initializing cgroup subsys cpu 2021-06-03 17:18:59 [ 0.000000] Initializing cgroup subsys cpuacct The reasons for these inaccuracies are: 1. log -T computes boot time as (crash time minus uptime), and then adds the seconds part of the time stored in each log entry to generate the entry's timestamp. 2. tslog computes a base time as (crash time minus seconds part of the final log entry) and then adds the seconds part of the time stored in each log entry. 3. The key to the problem: printk() stores the log entry timestamp based on a call to local_clock(), which provides the raw time in the local CPU, which is not adjusted by NTP. As such, inaccuracy accumulates as the clock drifts over time; in the example above, the discrepancy has reached 150 seconds by the time of the crash. I have seen this now in numerous vmcores from kernels 3.0 through 4.12, which is the latest version I've checked. The discrepancy exists in all of them with more than a few hours of uptime and can be positive or negative. In one vmcore it was over 13 hours after 239 days of uptime. >From the PyKdump perspective, I could live with the current tslog behavior because it's accurate for log entries near the crash time, which are generally the most useful for crash analysis. But in an attempt to improve it, I'm testing an experimental version of tslog that smooths out the discrepancy. It computes the boot time the same way that crash does (crash time minus uptime) and a scale factor for the time discrepancy equal to (uptime)/(seconds part of final log entry). Then each log entry's timestamp is computed as (boot time) + (seconds part of log entry)*(scale factor). This version results in correct timestamps at both ends of the log: 2021-06-03 17:21:29 [ 0.000000] Initializing cgroup subsys cpuset 2021-06-03 17:21:29 [ 0.000000] Initializing cgroup subsys cpu 2021-06-03 17:21:29 [ 0.000000] Initializing cgroup subsys cpuacct : 2021-07-06 09:50:58 [2824319.188837] BUG: unable to handle kernel 2021-07-06 09:50:58 [2824319.193440] NULL pointer dereference at (null) 2021-07-06 09:50:58 [2824319.197853] IP: [<ffffffff91cd6e66>] scsi_uninit_cmd+0x26/0x40 This is something of a hack since there's no guarantee that the clock will drift uniformly during the system uptime, so timestamps in the middle of the log may still be somewhat inaccurate (but probably more accurate than without this adjustment). Regards, Martin Explore the HPE digital support experience: https://support.hpe.com Martin Moore Linux Engineering Resolution Team HPE Pointnext Services Hewlett Packard Enterprise Martin.Moore(a)hpe.com<mailto:Martin.Moore@hpe.com> 8AM-5PM EDT (UTC-4) Monday-Friday Manager: Becky McBride (becky.mcbride(a)hpe.com<mailto:becky.mcbride@hpe.com>)

2 years, 9 months

2
1
0 / 0

[PATCH 1/3] .gitignore: Add cscope, ctags & compile_commands.json in .gitignore

by Ritesh Harjani

Add cscope, ctags & compile_commands.json in .gitignore file. Signed-off-by: Ritesh Harjani <riteshh(a)linux.ibm.com> --- .gitignore | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/.gitignore b/.gitignore index 5b2ba1d..b39832f 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,14 @@ gdb-7.6/ extensions/defs.h extensions/*.so extensions/eppic + +# cscope files +cscope.* +ncscope.* + +# ctags files +tags +TAGS + +# Clang's compilation database file +/compile_commands.json -- 2.31.1

2 years, 9 months

3
8
0 / 0

[PATCH v3 0/4] Improve kernel modules symbol searching performance

by Tao Liu

This patch set improves symbol_search/symbol_exists performance by introducing hash table for kernel modules symbols. v2 -> v3: 1) Seperate v2 patch into multiple patches. 2) Several code indented formatting. 3) Moved "if (sp != NULL)" check from mod_symtable_hash_install/remove_range into symname_hash_install/remove, and shorten it to be "if (!sp)" check. 4) Replaced "index = index > 0 ? index : -index;" into abs() in SYMNAME_HASH_INDEX macro. 5) Replaced the code of remove hash table elements in symname_hash_remove with Kazu's version, and variable "tmp" of v2 patch get removed. 6) Removed "first_encounter" check in symname_hash_remove. 7) Add assert check in symname_hash_install. Tao Liu (4): Improve the performance of symbol searching for kernel modules Get the absolute value of SYMNAME_HASH_INDEX Set name_hash_next field to be NULL for the newly installed elements Add assert check if an element is installed one more time defs.h | 3 +- kernel.c | 1 + symbols.c | 170 +++++++++++++++++++++++++++++------------------------- 3 files changed, 95 insertions(+), 79 deletions(-) -- 2.29.2

2 years, 9 months

2
10
0 / 0

[PATCH] diskdump: Add support for reading dumpfiles compressed by Zstandard

by HAGIO KAZUHITO(萩尾　一仁)

Hi, Tao Liu posted the patchset that adds zstd support to makedumpfile [1], this is a corresponding patch for crash. [1] http://lists.infradead.org/pipermail/kexec/2021-September/023011.html -- >From ed05f25eefb870b9d08575276d487fe195f7b832 Mon Sep 17 00:00:00 2001 From: Kazuhito Hagio <k-hagio(a)ab.jp.nec.com> Date: Thu, 12 Sep 2019 11:53:08 -0400 Subject: [PATCH] diskdump: Add support for reading dumpfiles compressed by Zstandard Add support for reading dumpfiles compressed by Zstandard (zstd) using makedumpfile. To build crash with zstd support, type "make zstd". Signed-off-by: Kazuhito Hagio <k-hagio-ab(a)nec.com> --- Makefile | 4 ++++ README | 4 ++-- configure.c | 20 +++++++++++++++++--- defs.h | 4 ++++ diskdump.c | 31 +++++++++++++++++++++++++++++++ diskdump.h | 1 + help.c | 4 ++-- 7 files changed, 61 insertions(+), 7 deletions(-) diff --git a/Makefile b/Makefile index ece13069a029..eae023c54bdd 100644 --- a/Makefile +++ b/Makefile @@ -333,6 +333,10 @@ snappy: make_configure @./configure -x snappy ${CONF_TARGET_FLAG} -w -b @make --no-print-directory gdb_merge +zstd: make_configure + @./configure -x zstd ${CONF_TARGET_FLAG} -w -b + @make --no-print-directory gdb_merge + valgrind: make_configure @./configure -x valgrind ${CONF_TARGET_FLAG} -w -b @make --no-print-directory gdb_merge diff --git a/README b/README index 50179742e620..4962f272074b 100644 --- a/README +++ b/README @@ -102,8 +102,8 @@ Traditionally when vmcores are compressed via the makedumpfile(8) facility the libz compression library is used, and by default the crash utility only supports libz. Recently makedumpfile has been enhanced to optionally - use either the LZO or snappy compression libraries. To build crash with - either or both of those libraries, type "make lzo" or "make snappy". + use the LZO, snappy or zstd compression libraries. To build crash with any + or all of those libraries, type "make lzo", "make snappy" or "make zstd". crash supports valgrind Memcheck tool on the crash's custom memory allocator. To build crash with this feature enabled, type "make valgrind" and then run diff --git a/configure.c b/configure.c index e8f619a3c061..9548720ef64a 100644 --- a/configure.c +++ b/configure.c @@ -1746,6 +1746,7 @@ add_extra_lib(char *option) { int lzo, add_DLZO, add_llzo2; int snappy, add_DSNAPPY, add_lsnappy; + int zstd, add_DZSTD, add_lzstd; int valgrind, add_DVALGRIND; char *cflags, *ldflags; FILE *fp_cflags, *fp_ldflags; @@ -1754,6 +1755,7 @@ add_extra_lib(char *option) lzo = add_DLZO = add_llzo2 = 0; snappy = add_DSNAPPY = add_lsnappy = 0; + zstd = add_DZSTD = add_lzstd = 0; valgrind = add_DVALGRIND = 0; ldflags = get_extra_flags("LDFLAGS.extra", NULL); @@ -1775,13 +1777,21 @@ add_extra_lib(char *option) add_lsnappy++; } + if (strcmp(option, "zstd") == 0) { + zstd++; + if (!cflags || !strstr(cflags, "-DZSTD")) + add_DZSTD++; + if (!ldflags || !strstr(ldflags, "-lzstd")) + add_lzstd++; + } + if (strcmp(option, "valgrind") == 0) { valgrind++; if (!cflags || !strstr(cflags, "-DVALGRIND")) add_DVALGRIND++; } - if ((lzo || snappy) && + if ((lzo || snappy || zstd) && file_exists("diskdump.o") && (unlink("diskdump.o") < 0)) { perror("diskdump.o"); return; @@ -1806,24 +1816,28 @@ add_extra_lib(char *option) return; } - if (add_DLZO || add_DSNAPPY || add_DVALGRIND) { + if (add_DLZO || add_DSNAPPY || add_DZSTD || add_DVALGRIND) { while (fgets(inbuf, 512, fp_cflags)) ; if (add_DLZO) fputs("-DLZO\n", fp_cflags); if (add_DSNAPPY) fputs("-DSNAPPY\n", fp_cflags); + if (add_DZSTD) + fputs("-DZSTD\n", fp_cflags); if (add_DVALGRIND) fputs("-DVALGRIND\n", fp_cflags); } - if (add_llzo2 || add_lsnappy) { + if (add_llzo2 || add_lsnappy || add_lzstd) { while (fgets(inbuf, 512, fp_ldflags)) ; if (add_llzo2) fputs("-llzo2\n", fp_ldflags); if (add_lsnappy) fputs("-lsnappy\n", fp_ldflags); + if (add_lzstd) + fputs("-lzstd\n", fp_ldflags); } fclose(fp_cflags); diff --git a/defs.h b/defs.h index eb1c71b5333a..b2e94722c92b 100644 --- a/defs.h +++ b/defs.h @@ -54,6 +54,9 @@ #ifdef SNAPPY #include <snappy-c.h> #endif +#ifdef ZSTD +#include <zstd.h> +#endif #ifndef ATTRIBUTE_UNUSED #define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) @@ -327,6 +330,7 @@ struct number_option { #define NO_ELF_NOTES (0x20) #define LZO_SUPPORTED (0x40) #define SNAPPY_SUPPORTED (0x80) +#define ZSTD_SUPPORTED (0x100) #define DISKDUMP_VALID() (dd->flags & DISKDUMP_LOCAL) #define KDUMP_CMPRS_VALID() (dd->flags & KDUMP_CMPRS_LOCAL) #define KDUMP_SPLIT() (dd->flags & DUMPFILE_SPLIT) diff --git a/diskdump.c b/diskdump.c index de3eeb2c720c..f1e890acbf58 100644 --- a/diskdump.c +++ b/diskdump.c @@ -96,6 +96,10 @@ static struct diskdump_data **dd_list = NULL; static int num_dd = 0; static int num_dumpfiles = 0; +#ifdef ZSTD +static ZSTD_DCtx *dctx = NULL; +#endif + int dumpfile_is_split(void) { return KDUMP_SPLIT(); @@ -1002,6 +1006,11 @@ is_diskdump(char *file) dd->flags |= SNAPPY_SUPPORTED; #endif +#ifdef ZSTD + if ((dctx = ZSTD_createDCtx()) != NULL) + dd->flags |= ZSTD_SUPPORTED; +#endif + pc->read_vmcoreinfo = vmcoreinfo_read_string; if ((pc->flags2 & GET_LOG) && KDUMP_CMPRS_VALID()) { @@ -1251,6 +1260,24 @@ cache_page(physaddr_t paddr) ret); return READ_ERROR; } +#endif + } else if (pd.flags & DUMP_DH_COMPRESSED_ZSTD) { + + if (!(dd->flags & ZSTD_SUPPORTED)) { + error(INFO, "%s: uncompress failed: no zstd compression support\n", + DISKDUMP_VALID() ? "diskdump" : "compressed kdump"); + return READ_ERROR; + } +#ifdef ZSTD + retlen = ZSTD_decompressDCtx(dctx, + dd->page_cache_hdr[i].pg_bufptr, block_size, + dd->compressed_page, pd.size); + if (ZSTD_isError(retlen)) { + error(INFO, "%s: uncompress failed: %d (%s)\n", + DISKDUMP_VALID() ? "diskdump" : "compressed kdump", + retlen, ZSTD_getErrorName(retlen)); + return READ_ERROR; + } #endif } else memcpy(dd->page_cache_hdr[i].pg_bufptr, @@ -1806,6 +1833,8 @@ __diskdump_memory_dump(FILE *fp) fprintf(fp, "%sLZO_SUPPORTED", others++ ? "|" : ""); if (dd->flags & SNAPPY_SUPPORTED) fprintf(fp, "%sSNAPPY_SUPPORTED", others++ ? "|" : ""); + if (dd->flags & ZSTD_SUPPORTED) + fprintf(fp, "%sZSTD_SUPPORTED", others++ ? "|" : ""); fprintf(fp, ") %s\n", FLAT_FORMAT() ? "[FLAT]" : ""); fprintf(fp, " dfd: %d\n", dd->dfd); fprintf(fp, " ofp: %lx\n", (ulong)dd->ofp); @@ -1872,6 +1901,8 @@ __diskdump_memory_dump(FILE *fp) fprintf(fp, "DUMP_DH_COMPRESSED_LZO"); if (dh->status & DUMP_DH_COMPRESSED_SNAPPY) fprintf(fp, "DUMP_DH_COMPRESSED_SNAPPY"); + if (dh->status & DUMP_DH_COMPRESSED_ZSTD) + fprintf(fp, "DUMP_DH_COMPRESSED_ZSTD"); if (dh->status & DUMP_DH_COMPRESSED_INCOMPLETE) fprintf(fp, "DUMP_DH_COMPRESSED_INCOMPLETE"); if (dh->status & DUMP_DH_EXCLUDED_VMEMMAP) diff --git a/diskdump.h b/diskdump.h index 28713407b841..c152c7b86616 100644 --- a/diskdump.h +++ b/diskdump.h @@ -86,6 +86,7 @@ struct kdump_sub_header { #define DUMP_DH_COMPRESSED_SNAPPY 0x4 /* page is compressed with snappy */ #define DUMP_DH_COMPRESSED_INCOMPLETE 0x8 /* dumpfile is incomplete */ #define DUMP_DH_EXCLUDED_VMEMMAP 0x10 /* unused vmemmap pages are excluded */ +#define DUMP_DH_COMPRESSED_ZSTD 0x20 /* page is compressed with zstd */ /* descriptor of each page for vmcore */ typedef struct page_desc { diff --git a/help.c b/help.c index 6c262a3ffcbb..f34838d59908 100644 --- a/help.c +++ b/help.c @@ -9420,8 +9420,8 @@ README_ENTER_DIRECTORY, " Traditionally when vmcores are compressed via the makedumpfile(8) facility", " the libz compression library is used, and by default the crash utility", " only supports libz. Recently makedumpfile has been enhanced to optionally", -" use either the LZO or snappy compression libraries. To build crash with", -" either or both of those libraries, type \"make lzo\" or \"make snappy\".", +" use the LZO, snappy or zstd compression libraries. To build crash with any", +" or all of those libraries, type \"make lzo\", \"make snappy\" or \"make zstd\".", "", " crash supports valgrind Memcheck tool on the crash's custom memory allocator.", " To build crash with this feature enabled, type \"make valgrind\" and then run", -- 2.27.0

2 years, 9 months

1
0
0 / 0

[PATCH v2] Improve the performance of symbol searching for kernel modules

by Tao Liu

Currently the sequence for crash searching a symbol is: 1) kernel symname hash table, 2) iterate all kernel symbols, 3) iterate all kernel modules and their symbols. In the worst case, if a non-exist symbol been searched, all 3 stages will be went through. The time consuming status for each stage is like: stage 1 stage 2 stage 3 0.007000(ms) 0.593000(ms) 2.421000(ms) stage 3 takes too much time when comparing to stage 1. So let's introduce a symname hash table for kernel modules to improve the performance of symbol searching. Signed-off-by: Tao Liu <ltao(a)redhat.com> --- v1 -> v2: - Removed unused variables within the modified functions. --- defs.h | 1 + kernel.c | 1 + symbols.c | 189 +++++++++++++++++++++++++++++++----------------------- 3 files changed, 111 insertions(+), 80 deletions(-) diff --git a/defs.h b/defs.h index eb1c71b..58b8546 100644 --- a/defs.h +++ b/defs.h @@ -2751,6 +2751,7 @@ struct symbol_table_data { double val_hash_searches; double val_hash_iterations; struct syment *symname_hash[SYMNAME_HASH]; + struct syment *mod_symname_hash[SYMNAME_HASH]; struct symbol_namespace kernel_namespace; struct syment *ext_module_symtable; struct syment *ext_module_symend; diff --git a/kernel.c b/kernel.c index 36fdea2..c56cc34 100644 --- a/kernel.c +++ b/kernel.c @@ -4663,6 +4663,7 @@ reinit_modules(void) kt->mods_installed = 0; clear_text_value_cache(); + memset(st->mod_symname_hash, 0, sizeof(st->mod_symname_hash)); module_init(); } diff --git a/symbols.c b/symbols.c index bf6d94d..9b64734 100644 --- a/symbols.c +++ b/symbols.c @@ -64,8 +64,9 @@ static int namespace_ctl(int, struct symbol_namespace *, void *, void *); static void symval_hash_init(void); static struct syment *symval_hash_search(ulong); static void symname_hash_init(void); -static void symname_hash_install(struct syment *); -static struct syment *symname_hash_search(char *); +static void symname_hash_install(struct syment *[], struct syment *); +static void symname_hash_remove(struct syment *[], struct syment *); +static struct syment *symname_hash_search(struct syment *[], char *, int (*)(struct syment *, char *)); static void gnu_qsort(bfd *, void *, long, unsigned int, asymbol *, asymbol *); static int check_gnu_debuglink(bfd *); static int separate_debug_file_exists(const char *, unsigned long, int *); @@ -1119,7 +1120,7 @@ symname_hash_init(void) struct syment *sp; for (sp = st->symtable; sp < st->symend; sp++) - symname_hash_install(sp); + symname_hash_install(st->symname_hash, sp); if ((sp = symbol_search("__per_cpu_start"))) st->__per_cpu_start = sp->value; @@ -1127,21 +1128,48 @@ symname_hash_init(void) st->__per_cpu_end = sp->value; } +static void +mod_symtable_hash_install_range(struct syment *from, struct syment *to) +{ + struct syment *sp; + + for (sp = from; sp <= to; sp++) { + if (sp != NULL) { + symname_hash_install(st->mod_symname_hash, sp); + } + } +} + +static void +mod_symtable_hash_remove_range(struct syment *from, struct syment *to) +{ + struct syment *sp; + + for (sp = from; sp <= to; sp++) { + if (sp != NULL) { + symname_hash_remove(st->mod_symname_hash, sp); + } + } +} + /* * Install a single static kernel symbol into the symname_hash. */ static void -symname_hash_install(struct syment *spn) +symname_hash_install(struct syment *table[], struct syment *spn) { struct syment *sp; int index; index = SYMNAME_HASH_INDEX(spn->name); + index = index > 0 ? index : -index; + spn->cnt = 1; - if ((sp = st->symname_hash[index]) == NULL) - st->symname_hash[index] = spn; - else { + if ((sp = table[index]) == NULL) { + table[index] = spn; + spn->name_hash_next = NULL; + } else { while (sp) { if (STREQ(sp->name, spn->name)) { sp->cnt++; @@ -1151,23 +1179,67 @@ symname_hash_install(struct syment *spn) sp = sp->name_hash_next; else { sp->name_hash_next = spn; + spn->name_hash_next = NULL; break; } } } } +static void +symname_hash_remove(struct syment *table[], struct syment *spn) +{ + struct syment *sp, **tmp; + int index, first_encounter = 1; + + index = SYMNAME_HASH_INDEX(spn->name); + index = index > 0 ? index : -index; + + if ((sp = table[index]) == NULL) + return; + + for (tmp = &table[index], sp = table[index]; sp; ) { + if (STREQ(sp->name, spn->name)) { + if (sp != spn) { + sp->cnt--; + spn->cnt--; + } else if (!first_encounter) { + sp->cnt--; + } else { + *tmp = sp->name_hash_next; + first_encounter = 0; + + tmp = &(*tmp)->name_hash_next; + sp = sp->name_hash_next; + spn->name_hash_next = NULL; + continue; + } + } + tmp = &sp->name_hash_next; + sp = sp->name_hash_next; + } +} + /* * Static kernel symbol value search */ static struct syment * -symname_hash_search(char *name) +symname_hash_search(struct syment *table[], char *name, + int (*skip_condition)(struct syment *, char *)) { struct syment *sp; + int index; - sp = st->symname_hash[SYMNAME_HASH_INDEX(name)]; + index = SYMNAME_HASH_INDEX(name); + index = index > 0 ? index : -index; + sp = table[index]; while (sp) { + if (skip_condition && skip_condition(sp, name)) { + sp = sp->name_hash_next; + continue; + } + if (STREQ(sp->name, name)) return sp; sp = sp->name_hash_next; @@ -1595,6 +1667,7 @@ store_module_symbols_v1(ulong total, int mods_installed) lm->mod_symend = sp; } } + mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); } st->flags |= MODULE_SYMS; @@ -2075,6 +2148,8 @@ store_module_symbols_v2(ulong total, int mods_installed) lm->mod_init_symend = sp; } } + mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); + mod_symtable_hash_install_range(lm->mod_init_symtable, lm->mod_init_symend); } st->flags |= MODULE_SYMS; @@ -4482,6 +4557,16 @@ symbol_query(char *s, char *print_pad, struct syment **spp) return(cnt); } +static int +skip_symbols(struct syment *sp, char *s) +{ + int pseudos, skip = 0; + pseudos = (strstr(s, "_MODULE_START_") || strstr(s, "_MODULE_END_") || + strstr(s, "_MODULE_INIT_START_") || strstr(s, "_MODULE_INIT_END_")); + if (!pseudos && MODULE_PSEUDO_SYMBOL(sp)) + skip = 1; + return skip; +} /* * Return the syment of a symbol. @@ -4489,58 +4574,16 @@ symbol_query(char *s, char *print_pad, struct syment **spp) struct syment * symbol_search(char *s) { - int i; - struct syment *sp_hashed, *sp, *sp_end; - struct load_module *lm; - int pseudos, search_init; + struct syment *sp_hashed, *sp; - sp_hashed = symname_hash_search(s); + sp_hashed = symname_hash_search(st->symname_hash, s, NULL); for (sp = sp_hashed ? sp_hashed : st->symtable; sp < st->symend; sp++) { if (STREQ(s, sp->name)) return(sp); } - pseudos = (strstr(s, "_MODULE_START_") || strstr(s, "_MODULE_END_")); - search_init = FALSE; - - for (i = 0; i < st->mods_installed; i++) { - lm = &st->load_modules[i]; - if (lm->mod_flags & MOD_INIT) - search_init = TRUE; - sp = lm->mod_symtable; - sp_end = lm->mod_symend; - - for ( ; sp <= sp_end; sp++) { - if (!pseudos && MODULE_PSEUDO_SYMBOL(sp)) - continue; - if (STREQ(s, sp->name)) - return(sp); - } - } - - if (!search_init) - return((struct syment *)NULL); - - pseudos = (strstr(s, "_MODULE_INIT_START_") || strstr(s, "_MODULE_INIT_END_")); - - for (i = 0; i < st->mods_installed; i++) { - lm = &st->load_modules[i]; - if (!lm->mod_init_symtable) - continue; - sp = lm->mod_init_symtable; - sp_end = lm->mod_init_symend; - - for ( ; sp < sp_end; sp++) { - if (!pseudos && MODULE_PSEUDO_SYMBOL(sp)) - continue; - - if (STREQ(s, sp->name)) - return(sp); - } - } - - return((struct syment *)NULL); + return symname_hash_search(st->mod_symname_hash, s, skip_symbols); } /* @@ -5432,33 +5475,13 @@ value_symbol(ulong value) int symbol_exists(char *symbol) { - int i; - struct syment *sp, *sp_end; - struct load_module *lm; + struct syment *sp; - if ((sp = symname_hash_search(symbol))) + if ((sp = symname_hash_search(st->symname_hash, symbol, NULL))) return TRUE; - for (i = 0; i < st->mods_installed; i++) { - lm = &st->load_modules[i]; - sp = lm->mod_symtable; - sp_end = lm->mod_symend; - - for ( ; sp < sp_end; sp++) { - if (STREQ(symbol, sp->name)) - return(TRUE); - } - - if (lm->mod_init_symtable) { - sp = lm->mod_init_symtable; - sp_end = lm->mod_init_symend; - - for ( ; sp < sp_end; sp++) { - if (STREQ(symbol, sp->name)) - return(TRUE); - } - } - } + if ((sp = symname_hash_search(st->mod_symname_hash, symbol, NULL))) + return TRUE; return(FALSE); } @@ -5515,7 +5538,7 @@ kernel_symbol_exists(char *symbol) { struct syment *sp; - if ((sp = symname_hash_search(symbol))) + if ((sp = symname_hash_search(st->symname_hash, symbol, NULL))) return TRUE; else return FALSE; @@ -5527,7 +5550,7 @@ kernel_symbol_exists(char *symbol) struct syment * kernel_symbol_search(char *symbol) { - return symname_hash_search(symbol); + return symname_hash_search(st->symname_hash, symbol, NULL); } /* @@ -12464,8 +12487,10 @@ store_load_module_symbols(bfd *bfd, int dynamic, void *minisyms, error(INFO, "%s: last symbol: %s is not _MODULE_END_%s?\n", lm->mod_name, lm->mod_load_symend->name, lm->mod_name); + mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); lm->mod_symtable = lm->mod_load_symtable; lm->mod_symend = lm->mod_load_symend; + mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); lm->mod_flags &= ~MOD_EXT_SYMS; lm->mod_flags |= MOD_LOAD_SYMS; @@ -12495,6 +12520,7 @@ delete_load_module(ulong base_addr) req->name = lm->mod_namelist; gdb_interface(req); } + mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); if (lm->mod_load_symtable) { free(lm->mod_load_symtable); namespace_ctl(NAMESPACE_FREE, @@ -12504,6 +12530,7 @@ delete_load_module(ulong base_addr) unlink_module(lm); lm->mod_symtable = lm->mod_ext_symtable; lm->mod_symend = lm->mod_ext_symend; + mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); lm->mod_flags &= ~(MOD_LOAD_SYMS|MOD_REMOTE|MOD_NOPATCH); lm->mod_flags |= MOD_EXT_SYMS; lm->mod_load_symtable = NULL; @@ -12532,6 +12559,7 @@ delete_load_module(ulong base_addr) req->name = lm->mod_namelist; gdb_interface(req); } + mod_symtable_hash_remove_range(lm->mod_symtable, lm->mod_symend); if (lm->mod_load_symtable) { free(lm->mod_load_symtable); namespace_ctl(NAMESPACE_FREE, @@ -12541,6 +12569,7 @@ delete_load_module(ulong base_addr) unlink_module(lm); lm->mod_symtable = lm->mod_ext_symtable; lm->mod_symend = lm->mod_ext_symend; + mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend); lm->mod_flags &= ~(MOD_LOAD_SYMS|MOD_REMOTE|MOD_NOPATCH); lm->mod_flags |= MOD_EXT_SYMS; lm->mod_load_symtable = NULL; -- 2.29.2

2 years, 9 months

3
16
0 / 0

[PATCH] mod: fix module object file lookup

by Hari Bathini

On systems where vmlinux file is not under /usr/lib/debug/lib/modules directory, 'mod -s|-S' command may fail to find the module's object file with the below error: mod: cannot find or load object file for sd_mod module Fix it by trying all possible module object file extentions while searching for the object file under /usr/lib/debug/lib/modules directory. Signed-off-by: Naveen N. Rao <naveen.n.rao(a)linux.ibm.com> Signed-off-by: Hari Bathini <hbathini(a)linux.ibm.com> --- kernel.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/kernel.c b/kernel.c index 36fdea2..b2c8a0c 100644 --- a/kernel.c +++ b/kernel.c @@ -4796,7 +4796,18 @@ module_objfile_search(char *modref, char *filename, char *tree) sprintf(dir, "%s/%s", DEFAULT_REDHAT_DEBUG_LOCATION, kt->utsname.release); - retbuf = search_directory_tree(dir, file, 0); + if (!(retbuf = search_directory_tree(dir, file, 0))) { + switch (kt->flags & (KMOD_V1|KMOD_V2)) + { + case KMOD_V2: + sprintf(file, "%s.ko", modref); + retbuf = search_directory_tree(dir, file, 0); + if (!retbuf) { + sprintf(file, "%s.ko.debug", modref); + retbuf = search_directory_tree(dir, file, 0); + } + } + } if (!retbuf && (env = getenv("CRASH_MODULE_PATH"))) { sprintf(dir, "%s", env);

2 years, 9 months

3
2
0 / 0

Re: [Crash-utility] [PATCH 3/3] ppc64: Add MMU type info in machdep command

by lijiang

For these two patches in this series: [PATCH 1/3] .gitignore: Add cscope, ctags & compile_commands.json in .gitignore [PATCH 3/3] ppc64: Add MMU type info in machdep command Acked-by: Lianbo Jiang <lijiang(a)redhat.com>

2 years, 9 months

2
1
0 / 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

Crash-utility September 2021