#include #include #include #include #include "../../util/sort.h" #include "../../util/util.h" #include "../../util/hist.h" #include "../../util/debug.h" #include "../../util/symbol.h" #include "../browser.h" #include "../helpline.h" #include "../libslang.h" /* 2048 lines should be enough for a script output */ #define MAX_LINES 2048 /* 160 bytes for one output line */ #define AVERAGE_LINE_LEN 160 struct script_line { struct list_head node; char line[AVERAGE_LINE_LEN]; }; struct perf_script_browser { struct ui_browser b; struct list_head entries; const char *script_name; int nr_lines; }; #define SCRIPT_NAMELEN 128 #define SCRIPT_MAX_NO 64 /* * Usually the full path for a script is: * /home/username/libexec/perf-core/scripts/python/xxx.py * /home/username/libexec/perf-core/scripts/perl/xxx.pl * So 256 should be long enough to contain the full path. */ #define SCRIPT_FULLPATH_LEN 256 /* * When success, will copy the full path of the selected script * into the buffer pointed by script_name, and return 0. * Return -1 on failure. */ static int list_scripts(char *script_name) { char *buf, *names[SCRIPT_MAX_NO], *paths[SCRIPT_MAX_NO]; int i, num, choice, ret = -1; /* Preset the script name to SCRIPT_NAMELEN */ buf = malloc(SCRIPT_MAX_NO * (SCRIPT_NAMELEN + SCRIPT_FULLPATH_LEN)); if (!buf) return ret; for (i = 0; i < SCRIPT_MAX_NO; i++) { names[i] = buf + i * (SCRIPT_NAMELEN + SCRIPT_FULLPATH_LEN); paths[i] = names[i] + SCRIPT_NAMELEN; } num = find_scripts(names, paths); if (num > 0) { choice = ui__popup_menu(num, names); if (choice < num && choice >= 0) { strcpy(script_name, paths[choice]); ret = 0; } } free(buf); return ret; } static void script_browser__write(struct ui_browser *browser, void *entry, int row) { struct script_line *sline = list_entry(entry, struct script_line, node); bool current_entry = ui_browser__is_current_entry(browser, row); ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED : HE_COLORSET_NORMAL); ui_browser__write_nstring(browser, sline->line, browser->width); } static int script_browser__run(struct perf_script_browser *browser) { int key; if (ui_browser__show(&browser->b, browser->script_name, "Press ESC to exit") < 0) return -1; while (1) { key = ui_browser__run(&browser->b, 0); /* We can add some special key handling here if needed */ break; } ui_browser__hide(&browser->b); return key; } int script_browse(const char *script_opt) { char cmd[SCRIPT_FULLPATH_LEN*2], script_name[SCRIPT_FULLPATH_LEN]; char *line = NULL; size_t len = 0; ssize_t retlen; int ret = -1, nr_entries = 0; FILE *fp; void *buf; struct script_line *sline; struct perf_script_browser script = { .b = { .refresh = ui_browser__list_head_refresh, .seek = ui_browser__list_head_seek, .write = script_browser__write, }, .script_name = script_name, }; INIT_LIST_HEAD(&script.entries); /* Save each line of the output in one struct script_line object. */ buf = zalloc((sizeof(*sline)) * MAX_LINES); if (!buf) return -1; sline = buf; memset(script_name, 0, SCRIPT_FULLPATH_LEN); if (list_scripts(script_name)) goto exit; sprintf(cmd, "perf script -s %s ", script_name); if (script_opt) strcat(cmd, script_opt); if (input_name) { strcat(cmd, " -i "); strcat(cmd, input_name); } strcat(cmd, " 2>&1"); fp = popen(cmd, "r"); if (!fp) goto exit; while ((retlen = getline(&line, &len, fp)) != -1) { strncpy(sline->line, line, AVERAGE_LINE_LEN); /* If one output line is very large, just cut it short */ if (retlen >= AVERAGE_LINE_LEN) { sline->line[AVERAGE_LINE_LEN - 1] = '\0'; sline->line[AVERAGE_LINE_LEN - 2] = '\n'; } list_add_tail(&sline->node, &script.entries); if (script.b.width < retlen) script.b.width = retlen; if (nr_entries++ >= MAX_LINES - 1) break; sline++; } if (script.b.width > AVERAGE_LINE_LEN) script.b.width = AVERAGE_LINE_LEN; free(line); pclose(fp); script.nr_lines = nr_entries; script.b.nr_entries = nr_entries; script.b.entries = &script.entries; ret = script_browser__run(&script); exit: free(buf); return ret; } emode:
authorBenjamin Herrenschmidt <benh@kernel.crashing.org>2017-02-03 17:10:28 +1100
committerMichael Ellerman <mpe@ellerman.id.au>2017-02-08 23:36:29 +1100
commitd7df2443cd5f67fc6ee7c05a88e4996e8177f91b (patch)
tree098a7c0ca4fceb8a65cb1f693c9d71990388933d /drivers/usb/core/Makefile
parenta0615a16f7d0ceb5804d295203c302d496d8ee91 (diff)
powerpc/mm: Fix spurrious segfaults on radix with autonuma
When autonuma (Automatic NUMA balancing) marks a PTE inaccessible it clears all the protection bits but leave the PTE valid. With the Radix MMU, an attempt at executing from such a PTE will take a fault with bit 35 of SRR1 set "SRR1_ISI_N_OR_G". It is thus incorrect to treat all such faults as errors. We should pass them to handle_mm_fault() for autonuma to deal with. The case of pages that are really not executable is handled by the existing test for VM_EXEC further down. That leaves us with catching the kernel attempts at executing user pages. We can catch that earlier, even before we do find_vma. It is never valid on powerpc for the kernel to take an exec fault to begin with. So fold that test with the existing test for the kernel faulting on kernel addresses to bail out early. Fixes: 1d18ad026844 ("powerpc/mm: Detect instruction fetch denied and report") Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org> Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> Acked-by: Balbir Singh <bsingharora@gmail.com> Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Diffstat (limited to 'drivers/usb/core/Makefile')