Date: Thu, 4 Mar 2021 20:20:28 +0900 From: HATAYAMA Daisuke <d.hatayama(a)fujitsu.com&gt; To: crash-utility(a)redhat.com Cc: HATAYAMA Daisuke <d.hatayama(a)fujitsu.com&gt; Subject: [Crash-utility] [PATCH v2 1/3] Add valgrind support for the crash's custom memory allocator Message-ID: <1614856830-14414-2-git-send-email-d.hatayama(a)fujitsu.com&gt; Content-Type: text/plain; charset="US-ASCII" This adds valgrind support for the crash's custom memory allocator using the way described in the following valgrind's Memcheck manual: https://www.valgrind.org/docs/manual/mc-manual.html#mc-manual.mempools This helps detecting various memory errors on the crash's custom memory allocator. To enable this feature, build crash command as: # make valgrind Then, run crash commnad using valgrind as: # valgrind ./crash vmlinux vmcore Signed-off-by: HATAYAMA Daisuke <d.hatayama(a)fujitsu.com&gt; --- Makefile | 4 ++++ README | 5 +++++ configure.c | 21 ++++++++++++++++++- help.c | 5 +++++ tools.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 103 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index f66eba7..e0c922f 100644 --- a/Makefile +++ b/Makefile @@ -332,6 +332,10 @@ snappy: make_configure @./configure -x snappy ${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 + main.o: ${GENERIC_HFILES} main.c ${CC} -c ${CRASH_CFLAGS} main.c ${WARNING_OPTIONS} ${WARNING_ERROR} diff --git a/README b/README index e2af924..9b9c6e6 100644 --- a/README +++ b/README @@ -105,6 +105,11 @@ use either the LZO or snappy compression libraries. To build crash with either or both of those libraries, type "make lzo" or "make snappy". + crash supports valgrind Memcheck tool on the crash's custom memory + allocator. To build crash with this feature enabled, type "make + valrind" and then run crash with valgrind as "valgrind crash

+ vmlinux vmcore". + All of the alternate build commands above are "sticky" in that the special "make" targets only have to be entered one time; all subsequent builds will follow suit. diff --git a/configure.c b/configure.c index 7f6d19e..52d3c24 100644 --- a/configure.c +++ b/configure.c @@ -1710,12 +1710,16 @@ get_extra_flags(char *filename, char *initial) * For snappy: * - enter -DLZO in the CFLAGS.extra file * - enter -llzo2 in the LDFLAGS.extra file. + * + * For valgrind: + * - enter -DVALGRIND in the CFLAGS.extra file */ void add_extra_lib(char *option) { int lzo, add_DLZO, add_llzo2; int snappy, add_DSNAPPY, add_lsnappy; + int valgrind, add_DVALGRIND; char *cflags, *ldflags; FILE *fp_cflags, *fp_ldflags; char *mode; @@ -1723,6 +1727,7 @@ add_extra_lib(char *option) lzo = add_DLZO = add_llzo2 = 0; snappy = add_DSNAPPY = add_lsnappy = 0; + valgrind = add_DVALGRIND = 0; ldflags = get_extra_flags("LDFLAGS.extra", NULL); cflags = get_extra_flags("CFLAGS.extra", NULL); @@ -1743,12 +1748,24 @@ add_extra_lib(char *option) add_lsnappy++; } + if (strcmp(option, "valgrind") == 0) { + valgrind++; + if (!cflags || !strstr(cflags, "-DVALGRIND")) + add_DVALGRIND++; + } + if ((lzo || snappy) && file_exists("diskdump.o") && (unlink("diskdump.o") < 0)) { perror("diskdump.o"); return; } + if (valgrind && + file_exists("tools.o") && (unlink("tools.o") < 0)) { + perror("tools.o"); + return; + } + mode = file_exists("CFLAGS.extra") ? "r+" : "w+"; if ((fp_cflags = fopen("CFLAGS.extra", mode)) == NULL) { perror("CFLAGS.extra"); @@ -1762,13 +1779,15 @@ add_extra_lib(char *option) return; } - if (add_DLZO || add_DSNAPPY) { + if (add_DLZO || add_DSNAPPY || 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_DVALGRIND) + fputs("-DVALGRIND\n", fp_cflags); } if (add_llzo2 || add_lsnappy) { diff --git a/help.c b/help.c index d3427a3..f2b1007 100644 --- a/help.c +++ b/help.c @@ -9428,6 +9428,11 @@ README_ENTER_DIRECTORY, " use either the LZO or snappy compression libraries. To build crash with", " either or both of those libraries, type \"make lzo\" or \"make snappy\".", "", +" crash supports valgrind Memcheck tool on the crash's custom memory", +" allocator. To build crash with this feature enabled, type \"make", +" valrind\" and then run crash with valgrind as \"valgrind crash",

+" vmlinux vmcore\".", +"", " All of the alternate build commands above are \"sticky\" in that the", " special \"make\" targets only have to be entered one time; all subsequent", " builds will follow suit.", diff --git a/tools.c b/tools.c index 89352b1..91d5baf 100644 --- a/tools.c +++ b/tools.c @@ -18,6 +18,11 @@ #include "defs.h" #include <ctype.h> +#ifdef VALGRIND +#include <valgrind/valgrind.h> +#include <valgrind/memcheck.h> +#endif + static void print_number(struct number_option *, int, int); static long alloc_hq_entry(void); struct hq_entry; @@ -5679,8 +5684,21 @@ buf_init(void) bp->smallest = 0x7fffffff; bp->total = 0.0; -} +#ifdef VALGRIND + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_1K, sizeof(bp->buf_1K)); + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_2K, sizeof(bp->buf_2K)); + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_4K, sizeof(bp->buf_4K)); + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_8K, sizeof(bp->buf_8K)); + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_32K, sizeof(bp->buf_32K)); + + VALGRIND_CREATE_MEMPOOL(&bp->buf_1K, 0, 1); + VALGRIND_CREATE_MEMPOOL(&bp->buf_2K, 0, 1); + VALGRIND_CREATE_MEMPOOL(&bp->buf_4K, 0, 1); + VALGRIND_CREATE_MEMPOOL(&bp->buf_8K, 0, 1); + VALGRIND_CREATE_MEMPOOL(&bp->buf_32K, 0, 1); +#endif +} /* * Free up all buffers used by the last command. @@ -5707,6 +5725,26 @@ void free_all_bufs(void) if (bp->mallocs != bp->frees) error(WARNING, "malloc/free mismatch (%ld/%ld)\n", bp->mallocs, bp->frees); + +#ifdef VALGRIND + VALGRIND_DESTROY_MEMPOOL(&bp->buf_1K); + VALGRIND_DESTROY_MEMPOOL(&bp->buf_2K); + VALGRIND_DESTROY_MEMPOOL(&bp->buf_4K); + VALGRIND_DESTROY_MEMPOOL(&bp->buf_8K); + VALGRIND_DESTROY_MEMPOOL(&bp->buf_32K); + + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_1K, sizeof(bp->buf_1K)); + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_2K, sizeof(bp->buf_2K)); + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_4K, sizeof(bp->buf_4K)); + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_8K, sizeof(bp->buf_8K)); + VALGRIND_MAKE_MEM_NOACCESS(&bp->buf_32K, sizeof(bp->buf_32K)); + + VALGRIND_CREATE_MEMPOOL(&bp->buf_1K, 0, 1); + VALGRIND_CREATE_MEMPOOL(&bp->buf_2K, 0, 1); + VALGRIND_CREATE_MEMPOOL(&bp->buf_4K, 0, 1); + VALGRIND_CREATE_MEMPOOL(&bp->buf_8K, 0, 1); + VALGRIND_CREATE_MEMPOOL(&bp->buf_32K, 0, 1); +#endif } /* @@ -5731,6 +5769,9 @@ freebuf(char *addr) for (i = 0; i < NUMBER_1K_BUFS; i++) { if (addr == (char *)&bp->buf_1K[i]) { bp->buf_inuse[B1K] &= ~(1 << i); +#ifdef VALGRIND + VALGRIND_MEMPOOL_FREE(&bp->buf_1K, addr); +#endif return; } } @@ -5738,6 +5779,9 @@ freebuf(char *addr) for (i = 0; i < NUMBER_2K_BUFS; i++) { if (addr == (char *)&bp->buf_2K[i]) { bp->buf_inuse[B2K] &= ~(1 << i); +#ifdef VALGRIND + VALGRIND_MEMPOOL_FREE(&bp->buf_2K, addr); +#endif return; } } @@ -5745,6 +5789,9 @@ freebuf(char *addr) for (i = 0; i < NUMBER_4K_BUFS; i++) { if (addr == (char *)&bp->buf_4K[i]) { bp->buf_inuse[B4K] &= ~(1 << i); +#ifdef VALGRIND + VALGRIND_MEMPOOL_FREE(&bp->buf_4K, addr); +#endif return; } } @@ -5752,6 +5799,9 @@ freebuf(char *addr) for (i = 0; i < NUMBER_8K_BUFS; i++) { if (addr == (char *)&bp->buf_8K[i]) { bp->buf_inuse[B8K] &= ~(1 << i); +#ifdef VALGRIND + VALGRIND_MEMPOOL_FREE(&bp->buf_8K, addr); +#endif return; } } @@ -5759,6 +5809,9 @@ freebuf(char *addr) for (i = 0; i < NUMBER_32K_BUFS; i++) { if (addr == (char *)&bp->buf_32K[i]) { bp->buf_inuse[B32K] &= ~(1 << i); +#ifdef VALGRIND + VALGRIND_MEMPOOL_FREE(&bp->buf_32K, addr); +#endif return; } } @@ -5924,6 +5977,9 @@ getbuf(long reqsize) bp->buf_inuse[B1K] |= (1 << bdx); bp->buf_1K_maxuse = MAX(bp->buf_1K_maxuse, count_bits_int(bp->buf_inuse[B1K])); +#ifdef VALGRIND + VALGRIND_MEMPOOL_ALLOC(&bp->buf_1K, bufp, 1024); +#endif BZERO(bufp, 1024); return(bufp); } @@ -5938,6 +5994,9 @@ getbuf(long reqsize) bp->buf_inuse[B2K] |= (1 << bdx); bp->buf_2K_maxuse = MAX(bp->buf_2K_maxuse, count_bits_int(bp->buf_inuse[B2K])); +#ifdef VALGRIND + VALGRIND_MEMPOOL_ALLOC(&bp->buf_2K, bufp, 2048); +#endif BZERO(bufp, 2048); return(bufp); } @@ -5952,6 +6011,9 @@ getbuf(long reqsize) bp->buf_inuse[B4K] |= (1 << bdx); bp->buf_4K_maxuse = MAX(bp->buf_4K_maxuse, count_bits_int(bp->buf_inuse[B4K])); +#ifdef VALGRIND + VALGRIND_MEMPOOL_ALLOC(&bp->buf_4K, bufp, 4096); +#endif BZERO(bufp, 4096); return(bufp); } @@ -5966,6 +6028,9 @@ getbuf(long reqsize) bp->buf_inuse[B8K] |= (1 << bdx); bp->buf_8K_maxuse = MAX(bp->buf_8K_maxuse, count_bits_int(bp->buf_inuse[B8K])); +#ifdef VALGRIND + VALGRIND_MEMPOOL_ALLOC(&bp->buf_8K, bufp, 8192); +#endif BZERO(bufp, 8192); return(bufp); } @@ -5980,6 +6045,9 @@ getbuf(long reqsize) bp->buf_inuse[B32K] |= (1 << bdx); bp->buf_32K_maxuse = MAX(bp->buf_32K_maxuse, count_bits_int(bp->buf_inuse[B32K])); +#ifdef VALGRIND + VALGRIND_MEMPOOL_ALLOC(&bp->buf_32K, bufp, 32768); +#endif BZERO(bufp, 32768); return(bufp); } -- 1.8.3.1