#include "evlist.h" #include "evsel.h" #include "thread_map.h" #include "cpumap.h" #include "tests.h" #include static int exited; static int nr_exit; static void sig_handler(int sig __maybe_unused) { exited = 1; } /* * perf_evlist__prepare_workload will send a SIGUSR1 if the fork fails, since * we asked by setting its exec_error to this handler. */ static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info __maybe_unused, void *ucontext __maybe_unused) { exited = 1; nr_exit = -1; } /* * This test will start a workload that does nothing then it checks * if the number of exit event reported by the kernel is 1 or not * in order to check the kernel returns correct number of event. */ int test__task_exit(int subtest __maybe_unused) { int err = -1; union perf_event *event; struct perf_evsel *evsel; struct perf_evlist *evlist; struct target target = { .uid = UINT_MAX, .uses_mmap = true, }; const char *argv[] = { "true", NULL }; char sbuf[STRERR_BUFSIZE]; struct cpu_map *cpus; struct thread_map *threads; signal(SIGCHLD, sig_handler); evlist = perf_evlist__new_default(); if (evlist == NULL) { pr_debug("perf_evlist__new_default\n"); return -1; } /* * Create maps of threads and cpus to monitor. In this case * we start with all threads and cpus (-1, -1) but then in * perf_evlist__prepare_workload we'll fill in the only thread * we're monitoring, the one forked there. */ cpus = cpu_map__dummy_new(); threads = thread_map__new_by_tid(-1); if (!cpus || !threads) { err = -ENOMEM; pr_debug("Not enough memory to create thread/cpu maps\n"); goto out_free_maps; } perf_evlist__set_maps(evlist, cpus, threads); cpus = NULL; threads = NULL; err = perf_evlist__prepare_workload(evlist, &target, argv, false, workload_exec_failed_signal); if (err < 0) { pr_debug("Couldn't run the workload!\n"); goto out_delete_evlist; } evsel = perf_evlist__first(evlist); evsel->attr.task = 1; evsel->attr.sample_freq = 0; evsel->attr.inherit = 0; evsel->attr.watermark = 0; evsel->attr.wakeup_events = 1; evsel->attr.exclude_kernel = 1; err = perf_evlist__open(evlist); if (err < 0) { pr_debug("Couldn't open the evlist: %s\n", str_error_r(-err, sbuf, sizeof(sbuf))); goto out_delete_evlist; } if (perf_evlist__mmap(evlist, 128, true) < 0) { pr_debug("failed to mmap events: %d (%s)\n", errno, str_error_r(errno, sbuf, sizeof(sbuf))); goto out_delete_evlist; } perf_evlist__start_workload(evlist); retry: while ((event = perf_evlist__mmap_read(evlist, 0)) != NULL) { if (event->header.type == PERF_RECORD_EXIT) nr_exit++; perf_evlist__mmap_consume(evlist, 0); } if (!exited || !nr_exit) { perf_evlist__poll(evlist, -1); goto retry; } if (nr_exit != 1) { pr_debug("received %d EXIT records\n", nr_exit); err = -1; } out_free_maps: cpu_map__put(cpus); thread_map__put(threads); out_delete_evlist: perf_evlist__delete(evlist); return err; } ef='/cgit.cgi/linux/net-next.git/commit/include/trace/events?id=dd86e373e09fb16b83e8adf5c48c421a4ca76468'>events/thp.h
diff options
context:
space:
mode:
authorThomas Gleixner <tglx@linutronix.de>2017-01-31 23:58:38 +0100
committerIngo Molnar <mingo@kernel.org>2017-02-01 08:37:27 +0100
commitdd86e373e09fb16b83e8adf5c48c421a4ca76468 (patch)
tree55703c2ea8584e303e342090614e0aab3509ab21 /include/trace/events/thp.h
parent0b3589be9b98994ce3d5aeca52445d1f5627c4ba (diff)
perf/x86/intel/rapl: Make package handling more robust
The package management code in RAPL relies on package mapping being available before a CPU is started. This changed with: 9d85eb9119f4 ("x86/smpboot: Make logical package management more robust") because the ACPI/BIOS information turned out to be unreliable, but that left RAPL in broken state. This was not noticed because on a regular boot all CPUs are online before RAPL is initialized. A possible fix would be to reintroduce the mess which allocates a package data structure in CPU prepare and when it turns out to already exist in starting throw it away later in the CPU online callback. But that's a horrible hack and not required at all because RAPL becomes functional for perf only in the CPU online callback. That's correct because user space is not yet informed about the CPU being onlined, so nothing caan rely on RAPL being available on that particular CPU. Move the allocation to the CPU online callback and simplify the hotplug handling. At this point the package mapping is established and correct. This also adds a missing check for available package data in the event_init() function. Reported-by: Yasuaki Ishimatsu <yasu.isimatu@gmail.com> Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com> Cc: Arnaldo Carvalho de Melo <acme@redhat.com> Cc: Jiri Olsa <jolsa@redhat.com> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Sebastian Siewior <bigeasy@linutronix.de> Cc: Stephane Eranian <eranian@google.com> Cc: Vince Weaver <vincent.weaver@maine.edu> Fixes: 9d85eb9119f4 ("x86/smpboot: Make logical package management more robust") Link: http://lkml.kernel.org/r/20170131230141.212593966@linutronix.de Signed-off-by: Ingo Molnar <mingo@kernel.org>
Diffstat (limited to 'include/trace/events/thp.h')