This patch will introduce multithread for search_virtual. The main process, aka readmem, will fill a zone of page buffers, then notify search_value threads to start. A pthread barrier is used for such main process and threads synchronization. For the search_value threads, they are always working on a same zone, the search results are cached within a output_buffer of each thread. If one thread finishes earlier, it have to wait untill other threads finish. The last finished thread is responsible for output search results in order. After all work done, search_value threads will work on the next zone. Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- defs.h | 6 + memory.c | 447 ++++++++++++++++++++++++++++++++++++++++++++----------- task.c | 14 ++ 3 files changed, 382 insertions(+), 85 deletions(-) diff --git a/defs.h b/defs.h index 12ad6aa..c58272c 100644 --- a/defs.h +++ b/defs.h @@ -5705,6 +5705,11 @@ int dump_inode_page(ulong); ulong valid_section_nr(ulong); void display_memory_from_file_offset(ulonglong, long, void *); void swap_info_init(void); +typedef struct cache_output { + char **output_buf; + int *output_buf_size; + int *output_buf_offset; +} cache_output_t; /* * filesys.c @@ -5950,6 +5955,7 @@ void sort_tgid_array(void); int sort_by_tgid(const void *, const void *); int in_irq_ctx(ulonglong, int, ulong); void check_stack_overflow(void); +void print_task_header_para(struct task_context *, int, cache_output_t *); /* * extensions.c diff --git a/memory.c b/memory.c index 592a5ef..c396b07 100644 --- a/memory.c +++ b/memory.c @@ -22,6 +22,8 @@ #include <netinet/in.h> #include <byteswap.h> #include "maple_tree.h" +#include <pthread.h> +#include <semaphore.h> struct meminfo { /* general purpose memory information structure */ ulong cache; /* used by the various memory searching/dumping */ @@ -136,6 +138,9 @@ struct searchinfo { } s_chars; } s_parms; char buf[BUFSIZE]; + ulong thread_num; + ulong page_buf_zone_num; + ulong factor; }; struct handle_each_vm_area_args { @@ -241,9 +246,9 @@ static int page_to_phys(ulong, physaddr_t *); static void display_memory(ulonglong, long, ulong, int, void *); static char *show_opt_string(struct searchinfo *); static void display_with_pre_and_post(void *, ulonglong, struct searchinfo *); -static ulong search_ulong(ulong *, ulong, int, struct searchinfo *); -static ulong search_uint(ulong *, ulong, int, struct searchinfo *); -static ulong search_ushort(ulong *, ulong, int, struct searchinfo *); +static ulong search_ulong(ulong *, ulong, int, struct searchinfo *, struct searchinfo *, void *); +static ulong search_uint(ulong *, ulong, int, struct searchinfo *, struct searchinfo *, void *); +static ulong search_ushort(ulong *, ulong, int, struct searchinfo *, struct searchinfo *, void *); static ulong search_chars(ulong *, ulong, int, struct searchinfo *); static ulonglong search_ulong_p(ulong *, ulonglong, int, struct searchinfo *); static ulonglong search_uint_p(ulong *, ulonglong, int, struct searchinfo *); @@ -14928,25 +14933,57 @@ display_with_pre_and_post(void *bufptr, ulonglong addr, struct searchinfo *si) } static ulong -search_ulong(ulong *bufptr, ulong addr, int longcnt, struct searchinfo *si) +search_ulong(ulong *bufptr, ulong addr, int longcnt, + struct searchinfo *si, struct searchinfo *si_orig, void *priv) { int i; + cache_output_t *co = (cache_output_t *)priv; + char *buf; + ulong mask = si->s_parms.s_ulong.mask; for (i = 0; i < longcnt; i++, bufptr++, addr += sizeof(long)) { for (si->val = 0; si->val < si->vcnt; si->val++) { if (SEARCHMASK(*bufptr) == SEARCHMASK(si->s_parms.s_ulong.value[si->val])) { if (si->do_task_header) { - print_task_header(fp, si->task_context, - si->tasks_found); - si->do_task_header = FALSE; - si->tasks_found++; + if (co) + print_task_header_para(si->task_context, + si->tasks_found, co); + else + print_task_header(fp, si->task_context, + si->tasks_found); + si_orig->do_task_header = si->do_task_header = FALSE; + si_orig->tasks_found = ++si->tasks_found; } if (si->context) display_with_pre_and_post(bufptr, addr, si); - else - fprintf(fp, "%lx: %lx %s\n", addr, *bufptr, - show_opt_string(si)); + else { + if (co) { + *co->output_buf_offset += snprintf( + *co->output_buf + + *co->output_buf_offset, + *co->output_buf_size - + *co->output_buf_offset, + "%lx: %lx %s\n", + addr, *bufptr, + show_opt_string(si)); + if (*co->output_buf_offset >= + *co->output_buf_size >> 1) { + *co->output_buf_size <<= 1; + buf = *co->output_buf; + if (!(*co->output_buf = + malloc(*co->output_buf_size))) { + error(FATAL, "cannot malloc" + " more output buffer"); + } + memcpy(*co->output_buf, buf, + *co->output_buf_offset); + free(buf); + } + } else + fprintf(fp, "%lx: %lx %s\n", addr, *bufptr, + show_opt_string(si)); + } } } } @@ -14975,28 +15012,59 @@ search_ulong_p(ulong *bufptr, ulonglong addr, int longcnt, struct searchinfo *si } static ulong -search_uint(ulong *bufptr, ulong addr, int longcnt, struct searchinfo *si) +search_uint(ulong *bufptr, ulong addr, int longcnt, + struct searchinfo *si, struct searchinfo *si_orig, void *priv) { int i; int cnt = longcnt * (sizeof(long)/sizeof(int)); uint *ptr = (uint *)bufptr; uint mask = si->s_parms.s_uint.mask; + cache_output_t *co = (cache_output_t *)priv; + char *buf; for (i = 0; i < cnt; i++, ptr++, addr += sizeof(int)) { for (si->val = 0; si->val < si->vcnt; si->val++) { if (SEARCHMASK(*ptr) == SEARCHMASK(si->s_parms.s_uint.value[si->val])) { if (si->do_task_header) { - print_task_header(fp, si->task_context, - si->tasks_found); - si->do_task_header = FALSE; - si->tasks_found++; + if (co) + print_task_header_para(si->task_context, + si->tasks_found, co); + else + print_task_header(fp, si->task_context, + si->tasks_found); + si_orig->do_task_header = si->do_task_header = FALSE; + si_orig->tasks_found = ++si->tasks_found; } if (si->context) display_with_pre_and_post(ptr, addr, si); - else - fprintf(fp, "%lx: %x %s\n", addr, *ptr, - show_opt_string(si)); + else { + if (co) { + *co->output_buf_offset += snprintf( + *co->output_buf + + *co->output_buf_offset, + *co->output_buf_size - + *co->output_buf_offset, + "%lx: %lx %s\n", + addr, *bufptr, + show_opt_string(si)); + if (*co->output_buf_offset >= + *co->output_buf_size >> 1) { + *co->output_buf_size <<= 1; + buf = *co->output_buf; + if (!(*co->output_buf = + malloc(*co->output_buf_size))) { + error(FATAL, "cannot malloc" + " more output buffer"); + } + memcpy(*co->output_buf, buf, + *co->output_buf_offset); + free(buf); + } + } else + fprintf(fp, "%lx: %x %s\n", addr, *ptr, + show_opt_string(si)); + } } } } @@ -15028,28 +15096,62 @@ search_uint_p(ulong *bufptr, ulonglong addr, int longcnt, struct searchinfo *si) } static ulong -search_ushort(ulong *bufptr, ulong addr, int longcnt, struct searchinfo *si) +search_ushort(ulong *bufptr, ulong addr, int longcnt, + struct searchinfo *si, struct searchinfo *si_orig, void *priv) { int i; int cnt = longcnt * (sizeof(long)/sizeof(short)); ushort *ptr = (ushort *)bufptr; ushort mask = si->s_parms.s_ushort.mask; + cache_output_t *co = (cache_output_t *)priv; + char *buf; for (i = 0; i < cnt; i++, ptr++, addr += sizeof(short)) { for (si->val = 0; si->val < si->vcnt; si->val++) { if (SEARCHMASK(*ptr) == SEARCHMASK(si->s_parms.s_ushort.value[si->val])) { if (si->do_task_header) { - print_task_header(fp, si->task_context, - si->tasks_found); - si->do_task_header = FALSE; - si->tasks_found++; + if (co) + print_task_header_para( + si->task_context, + si->tasks_found, co); + else + print_task_header(fp, + si->task_context, + si->tasks_found); + si_orig->do_task_header = + si->do_task_header = FALSE; + si_orig->tasks_found = ++si->tasks_found; } if (si->context) display_with_pre_and_post(ptr, addr, si); - else - fprintf(fp, "%lx: %x %s\n", addr, *ptr, - show_opt_string(si)); + else { + if (co) { + *co->output_buf_offset += snprintf( + *co->output_buf + + *co->output_buf_offset, + *co->output_buf_size - + *co->output_buf_offset, + "%lx: %lx %s\n", + addr, *bufptr, + show_opt_string(si)); + if (*co->output_buf_offset >= + *co->output_buf_size >> 1) { + *co->output_buf_size <<= 1; + buf = *co->output_buf; + if (!(*co->output_buf = + malloc(*co->output_buf_size))) { + error(FATAL, "cannot malloc" + " more output buffer"); + } + memcpy(*co->output_buf, buf, + *co->output_buf_offset); + free(buf); + } + } else + fprintf(fp, "%lx: %x %s\n", addr, *ptr, + show_opt_string(si)); + } } } } @@ -15101,6 +15203,34 @@ ulonglong cross_match_next_addr_p; /* the expected starting value of the next ph #define CHARS_CTX 56 +typedef struct page_buf { + char *pagebuf; + ulonglong ppp; + ulonglong pnext; + int lastpage; +} page_buf_t; +page_buf_t *page_buf; + +typedef struct thread_data { + int *start; + int *end; + int *exit; + struct searchinfo *si; + char *output_buf; + int output_buf_size; + int output_buf_offset; + struct thread_data *td; + + // For thread sync + int *page_buf_zone_index; + sem_t *empty_page_buf_zone_count; + pthread_barrier_t *barrier; + int *finished_thread_count; + pthread_mutex_t *finished_thread_count_mutex; + + int thread_index; +} thread_data_t; + static void report_match(struct searchinfo *si, ulong addr, char *ptr1, int len1, char *ptr2, int len2) { @@ -15285,50 +15415,184 @@ search_chars_p(ulong *bufptr, ulonglong addr_p, int longcnt, struct searchinfo * return addr_p; } +static void * +do_search_virtual(void *args) +{ + ulong *ubp; + ulong pp, next; + ulong end; + int wordcnt, lastpage; + struct searchinfo si; + int i, page_buf_zone_index, page_buf_num_per_zone; + cache_output_t cache_output; + + thread_data_t *td = (thread_data_t *)args; + end = td->si->vaddr_end; + memcpy(&si, td->si, sizeof(struct searchinfo)); + cache_output.output_buf = &td->output_buf; + cache_output.output_buf_size = &td->output_buf_size; + cache_output.output_buf_offset = &td->output_buf_offset; + page_buf_num_per_zone = si.thread_num * si.factor; + + while (1) { + pthread_barrier_wait(td->barrier); + page_buf_zone_index = *td->page_buf_zone_index; + for (i = td->start[page_buf_zone_index]; + i < td->end[page_buf_zone_index]; + i++) { + pp = (page_buf + page_buf_num_per_zone * + page_buf_zone_index)[i].ppp; + next = (page_buf + page_buf_num_per_zone * + page_buf_zone_index)[i].pnext; + lastpage = (page_buf + page_buf_num_per_zone * + page_buf_zone_index)[i].lastpage; + + ubp = (ulong *)&(page_buf + page_buf_num_per_zone * + page_buf_zone_index)[i] + .pagebuf[next - pp]; + if (lastpage) { + if (end == (ulong)(-1)) + wordcnt = PAGESIZE()/sizeof(long); + else + wordcnt = (end - next)/sizeof(long); + } else + wordcnt = (PAGESIZE() - (next - pp))/sizeof(long); + + switch (td->si->mode) + { + case SEARCH_ULONG: + next = search_ulong(ubp, next, wordcnt, + &si, td->si, &cache_output); + break; + case SEARCH_UINT: + next = search_uint(ubp, next, wordcnt, + &si, td->si, &cache_output); + break; + case SEARCH_USHORT: + next = search_ushort(ubp, next, wordcnt, + &si, td->si, &cache_output); + break; + case SEARCH_CHARS: + next = search_chars(ubp, next, wordcnt, si); + break; + default: + /* unimplemented search type */ + next += wordcnt * (sizeof(long)); + break; + } + } + pthread_mutex_lock(td->finished_thread_count_mutex); + if (++(*td->finished_thread_count) == si.thread_num) { + pthread_mutex_unlock(td->finished_thread_count_mutex); + for (i = 0; i < si.thread_num; i++) { + fprintf(fp, "%s", (td->td + i)->output_buf); + *((td->td + i)->output_buf) = '\0'; + (td->td + i)->output_buf_offset = 0; + } + *td->page_buf_zone_index = (page_buf_zone_index + 1) % + si.page_buf_zone_num; + (*td->finished_thread_count) = 0; + + sem_post(td->empty_page_buf_zone_count); + } else { + pthread_mutex_unlock(td->finished_thread_count_mutex); + } + if (td->exit[page_buf_zone_index]) { + break; + } + } + return NULL; +} + static void search_virtual(struct searchinfo *si) { ulong start, end; - ulong pp, next, *ubp; - int wordcnt, lastpage; + ulong next, pp; ulong page; - physaddr_t paddr; - char *pagebuf; + physaddr_t paddr; + int i, st, ed; ulong pct, pages_read, pages_checked; time_t begin, finish; - - start = si->vaddr_start; - end = si->vaddr_end; + int page_buf_zone_index = 0; + int page_buf_index; + int thread_num = si->thread_num; + int page_buf_num_per_zone = thread_num * si->factor; pages_read = pages_checked = 0; begin = finish = 0; - pagebuf = GETBUF(PAGESIZE()); + // For thread sync + sem_t empty_page_buf_zone_count; + pthread_barrier_t barrier; + pthread_t *threads; + thread_data_t *td; + int finished_thread_count = 0; + pthread_mutex_t finished_thread_count_mutex = PTHREAD_MUTEX_INITIALIZER; + int thread_page_buf_zone_index = 0; + sem_init(&empty_page_buf_zone_count, 0, si->page_buf_zone_num); + pthread_barrier_init(&barrier, NULL, thread_num + 1); + + // Alloc buffers + page_buf = (page_buf_t *)GETBUF(sizeof(page_buf_t) * + si->page_buf_zone_num * page_buf_num_per_zone); + threads = (pthread_t *)GETBUF(sizeof(pthread_t) * thread_num); + td = (thread_data_t *)GETBUF(sizeof(thread_data_t) * thread_num); + memset(threads, 0, sizeof(sizeof(pthread_t) * thread_num)); + memset(td, 0, sizeof(thread_data_t) * thread_num); + memset(page_buf, 0, sizeof(struct page_buf) * si->page_buf_zone_num * + page_buf_num_per_zone); + for (i = 0; i < si->page_buf_zone_num * page_buf_num_per_zone; i++) { + ((struct page_buf *)page_buf + i)->pagebuf = GETBUF(PAGESIZE()); + } + start = si->vaddr_start; + end = si->vaddr_end; if (start & (sizeof(long)-1)) { start &= ~(sizeof(long)-1); error(INFO, "rounding down start address to: %lx\n", start); } - if (CRASHDEBUG(1)) { begin = time(NULL); - fprintf(fp, "search_virtual: start: %lx end: %lx\n", + fprintf(fp, "search_virtual: start: %lx end: %lx\n", start, end); } - next = start; + for (i = 0; i < thread_num; i++) { + td[i].si = si; + if ((td[i].output_buf = malloc(1024)) == NULL) + error(FATAL, "cannot malloc output buffer"); + *td[i].output_buf = '\0'; + td[i].output_buf_size = 1024; + td[i].empty_page_buf_zone_count = &empty_page_buf_zone_count; + td[i].barrier = &barrier; + td[i].finished_thread_count = &finished_thread_count; + td[i].page_buf_zone_index = &thread_page_buf_zone_index; + td[i].finished_thread_count_mutex = &finished_thread_count_mutex; + td[i].td = td; + td[i].start = (int *)GETBUF(sizeof(int) * si->page_buf_zone_num * 3); + td[i].end = td[i].start + si->page_buf_zone_num * 1; + td[i].exit = td[i].start + si->page_buf_zone_num * 2; + memset(td[i].start, 0, sizeof(int) * si->page_buf_zone_num * 3); + + td[i].thread_index = i; + pthread_create(&threads[i], NULL, do_search_virtual, &td[i]); + } + + page_buf_index = 0; + next = start; + sem_wait(&empty_page_buf_zone_count); for (pp = VIRTPAGEBASE(start); next < end; next = pp) { pages_checked++; - lastpage = (VIRTPAGEBASE(next) == VIRTPAGEBASE(end)); - if (LKCD_DUMPFILE()) - set_lkcd_nohash(); - - /* - * Keep it virtual for Xen hypervisor. - */ + (page_buf + page_buf_zone_index * page_buf_num_per_zone) + [page_buf_index].lastpage = + (VIRTPAGEBASE(next) == VIRTPAGEBASE(end)); if (XEN_HYPER_MODE()) { - if (!readmem(pp, KVADDR, pagebuf, PAGESIZE(), - "search page", RETURN_ON_ERROR|QUIET)) { + if (!readmem(pp, KVADDR, (page_buf + + page_buf_zone_index * page_buf_num_per_zone) + [page_buf_index].pagebuf, + PAGESIZE(), "search page", + RETURN_ON_ERROR|QUIET)) { if (CRASHDEBUG(1)) fprintf(fp, "search suspended at: %lx\n", pp); @@ -15337,7 +15601,7 @@ search_virtual(struct searchinfo *si) goto virtual; } - switch (si->memtype) + switch (si->memtype) { case UVADDR: if (!uvtop(CURRENT_CONTEXT(), pp, &paddr, 0) || @@ -15358,60 +15622,73 @@ search_virtual(struct searchinfo *si) break; } - if (!readmem(paddr, PHYSADDR, pagebuf, PAGESIZE(), - "search page", RETURN_ON_ERROR|QUIET)) { + if (!readmem(paddr, PHYSADDR, (page_buf + + page_buf_zone_index * page_buf_num_per_zone) + [page_buf_index].pagebuf, + PAGESIZE(), "search page", + RETURN_ON_ERROR|QUIET)) { pp += PAGESIZE(); continue; } -virtual: pages_read++; - - ubp = (ulong *)&pagebuf[next - pp]; - if (lastpage) { - if (end == (ulong)(-1)) - wordcnt = PAGESIZE()/sizeof(long); - else - wordcnt = (end - next)/sizeof(long); - } else - wordcnt = (PAGESIZE() - (next - pp))/sizeof(long); - - switch (si->mode) - { - case SEARCH_ULONG: - next = search_ulong(ubp, next, wordcnt, si); - break; - case SEARCH_UINT: - next = search_uint(ubp, next, wordcnt, si); - break; - case SEARCH_USHORT: - next = search_ushort(ubp, next, wordcnt, si); - break; - case SEARCH_CHARS: - next = search_chars(ubp, next, wordcnt, si); - break; - default: - /* unimplemented search type */ - next += wordcnt * (sizeof(long)); - break; +virtual: + (page_buf + page_buf_zone_index * page_buf_num_per_zone) + [page_buf_index].ppp = pp; + (page_buf + page_buf_zone_index * page_buf_num_per_zone) + [page_buf_index++].pnext = next; + if (page_buf_index >= page_buf_num_per_zone) { + for (st = 0, i = 0; i < thread_num; st = ed, i++) { + ed = st + page_buf_index / thread_num + 1; + ed = ed > page_buf_index ? page_buf_index : ed; + td[i].start[page_buf_zone_index] = st; + td[i].end[page_buf_zone_index] = ed; + } + pthread_barrier_wait(&barrier); + page_buf_index = 0; + page_buf_zone_index = (page_buf_zone_index + 1) % + si->page_buf_zone_num; + sem_wait(&empty_page_buf_zone_count); } if (CRASHDEBUG(1)) if ((pp % (1024*1024)) == 0) console("%lx\n", pp); - pp += PAGESIZE(); } - + if (next >= end) { done: + for (st = 0, i = 0; i < thread_num; st = ed, i++) { + ed = st + page_buf_index / thread_num + 1; + ed = ed > page_buf_index ? page_buf_index : ed; + td[i].start[page_buf_zone_index] = st; + td[i].end[page_buf_zone_index] = ed; + td[i].exit[page_buf_zone_index] = true; + } + pthread_barrier_wait(&barrier); + sem_wait(&empty_page_buf_zone_count); + } + for (i = 0; i < thread_num; i++) { + pthread_join(threads[i], NULL); + } + for (i = 0; i < thread_num; i++) { + free(td[i].output_buf); + FREEBUF(td[i].start); + } + for (i = 0; i < si->page_buf_zone_num * page_buf_num_per_zone; i++) { + FREEBUF(((struct page_buf *)page_buf + i)->pagebuf); + } + FREEBUF(page_buf); + sem_destroy(&empty_page_buf_zone_count); + pthread_barrier_destroy(&barrier); + pthread_mutex_destroy(&finished_thread_count_mutex); + if (CRASHDEBUG(1)) { finish = time(NULL); pct = (pages_read * 100)/pages_checked; - fprintf(fp, - "search_virtual: read %ld (%ld%%) of %ld pages checked in %ld seconds\n", + fprintf(fp, + "search_virtual: read %ld (%ld%%) of %ld pages checked in %ld seconds\n", pages_read, pct, pages_checked, finish - begin); } - - FREEBUF(pagebuf); } diff --git a/task.c b/task.c index 88941c7..ff5b897 100644 --- a/task.c +++ b/task.c @@ -7724,6 +7724,20 @@ print_task_header(FILE *out, struct task_context *tc, int newline) task_cpu(tc->processor, buf, !VERBOSE), tc->comm); } +void +print_task_header_para(struct task_context *tc, int newline, cache_output_t *co) +{ + char buf[BUFSIZE]; + char buf1[BUFSIZE]; + + *co->output_buf_offset += snprintf(*co->output_buf, + *co->output_buf_size - *co->output_buf_offset, + "%sPID: %-7ld TASK: %s CPU: %-3s COMMAND: \"%s\"\n", + newline ? "\n" : "", tc->pid, + mkstring(buf1, VADDR_PRLEN, LJUST|LONG_HEX, MKSTR(tc->task)), + task_cpu(tc->processor, buf, !VERBOSE), tc->comm); +} + /* * "help -t" output */ -- 2.33.1

search_chars is different from search_ulong, search_uint and search_ushort. The latter ones don't need to handle the page crossing, while search_chars deals with string search, the strings can be longer than ulong/uint/ushort, so page crossing should be handled in this case. For the original single thread version of search_chars, at the end of each pagebuf string match, a hit record with chars location is kept, and will be used for string match at the start of next pagebuf processing. Since it only handles the page crossing between 2 pages, one cross_match struct is enough for the work. For the multithread version of search_chars, the situation is a bit more complex. e.g. we have 4 search_chars threads, and 100 pagebufs per zone. Threads 1 handles page 1~25, thread 2 handles page 26~50, thread 3 handles page 51~75, thread 4 handles page 76~100. For each thread, the page crossing is handled as usual, and a copy of the first page is kept as reserved page. The cases which should be handled specifically are 25~26, 50~51, 75~76, 100~101 page crossing. The last finished thread is responsible to use the final hit record of thread 1, aka page 25, against the reserved page of thread 2, aka page 26. Same as 50~51 and 75~76 page crossing. Then the final hit record of thread 4, aka page 100, is copied to thread 1, which will later be used against page 101 of next zone processing. In this case, 4 cross_match_para struct is used for 4 threads page crossing. Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- memory.c | 334 ++++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 243 insertions(+), 91 deletions(-) diff --git a/memory.c b/memory.c index 75112d7..024eccc 100644 --- a/memory.c +++ b/memory.c @@ -249,11 +249,11 @@ static void display_with_pre_and_post(void *, ulonglong, struct searchinfo *); static ulong search_ulong(ulong *, ulong, int, struct searchinfo *, struct searchinfo *, void *); static ulong search_uint(ulong *, ulong, int, struct searchinfo *, struct searchinfo *, void *); static ulong search_ushort(ulong *, ulong, int, struct searchinfo *, struct searchinfo *, void *); -static ulong search_chars(ulong *, ulong, int, struct searchinfo *); +static ulong search_chars(ulong *, ulong, int, struct searchinfo *, void *); static ulonglong search_ulong_p(ulong *, ulonglong, int, struct searchinfo *, void *); static ulonglong search_uint_p(ulong *, ulonglong, int, struct searchinfo *, void *); static ulonglong search_ushort_p(ulong *, ulonglong, int, struct searchinfo *, void *); -static ulonglong search_chars_p(ulong *, ulonglong, int, struct searchinfo *); +static ulonglong search_chars_p(ulong *, ulonglong, int, struct searchinfo *, void *); static void search_virtual(struct searchinfo *); static void search_physical(struct searchinfo *); static int next_upage(struct task_context *, ulong, ulong *); @@ -328,6 +328,8 @@ static void dump_hstates(void); static void freelist_ptr_init(void); static ulong freelist_ptr(struct meminfo *, ulong, ulong); static ulong handle_each_vm_area(struct handle_each_vm_area_args *); +static void clean_cross_para(int); +static void cross_para_handle(ulong *, struct searchinfo *, int, char **, int *, int *); /* * Memory display modes specific to this file. @@ -15316,188 +15318,285 @@ typedef struct thread_data { int thread_index; } thread_data_t; +typedef struct cross_match_para { + struct search_arg { + int cnt; + ulong addr; + ulonglong addr_p; + char hit[BUFSIZE]; + } search_arg[MAXARGS]; + char *reserve_buf; + ulonglong reserve_buf_addr_p; + ulonglong cross_match_next_addr_p; + int thread_start_flag; +} cross_para_t; +cross_para_t *cross_para; + static void -report_match(struct searchinfo *si, ulong addr, char *ptr1, int len1, char *ptr2, int len2) +report_match(struct searchinfo *si, ulong addr, char *ptr1, int len1, + char *ptr2, int len2, char **out_buf, int *out_buf_size, + int *out_buf_offset) { int i; + char *tmp; + cache_output_t co = { + .output_buf = out_buf, + .output_buf_offset = out_buf_offset, + .output_buf_size = out_buf_size, + }; + + if (*out_buf_offset > (*out_buf_size >> 1)) { + tmp = *out_buf; + *out_buf_size <<= 1; + if ((*out_buf = malloc(*out_buf_size)) == NULL) { + error(FATAL, "cannot malloc more output buffer"); + } + memcpy(*out_buf, tmp, *out_buf_offset); + free(tmp); + } if (si->do_task_header) { - print_task_header(fp, si->task_context, si->tasks_found); + print_task_header_para(si->task_context, si->tasks_found, &co); si->do_task_header = FALSE; si->tasks_found++; } - fprintf(fp, "%lx: ", addr); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, "%lx: ", addr); for (i = 0; i < len1; i++) { if (isprint(ptr1[i])) - fprintf(fp, "%c", ptr1[i]); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, + "%c", ptr1[i]); else - fprintf(fp, "."); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, + "."); } for (i = 0; i < len2; i++) { if (isprint(ptr2[i])) - fprintf(fp, "%c", ptr2[i]); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, + "%c", ptr2[i]); else - fprintf(fp, "."); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, + "."); } - fprintf(fp, "\n"); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, "\n"); } static ulong -search_chars(ulong *bufptr, ulong addr, int longcnt, struct searchinfo *si) +search_chars(ulong *bufptr, ulong addr, int longcnt, + struct searchinfo *si, void *priv) { int i, j; int len; char *target; int charcnt = longcnt * sizeof(long); char *ptr = (char *)bufptr; + thread_data_t *td = (thread_data_t *)priv; + int thread_index = td->thread_index; - /* is this the first page of this search? */ - if (si->s_parms.s_chars.started_flag == 0) { - for (j = 0; j < si->vcnt; j++) { - cross[j].cnt = 0; /* no hits */ - } - cross_match_next_addr = (ulong)-1; /* no page match for first page */ - si->s_parms.s_chars.started_flag++; + if ((cross_para[thread_index].cross_match_next_addr_p) == addr) { + cross_para_handle(bufptr, si, thread_index, &td->output_buf, + &td->output_buf_size, &td->output_buf_offset); } - if (cross_match_next_addr == addr) { - for (j = 0; j < si->vcnt; j++) { - if (cross[j].cnt) { - target = si->s_parms.s_chars.value[j]; - len = si->s_parms.s_chars.len[j]; - for (i = 0; i < len - 1; i++) { - if (cross[j].hit[i] && - !strncmp(&target[len - 1 - i], ptr, i + 1)) - report_match(si, cross[j].addr + i, - target, len, - &ptr[i+1], - CHARS_CTX - len); - } - } - } + if (cross_para[thread_index].thread_start_flag) { + cross_para[thread_index].thread_start_flag = 0; + cross_para[thread_index].reserve_buf = ptr; + cross_para[thread_index].reserve_buf_addr_p = addr; } - /* set up for possible cross matches on this page */ - cross_match_next_addr = addr + charcnt; + // reset hit status for (j = 0; j < si->vcnt; j++) { len = si->s_parms.s_chars.len[j]; - cross[j].cnt = 0; - cross[j].addr = addr + longcnt * sizeof(long) - (len - 1); - for (i = 0; i < len - 1; i++) - cross[j].hit[i] = 0; + cross_para[thread_index].search_arg[j].cnt = 0; + cross_para[thread_index].search_arg[j].addr_p = + addr + longcnt * sizeof(long) - (len - 1); + for (i = 0; i < len - 1; i++) + cross_para[thread_index].search_arg[j].hit[i] = 0; } - - for (i = 0; i < charcnt; i++, ptr++, addr++) { + + for (i = 0; i < charcnt; i++, ptr++) { for (j = 0; j < si->vcnt; j++) { target = si->s_parms.s_chars.value[j]; len = si->s_parms.s_chars.len[j]; if ((i + len) > charcnt) { /* check for cross match */ if (!strncmp(target, ptr, charcnt - i)) { - cross[j].hit[len + i - charcnt - 1] = 1; - cross[j].cnt++; - } + cross_para[thread_index].search_arg[j] + .hit[len + i - charcnt - 1] = 1; + cross_para[thread_index].search_arg[j].cnt++; + } } else { if (!strncmp(target, ptr, len)) { int slen = CHARS_CTX; if ((i + CHARS_CTX) > charcnt) slen = charcnt - i; - report_match(si, addr, ptr, slen, (char *)0, 0); + report_match(si, + addr + i, ptr, slen, NULL, 0, + &td->output_buf, + &td->output_buf_size, + &td->output_buf_offset + ); } } } } - return addr; + cross_para[thread_index].cross_match_next_addr_p = addr + charcnt; + return addr + charcnt; } static void -report_match_p(ulonglong addr, char *ptr1, int len1, char *ptr2, int len2) +report_match_p(ulonglong addr, char *ptr1, int len1, char *ptr2, + int len2, char **out_buf, int *out_buf_size, + int *out_buf_offset) { int i; - fprintf(fp, "%llx: ", addr); + char *tmp; + + if (*out_buf_offset > (*out_buf_size >> 1)) { + tmp = *out_buf; + *out_buf_size <<= 1; + if ((*out_buf = malloc(*out_buf_size)) == NULL) { + error(FATAL, "cannot malloc more output buffer"); + } + memcpy(*out_buf, tmp, *out_buf_offset); + free(tmp); + } + + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, "%llx: ", addr); for (i = 0; i < len1; i++) { if (isprint(ptr1[i])) - fprintf(fp, "%c", ptr1[i]); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, + "%c", ptr1[i]); else - fprintf(fp, "."); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, + "."); } for (i = 0; i < len2; i++) { if (isprint(ptr2[i])) - fprintf(fp, "%c", ptr2[i]); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, + "%c", ptr2[i]); else - fprintf(fp, "."); + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, + "."); + } + *out_buf_offset += snprintf(*out_buf + *out_buf_offset, + *out_buf_size - *out_buf_offset, "\n"); +} + +static void +cross_para_handle(ulong *bufptr, struct searchinfo *si, + int thread_index, char **output_buf, + int *output_buf_size, int *output_buf_offset) +{ + int i, j; + int len; + char *target; + char *ptr = (char *)bufptr; + + for (j = 0; j < si->vcnt; j++) { + if (cross_para[thread_index].search_arg[j].cnt) { + target = si->s_parms.s_chars.value[j]; + len = si->s_parms.s_chars.len[j]; + for (i = 0; i < len - 1; i++) { + if (cross_para[thread_index].search_arg[j].hit[i] && + !strncmp(&target[len - 1 - i], ptr, i + 1)) + report_match_p( + cross_para[thread_index] + .search_arg[j].addr_p + i, + target, len, + &ptr[i + 1], CHARS_CTX - len, + output_buf, + output_buf_size, + output_buf_offset); + } + } } - fprintf(fp, "\n"); } static ulonglong -search_chars_p(ulong *bufptr, ulonglong addr_p, int longcnt, struct searchinfo *si) +search_chars_p(ulong *bufptr, ulonglong addr_p, int longcnt, + struct searchinfo *si, void *priv) { int i, j; int len; char *target; int charcnt = longcnt * sizeof(long); char *ptr = (char *)bufptr; + thread_data_t *td = (thread_data_t *)priv; + int thread_index = td->thread_index; - /* is this the first page of this search? */ - if (si->s_parms.s_chars.started_flag == 0) { - for (j = 0; j < si->vcnt; j++) { - cross[j].cnt = 0; /* no hits */ - } - cross_match_next_addr_p = (ulonglong)-1; /* no page match for first page */ - si->s_parms.s_chars.started_flag++; + if ((cross_para[thread_index].cross_match_next_addr_p) == addr_p) { + cross_para_handle(bufptr, si, thread_index, + &td->output_buf, &td->output_buf_size, + &td->output_buf_offset); } - if (cross_match_next_addr_p == addr_p) { - for (j = 0; j < si->vcnt; j++) { - if (cross[j].cnt) { - target = si->s_parms.s_chars.value[j]; - len = si->s_parms.s_chars.len[j]; - for (i = 0; i < len - 1; i++) { - if (cross[j].hit[i] && - !strncmp(&target[len - 1 - i], ptr, i + 1)) - report_match_p(cross[j].addr_p + i, - target, len, - &ptr[i+1], - CHARS_CTX - len); - } - } - } + if (cross_para[thread_index].thread_start_flag) { + cross_para[thread_index].thread_start_flag = 0; + cross_para[thread_index].reserve_buf = ptr; + cross_para[thread_index].reserve_buf_addr_p = addr_p; } - /* set up for possible cross matches on this page */ - cross_match_next_addr_p = addr_p + charcnt; + // reset hit status for (j = 0; j < si->vcnt; j++) { len = si->s_parms.s_chars.len[j]; - cross[j].cnt = 0; - cross[j].addr_p = addr_p + longcnt * sizeof(long) - (len - 1); - for (i = 0; i < len - 1; i++) - cross[j].hit[i] = 0; + cross_para[thread_index].search_arg[j].cnt = 0; + cross_para[thread_index].search_arg[j].addr_p = + addr_p + longcnt * sizeof(long) - (len - 1); + for (i = 0; i < len - 1; i++) + cross_para[thread_index].search_arg[j].hit[i] = 0; } - - for (i = 0; i < charcnt; i++, ptr++, addr_p++) { + + for (i = 0; i < charcnt; i++, ptr++) { for (j = 0; j < si->vcnt; j++) { target = si->s_parms.s_chars.value[j]; len = si->s_parms.s_chars.len[j]; if ((i + len) > charcnt) { /* check for cross match */ if (!strncmp(target, ptr, charcnt - i)) { - cross[j].hit[len + i - charcnt - 1] = 1; - cross[j].cnt++; - } + cross_para[thread_index].search_arg[j] + .hit[len + i - charcnt - 1] = 1; + cross_para[thread_index].search_arg[j].cnt++; + } } else { if (!strncmp(target, ptr, len)) { int slen = CHARS_CTX; if ((i + CHARS_CTX) > charcnt) slen = charcnt - i; - report_match_p(addr_p, ptr, slen, (char *)0, 0); + report_match_p( + addr_p + i, ptr, slen, NULL, 0, + &td->output_buf, + &td->output_buf_size, + &td->output_buf_offset + ); } } } } - return addr_p; + cross_para[thread_index].cross_match_next_addr_p = addr_p + charcnt; + return addr_p + charcnt; +} + +static void +clean_cross_para(int i) +{ + memset(&cross_para[i].search_arg[0], 0, + sizeof(cross_para[i].search_arg)); + cross_para[i].reserve_buf_addr_p = (ulonglong)-1; + cross_para[i].cross_match_next_addr_p = (ulonglong)-1; + cross_para[i].thread_start_flag = 1; } static void * @@ -15558,7 +15657,8 @@ do_search_virtual(void *args) &si, td->si, &cache_output); break; case SEARCH_CHARS: - next = search_chars(ubp, next, wordcnt, si); + next = search_chars(ubp, next, wordcnt, + &si, td); break; default: /* unimplemented search type */ @@ -15569,6 +15669,28 @@ do_search_virtual(void *args) pthread_mutex_lock(td->finished_thread_count_mutex); if (++(*td->finished_thread_count) == si.thread_num) { pthread_mutex_unlock(td->finished_thread_count_mutex); + if (td->si->mode == SEARCH_CHARS) { + for (i = 0; i < si.thread_num - 1; i++) { + if (cross_para[i].cross_match_next_addr_p == + cross_para[i + 1].reserve_buf_addr_p) { + cross_para_handle( + (ulong *)cross_para[i + 1].reserve_buf, + &si, i, &(td->td + i)->output_buf, + &(td->td + i)->output_buf_size, + &(td->td + i)->output_buf_offset + ); + } + clean_cross_para(i); + } + memcpy(&cross_para[0].search_arg[0], + &cross_para[i].search_arg[0], + sizeof(cross_para[i].search_arg)); + cross_para[0].cross_match_next_addr_p = + cross_para[i].cross_match_next_addr_p; + cross_para[0].thread_start_flag = 1; + if (i > 0) + clean_cross_para(i); + } for (i = 0; i < si.thread_num; i++) { fprintf(fp, "%s", (td->td + i)->output_buf); *((td->td + i)->output_buf) = '\0'; @@ -15620,6 +15742,7 @@ search_virtual(struct searchinfo *si) // Alloc buffers page_buf = (page_buf_t *)GETBUF(sizeof(page_buf_t) * si->page_buf_zone_num * page_buf_num_per_zone); + cross_para = (cross_para_t *)GETBUF(sizeof(cross_para_t) * thread_num); threads = (pthread_t *)GETBUF(sizeof(pthread_t) * thread_num); td = (thread_data_t *)GETBUF(sizeof(thread_data_t) * thread_num); memset(threads, 0, sizeof(sizeof(pthread_t) * thread_num)); @@ -15660,6 +15783,7 @@ search_virtual(struct searchinfo *si) memset(td[i].start, 0, sizeof(int) * si->page_buf_zone_num * 3); td[i].thread_index = i; + clean_cross_para(i); pthread_create(&threads[i], NULL, do_search_virtual, &td[i]); } @@ -15759,6 +15883,7 @@ done: free(td[i].output_buf); FREEBUF(td[i].start); } + FREEBUF(cross_para); for (i = 0; i < si->page_buf_zone_num * page_buf_num_per_zone; i++) { FREEBUF(((struct page_buf *)page_buf + i)->pagebuf); } @@ -15834,7 +15959,8 @@ do_search_physical(void *args) &si, &cache_output); break; case SEARCH_CHARS: - pnext = search_chars_p(ubp, pnext, wordcnt, si); + pnext = search_chars_p(ubp, pnext, wordcnt, + &si, td); break; default: /* unimplemented search type */ @@ -15846,6 +15972,29 @@ do_search_physical(void *args) if (++(*td->finished_thread_count) == si.thread_num) { pthread_mutex_unlock(td->finished_thread_count_mutex); + if (td->si->mode == SEARCH_CHARS) { + for (i = 0; i < si.thread_num - 1; i++) { + if (cross_para[i].cross_match_next_addr_p == + cross_para[i + 1].reserve_buf_addr_p) { + cross_para_handle( + (ulong *)cross_para[i + 1].reserve_buf, + &si, i, &(td->td + i)->output_buf, + &(td->td + i)->output_buf_size, + &(td->td + i)->output_buf_offset + ); + } + clean_cross_para(i); + } + memcpy(&cross_para[0].search_arg[0], + &cross_para[i].search_arg[0], + sizeof(cross_para[i].search_arg)); + cross_para[0].cross_match_next_addr_p = + cross_para[i].cross_match_next_addr_p; + cross_para[0].thread_start_flag = 1; + if (i > 0) + clean_cross_para(i); + } + for (i = 0; i < si.thread_num; i++) { fprintf(fp, "%s", (td->td + i)->output_buf); *((td->td + i)->output_buf) = '\0'; @@ -15896,6 +16045,7 @@ search_physical(struct searchinfo *si) // Alloc buffers page_buf = (page_buf_t *)GETBUF(sizeof(page_buf_t) * si->page_buf_zone_num * page_buf_num_per_zone); + cross_para = (cross_para_t *)GETBUF(sizeof(cross_para_t) * thread_num); threads = (pthread_t *)GETBUF(sizeof(pthread_t) * thread_num); td = (thread_data_t *)GETBUF(sizeof(thread_data_t) * thread_num); memset(td, 0, sizeof(thread_data_t) * thread_num); @@ -15936,6 +16086,7 @@ search_physical(struct searchinfo *si) memset(td[i].start, 0, sizeof(int) * si->page_buf_zone_num * 3); td[i].thread_index = i; + clean_cross_para(i); pthread_create(&threads[i], NULL, do_search_physical, &td[i]); } @@ -16000,6 +16151,7 @@ search_physical(struct searchinfo *si) free(td[i].output_buf); FREEBUF(td[i].start); } + FREEBUF(cross_para); for (i = 0; i < si->page_buf_zone_num * page_buf_num_per_zone; i++) { FREEBUF(((struct page_buf *)page_buf + i)->pagebuf); } -- 2.33.1

Previously crash use lseek/read for kcore and vmcore reading, this involves 2 syscalls. And we can replace them with pread, only 1 syscall is needed for kcore/vmcore reading, and we can have a better performance. Please note there are plenty of places in crash using lseek/read, this patch doesn't modify all of them, just the most commonly used kcore and diskdump vmcore reading. Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- diskdump.c | 11 ++--------- netdump.c | 5 +---- 2 files changed, 3 insertions(+), 13 deletions(-) diff --git a/diskdump.c b/diskdump.c index cf5f5d9..acf79f2 100644 --- a/diskdump.c +++ b/diskdump.c @@ -515,15 +515,11 @@ arm_kdump_header_adjust(int header_version) static int read_pd(int fd, off_t offset, page_desc_t *pd) { - const off_t failed = (off_t)-1; - if (FLAT_FORMAT()) { if (!read_flattened_format(fd, offset, pd, sizeof(*pd))) return READ_ERROR; } else { - if (lseek(fd, offset, SEEK_SET) == failed) - return SEEK_ERROR; - if (read(fd, pd, sizeof(*pd)) != sizeof(*pd)) + if (pread(fd, pd, sizeof(*pd), offset) != sizeof(*pd)) return READ_ERROR; } @@ -1125,7 +1121,6 @@ cache_page(physaddr_t paddr) off_t seek_offset; page_desc_t pd; const int block_size = dd->block_size; - const off_t failed = (off_t)-1; ulong retlen; #ifdef ZSTD static ZSTD_DCtx *dctx = NULL; @@ -1190,9 +1185,7 @@ cache_page(physaddr_t paddr) return PAGE_INCOMPLETE; } } else { - if (lseek(dd->dfd, pd.offset, SEEK_SET) == failed) - return SEEK_ERROR; - if (read(dd->dfd, dd->compressed_page, pd.size) != pd.size) + if (pread(dd->dfd, dd->compressed_page, pd.size, pd.offset) != pd.size) return READ_ERROR; } diff --git a/netdump.c b/netdump.c index 01af145..e76807a 100644 --- a/netdump.c +++ b/netdump.c @@ -4436,10 +4436,7 @@ read_proc_kcore(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr) if (offset == UNINITIALIZED) return SEEK_ERROR; - if (lseek(fd, offset, SEEK_SET) != offset) - perror("lseek"); - - if (read(fd, bufptr, readcnt) != readcnt) + if (pread(fd, bufptr, readcnt, offset) != readcnt) return READ_ERROR; return cnt; -- 2.33.1

Hi Kazu, Sorry for the late reply. On Fri, Apr 7, 2023 at 10:36 AM HAGIO KAZUHITO(萩尾　一仁) <k-hagio-ab(a)nec.com&gt; wrote: Sorry I didn't understand your question... The functions which I modified in this patch didn't use a global errno to distinguish error types, they used a returned value instead. Currently if read error, READ_ERROR will be returned, same as seek error returns SEEK_ERROR. Do you want to distinguish pread error by introducing a new error number as PREAD_ERROR? Thanks, Tao Liu