2013-06-11 22:29:18 +07:00
|
|
|
#include <traceevent/event-parse.h>
|
2012-09-27 06:05:56 +07:00
|
|
|
#include "builtin.h"
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
#include "util/color.h"
|
2013-08-23 02:49:54 +07:00
|
|
|
#include "util/debug.h"
|
2012-09-27 06:05:56 +07:00
|
|
|
#include "util/evlist.h"
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
#include "util/machine.h"
|
2013-08-29 11:29:52 +07:00
|
|
|
#include "util/session.h"
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
#include "util/thread.h"
|
2012-09-27 06:05:56 +07:00
|
|
|
#include "util/parse-options.h"
|
2013-08-09 22:28:31 +07:00
|
|
|
#include "util/strlist.h"
|
2013-08-29 11:29:53 +07:00
|
|
|
#include "util/intlist.h"
|
2012-09-27 06:05:56 +07:00
|
|
|
#include "util/thread_map.h"
|
2013-10-09 10:26:53 +07:00
|
|
|
#include "util/stat.h"
|
2013-12-03 20:09:24 +07:00
|
|
|
#include "trace-event.h"
|
2013-12-05 09:41:39 +07:00
|
|
|
#include "util/parse-events.h"
|
2012-09-27 06:05:56 +07:00
|
|
|
|
|
|
|
#include <libaudit.h>
|
|
|
|
#include <stdlib.h>
|
2013-09-12 22:18:56 +07:00
|
|
|
#include <sys/eventfd.h>
|
perf trace: Add beautifier for mmap prot parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.984 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd62ae000
1.114 ( 0.016 ms): mmap(addr: 0, len: 125100, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xd628f000
1.252 ( 0.020 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: 2050, fd: 3, off: 0) = 0xc1600000
1.282 ( 0.024 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.315 ( 0.026 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: 2066, fd: 3, off: 1757184) = 0xc19ad000
1.352 ( 0.017 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: 50, fd: 4294967295, off: 0) = 0xc19b3000
1.415 ( 0.011 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628e000
1.440 ( 0.011 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628c000
1.569 ( 0.019 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.591 ( 0.017 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.616 ( 0.016 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
2.105 ( 0.018 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xcfe9c000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-21 03:44:42 +07:00
|
|
|
#include <sys/mman.h>
|
2013-09-02 23:46:44 +07:00
|
|
|
#include <linux/futex.h>
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2013-09-12 20:29:00 +07:00
|
|
|
/* For older distros: */
|
|
|
|
#ifndef MAP_STACK
|
|
|
|
# define MAP_STACK 0x20000
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef MADV_HWPOISON
|
|
|
|
# define MADV_HWPOISON 100
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef MADV_MERGEABLE
|
|
|
|
# define MADV_MERGEABLE 12
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef MADV_UNMERGEABLE
|
|
|
|
# define MADV_UNMERGEABLE 13
|
|
|
|
#endif
|
|
|
|
|
2014-02-06 08:00:35 +07:00
|
|
|
#ifndef EFD_SEMAPHORE
|
|
|
|
# define EFD_SEMAPHORE 1
|
|
|
|
#endif
|
|
|
|
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
struct tp_field {
|
|
|
|
int offset;
|
|
|
|
union {
|
|
|
|
u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
|
|
|
|
void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
#define TP_UINT_FIELD(bits) \
|
|
|
|
static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
|
|
|
|
{ \
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
u##bits value; \
|
|
|
|
memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
|
|
|
|
return value; \
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
TP_UINT_FIELD(8);
|
|
|
|
TP_UINT_FIELD(16);
|
|
|
|
TP_UINT_FIELD(32);
|
|
|
|
TP_UINT_FIELD(64);
|
|
|
|
|
|
|
|
#define TP_UINT_FIELD__SWAPPED(bits) \
|
|
|
|
static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
|
|
|
|
{ \
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
u##bits value; \
|
|
|
|
memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
return bswap_##bits(value);\
|
|
|
|
}
|
|
|
|
|
|
|
|
TP_UINT_FIELD__SWAPPED(16);
|
|
|
|
TP_UINT_FIELD__SWAPPED(32);
|
|
|
|
TP_UINT_FIELD__SWAPPED(64);
|
|
|
|
|
|
|
|
static int tp_field__init_uint(struct tp_field *field,
|
|
|
|
struct format_field *format_field,
|
|
|
|
bool needs_swap)
|
|
|
|
{
|
|
|
|
field->offset = format_field->offset;
|
|
|
|
|
|
|
|
switch (format_field->size) {
|
|
|
|
case 1:
|
|
|
|
field->integer = tp_field__u8;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
|
|
|
|
break;
|
|
|
|
case 8:
|
|
|
|
field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
return sample->raw_data + field->offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
|
|
|
|
{
|
|
|
|
field->offset = format_field->offset;
|
|
|
|
field->pointer = tp_field__ptr;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct syscall_tp {
|
|
|
|
struct tp_field id;
|
|
|
|
union {
|
|
|
|
struct tp_field args, ret;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
|
|
|
|
struct tp_field *field,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct format_field *format_field = perf_evsel__field(evsel, name);
|
|
|
|
|
|
|
|
if (format_field == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return tp_field__init_uint(field, format_field, evsel->needs_swap);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define perf_evsel__init_sc_tp_uint_field(evsel, name) \
|
|
|
|
({ struct syscall_tp *sc = evsel->priv;\
|
|
|
|
perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
|
|
|
|
|
|
|
|
static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
|
|
|
|
struct tp_field *field,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct format_field *format_field = perf_evsel__field(evsel, name);
|
|
|
|
|
|
|
|
if (format_field == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return tp_field__init_ptr(field, format_field);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
|
|
|
|
({ struct syscall_tp *sc = evsel->priv;\
|
|
|
|
perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
|
|
|
|
|
|
|
|
static void perf_evsel__delete_priv(struct perf_evsel *evsel)
|
|
|
|
{
|
2013-12-27 03:41:15 +07:00
|
|
|
zfree(&evsel->priv);
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
perf_evsel__delete(evsel);
|
|
|
|
}
|
|
|
|
|
2013-11-12 18:51:45 +07:00
|
|
|
static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
|
|
|
|
{
|
|
|
|
evsel->priv = malloc(sizeof(struct syscall_tp));
|
|
|
|
if (evsel->priv != NULL) {
|
|
|
|
if (perf_evsel__init_sc_tp_uint_field(evsel, id))
|
|
|
|
goto out_delete;
|
|
|
|
|
|
|
|
evsel->handler = handler;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
out_delete:
|
2013-12-27 03:41:15 +07:00
|
|
|
zfree(&evsel->priv);
|
2013-11-12 18:51:45 +07:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2013-11-08 02:41:19 +07:00
|
|
|
static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
{
|
2013-11-08 02:41:19 +07:00
|
|
|
struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
|
2013-12-05 09:41:39 +07:00
|
|
|
/* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
|
|
|
|
if (evsel == NULL)
|
|
|
|
evsel = perf_evsel__newtp("syscalls", direction);
|
|
|
|
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
if (evsel) {
|
2013-11-12 18:51:45 +07:00
|
|
|
if (perf_evsel__init_syscall_tp(evsel, handler))
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
goto out_delete;
|
|
|
|
}
|
|
|
|
|
|
|
|
return evsel;
|
|
|
|
|
|
|
|
out_delete:
|
|
|
|
perf_evsel__delete_priv(evsel);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define perf_evsel__sc_tp_uint(evsel, name, sample) \
|
|
|
|
({ struct syscall_tp *fields = evsel->priv; \
|
|
|
|
fields->name.integer(&fields->name, sample); })
|
|
|
|
|
|
|
|
#define perf_evsel__sc_tp_ptr(evsel, name, sample) \
|
|
|
|
({ struct syscall_tp *fields = evsel->priv; \
|
|
|
|
fields->name.pointer(&fields->name, sample); })
|
|
|
|
|
|
|
|
static int perf_evlist__add_syscall_newtp(struct perf_evlist *evlist,
|
|
|
|
void *sys_enter_handler,
|
|
|
|
void *sys_exit_handler)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
struct perf_evsel *sys_enter, *sys_exit;
|
|
|
|
|
2013-11-08 02:41:19 +07:00
|
|
|
sys_enter = perf_evsel__syscall_newtp("sys_enter", sys_enter_handler);
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
if (sys_enter == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
|
|
|
|
goto out_delete_sys_enter;
|
|
|
|
|
2013-11-08 02:41:19 +07:00
|
|
|
sys_exit = perf_evsel__syscall_newtp("sys_exit", sys_exit_handler);
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
if (sys_exit == NULL)
|
|
|
|
goto out_delete_sys_enter;
|
|
|
|
|
|
|
|
if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
|
|
|
|
goto out_delete_sys_exit;
|
|
|
|
|
|
|
|
perf_evlist__add(evlist, sys_enter);
|
|
|
|
perf_evlist__add(evlist, sys_exit);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
out_delete_sys_exit:
|
|
|
|
perf_evsel__delete_priv(sys_exit);
|
|
|
|
out_delete_sys_enter:
|
|
|
|
perf_evsel__delete_priv(sys_enter);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-03 22:20:12 +07:00
|
|
|
struct syscall_arg {
|
|
|
|
unsigned long val;
|
2013-09-24 21:04:32 +07:00
|
|
|
struct thread *thread;
|
|
|
|
struct trace *trace;
|
2013-09-04 01:50:28 +07:00
|
|
|
void *parm;
|
2013-09-03 22:20:12 +07:00
|
|
|
u8 idx;
|
|
|
|
u8 mask;
|
|
|
|
};
|
|
|
|
|
2013-09-04 01:50:28 +07:00
|
|
|
struct strarray {
|
2013-10-09 02:00:21 +07:00
|
|
|
int offset;
|
2013-09-04 01:50:28 +07:00
|
|
|
int nr_entries;
|
|
|
|
const char **entries;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
|
|
|
|
.nr_entries = ARRAY_SIZE(array), \
|
|
|
|
.entries = array, \
|
|
|
|
}
|
|
|
|
|
2013-10-09 02:00:21 +07:00
|
|
|
#define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
|
|
|
|
.offset = off, \
|
|
|
|
.nr_entries = ARRAY_SIZE(array), \
|
|
|
|
.entries = array, \
|
|
|
|
}
|
|
|
|
|
2013-10-09 03:17:43 +07:00
|
|
|
static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
|
|
|
|
const char *intfmt,
|
|
|
|
struct syscall_arg *arg)
|
2013-09-04 01:50:28 +07:00
|
|
|
{
|
|
|
|
struct strarray *sa = arg->parm;
|
2013-10-09 02:00:21 +07:00
|
|
|
int idx = arg->val - sa->offset;
|
2013-09-04 01:50:28 +07:00
|
|
|
|
|
|
|
if (idx < 0 || idx >= sa->nr_entries)
|
2013-10-09 03:17:43 +07:00
|
|
|
return scnprintf(bf, size, intfmt, arg->val);
|
2013-09-04 01:50:28 +07:00
|
|
|
|
|
|
|
return scnprintf(bf, size, "%s", sa->entries[idx]);
|
|
|
|
}
|
|
|
|
|
2013-10-09 03:17:43 +07:00
|
|
|
static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
|
|
|
|
}
|
|
|
|
|
2013-09-04 01:50:28 +07:00
|
|
|
#define SCA_STRARRAY syscall_arg__scnprintf_strarray
|
|
|
|
|
2014-02-11 00:09:48 +07:00
|
|
|
#if defined(__i386__) || defined(__x86_64__)
|
|
|
|
/*
|
|
|
|
* FIXME: Make this available to all arches as soon as the ioctl beautifier
|
|
|
|
* gets rewritten to support all arches.
|
|
|
|
*/
|
perf trace: Initial beautifier for ioctl's 'cmd' arg
[root@zoo linux]# trace -e ioctl | grep -v "cmd: 0x" | head -10
0.386 ( 0.001 ms): trace/1602 ioctl(fd: 1<pipe:[127057]>, cmd: TCGETS, arg: 0x7fff59fcb4d0 ) = -1 ENOTTY Inappropriate ioctl for device
1459.368 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.586 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.611 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
3740.526 ( 0.002 ms): awk/1612 ioctl(fd: 1<pipe:[128265]>, cmd: TCGETS, arg: 0x7fff4d166b90 ) = -1 ENOTTY Inappropriate ioctl for device
3740.704 ( 0.001 ms): awk/1612 ioctl(fd: 3</proc/meminfo>, cmd: TCGETS, arg: 0x7fff4d1669a0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.550 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.555 ( 0.003 ms): ps/1614 ioctl(fd: 2<socket:[19550]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.558 ( 0.002 ms): ps/1614 ioctl(cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.572 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TCGETS, arg: 0x7fff59176220 ) = -1 ENOTTY Inappropriate ioctl for device
[root@zoo linux]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-afajwap3mr60dfl4qpdl1pxn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-09 03:43:20 +07:00
|
|
|
static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
|
2014-02-11 00:09:48 +07:00
|
|
|
#endif /* defined(__i386__) || defined(__x86_64__) */
|
perf trace: Initial beautifier for ioctl's 'cmd' arg
[root@zoo linux]# trace -e ioctl | grep -v "cmd: 0x" | head -10
0.386 ( 0.001 ms): trace/1602 ioctl(fd: 1<pipe:[127057]>, cmd: TCGETS, arg: 0x7fff59fcb4d0 ) = -1 ENOTTY Inappropriate ioctl for device
1459.368 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.586 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.611 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
3740.526 ( 0.002 ms): awk/1612 ioctl(fd: 1<pipe:[128265]>, cmd: TCGETS, arg: 0x7fff4d166b90 ) = -1 ENOTTY Inappropriate ioctl for device
3740.704 ( 0.001 ms): awk/1612 ioctl(fd: 3</proc/meminfo>, cmd: TCGETS, arg: 0x7fff4d1669a0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.550 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.555 ( 0.003 ms): ps/1614 ioctl(fd: 2<socket:[19550]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.558 ( 0.002 ms): ps/1614 ioctl(cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.572 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TCGETS, arg: 0x7fff59176220 ) = -1 ENOTTY Inappropriate ioctl for device
[root@zoo linux]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-afajwap3mr60dfl4qpdl1pxn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-09 03:43:20 +07:00
|
|
|
|
2013-09-24 21:04:32 +07:00
|
|
|
static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg);
|
|
|
|
|
|
|
|
#define SCA_FD syscall_arg__scnprintf_fd
|
|
|
|
|
|
|
|
static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int fd = arg->val;
|
|
|
|
|
|
|
|
if (fd == AT_FDCWD)
|
|
|
|
return scnprintf(bf, size, "CWD");
|
|
|
|
|
|
|
|
return syscall_arg__scnprintf_fd(bf, size, arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_FDAT syscall_arg__scnprintf_fd_at
|
|
|
|
|
|
|
|
static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg);
|
|
|
|
|
|
|
|
#define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
|
|
|
|
|
2013-09-02 20:39:21 +07:00
|
|
|
static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
|
2013-09-03 22:20:12 +07:00
|
|
|
struct syscall_arg *arg)
|
2013-08-24 04:14:48 +07:00
|
|
|
{
|
2013-09-03 22:20:12 +07:00
|
|
|
return scnprintf(bf, size, "%#lx", arg->val);
|
2013-08-24 04:14:48 +07:00
|
|
|
}
|
|
|
|
|
2013-08-26 22:29:38 +07:00
|
|
|
#define SCA_HEX syscall_arg__scnprintf_hex
|
|
|
|
|
2013-09-02 20:39:21 +07:00
|
|
|
static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
|
2013-09-03 22:20:12 +07:00
|
|
|
struct syscall_arg *arg)
|
perf trace: Add beautifier for mmap prot parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.984 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd62ae000
1.114 ( 0.016 ms): mmap(addr: 0, len: 125100, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xd628f000
1.252 ( 0.020 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: 2050, fd: 3, off: 0) = 0xc1600000
1.282 ( 0.024 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.315 ( 0.026 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: 2066, fd: 3, off: 1757184) = 0xc19ad000
1.352 ( 0.017 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: 50, fd: 4294967295, off: 0) = 0xc19b3000
1.415 ( 0.011 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628e000
1.440 ( 0.011 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628c000
1.569 ( 0.019 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.591 ( 0.017 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.616 ( 0.016 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
2.105 ( 0.018 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xcfe9c000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-21 03:44:42 +07:00
|
|
|
{
|
2013-09-03 22:20:12 +07:00
|
|
|
int printed = 0, prot = arg->val;
|
perf trace: Add beautifier for mmap prot parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.984 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd62ae000
1.114 ( 0.016 ms): mmap(addr: 0, len: 125100, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xd628f000
1.252 ( 0.020 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: 2050, fd: 3, off: 0) = 0xc1600000
1.282 ( 0.024 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.315 ( 0.026 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: 2066, fd: 3, off: 1757184) = 0xc19ad000
1.352 ( 0.017 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: 50, fd: 4294967295, off: 0) = 0xc19b3000
1.415 ( 0.011 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628e000
1.440 ( 0.011 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628c000
1.569 ( 0.019 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.591 ( 0.017 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.616 ( 0.016 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
2.105 ( 0.018 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xcfe9c000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-21 03:44:42 +07:00
|
|
|
|
|
|
|
if (prot == PROT_NONE)
|
|
|
|
return scnprintf(bf, size, "NONE");
|
|
|
|
#define P_MMAP_PROT(n) \
|
|
|
|
if (prot & PROT_##n) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
|
|
|
|
prot &= ~PROT_##n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_MMAP_PROT(EXEC);
|
|
|
|
P_MMAP_PROT(READ);
|
|
|
|
P_MMAP_PROT(WRITE);
|
|
|
|
#ifdef PROT_SEM
|
|
|
|
P_MMAP_PROT(SEM);
|
|
|
|
#endif
|
|
|
|
P_MMAP_PROT(GROWSDOWN);
|
|
|
|
P_MMAP_PROT(GROWSUP);
|
|
|
|
#undef P_MMAP_PROT
|
|
|
|
|
|
|
|
if (prot)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
|
|
|
|
|
2013-09-02 20:39:21 +07:00
|
|
|
static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
|
2013-09-03 22:20:12 +07:00
|
|
|
struct syscall_arg *arg)
|
perf trace: Add beautifier for mmap flags parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.992 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa60be000
1.108 ( 0.012 ms): mmap(addr: 0, len: 125100, prot: READ, flags: PRIVATE, fd: 3, off: 0 ) = 0xa609f000
1.209 ( 0.014 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3, off: 0) = 0xc1600000
1.232 ( 0.018 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.255 ( 0.018 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3, off: 1757184) = 0xc19ad000
1.281 ( 0.011 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: 4294967295, off: 0) = 0xc19b3000
1.328 ( 0.008 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609e000
1.346 ( 0.008 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609c000
1.443 ( 0.013 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.459 ( 0.011 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.477 ( 0.011 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
1.855 ( 0.013 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: PRIVATE, fd: 3, off: 0) = 0x9fcac000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-23 20:48:33 +07:00
|
|
|
{
|
2013-09-03 22:20:12 +07:00
|
|
|
int printed = 0, flags = arg->val;
|
perf trace: Add beautifier for mmap flags parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.992 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa60be000
1.108 ( 0.012 ms): mmap(addr: 0, len: 125100, prot: READ, flags: PRIVATE, fd: 3, off: 0 ) = 0xa609f000
1.209 ( 0.014 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3, off: 0) = 0xc1600000
1.232 ( 0.018 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.255 ( 0.018 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3, off: 1757184) = 0xc19ad000
1.281 ( 0.011 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: 4294967295, off: 0) = 0xc19b3000
1.328 ( 0.008 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609e000
1.346 ( 0.008 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609c000
1.443 ( 0.013 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.459 ( 0.011 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.477 ( 0.011 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
1.855 ( 0.013 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: PRIVATE, fd: 3, off: 0) = 0x9fcac000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-23 20:48:33 +07:00
|
|
|
|
|
|
|
#define P_MMAP_FLAG(n) \
|
|
|
|
if (flags & MAP_##n) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
|
|
|
|
flags &= ~MAP_##n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_MMAP_FLAG(SHARED);
|
|
|
|
P_MMAP_FLAG(PRIVATE);
|
2013-09-05 21:29:47 +07:00
|
|
|
#ifdef MAP_32BIT
|
perf trace: Add beautifier for mmap flags parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.992 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa60be000
1.108 ( 0.012 ms): mmap(addr: 0, len: 125100, prot: READ, flags: PRIVATE, fd: 3, off: 0 ) = 0xa609f000
1.209 ( 0.014 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3, off: 0) = 0xc1600000
1.232 ( 0.018 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.255 ( 0.018 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3, off: 1757184) = 0xc19ad000
1.281 ( 0.011 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: 4294967295, off: 0) = 0xc19b3000
1.328 ( 0.008 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609e000
1.346 ( 0.008 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609c000
1.443 ( 0.013 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.459 ( 0.011 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.477 ( 0.011 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
1.855 ( 0.013 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: PRIVATE, fd: 3, off: 0) = 0x9fcac000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-23 20:48:33 +07:00
|
|
|
P_MMAP_FLAG(32BIT);
|
2013-09-05 21:29:47 +07:00
|
|
|
#endif
|
perf trace: Add beautifier for mmap flags parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.992 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa60be000
1.108 ( 0.012 ms): mmap(addr: 0, len: 125100, prot: READ, flags: PRIVATE, fd: 3, off: 0 ) = 0xa609f000
1.209 ( 0.014 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3, off: 0) = 0xc1600000
1.232 ( 0.018 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.255 ( 0.018 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3, off: 1757184) = 0xc19ad000
1.281 ( 0.011 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: 4294967295, off: 0) = 0xc19b3000
1.328 ( 0.008 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609e000
1.346 ( 0.008 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609c000
1.443 ( 0.013 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.459 ( 0.011 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.477 ( 0.011 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
1.855 ( 0.013 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: PRIVATE, fd: 3, off: 0) = 0x9fcac000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-23 20:48:33 +07:00
|
|
|
P_MMAP_FLAG(ANONYMOUS);
|
|
|
|
P_MMAP_FLAG(DENYWRITE);
|
|
|
|
P_MMAP_FLAG(EXECUTABLE);
|
|
|
|
P_MMAP_FLAG(FILE);
|
|
|
|
P_MMAP_FLAG(FIXED);
|
|
|
|
P_MMAP_FLAG(GROWSDOWN);
|
2013-08-27 23:50:40 +07:00
|
|
|
#ifdef MAP_HUGETLB
|
perf trace: Add beautifier for mmap flags parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.992 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa60be000
1.108 ( 0.012 ms): mmap(addr: 0, len: 125100, prot: READ, flags: PRIVATE, fd: 3, off: 0 ) = 0xa609f000
1.209 ( 0.014 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3, off: 0) = 0xc1600000
1.232 ( 0.018 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.255 ( 0.018 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3, off: 1757184) = 0xc19ad000
1.281 ( 0.011 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: 4294967295, off: 0) = 0xc19b3000
1.328 ( 0.008 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609e000
1.346 ( 0.008 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609c000
1.443 ( 0.013 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.459 ( 0.011 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.477 ( 0.011 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
1.855 ( 0.013 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: PRIVATE, fd: 3, off: 0) = 0x9fcac000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-23 20:48:33 +07:00
|
|
|
P_MMAP_FLAG(HUGETLB);
|
2013-08-27 23:50:40 +07:00
|
|
|
#endif
|
perf trace: Add beautifier for mmap flags parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.992 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa60be000
1.108 ( 0.012 ms): mmap(addr: 0, len: 125100, prot: READ, flags: PRIVATE, fd: 3, off: 0 ) = 0xa609f000
1.209 ( 0.014 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3, off: 0) = 0xc1600000
1.232 ( 0.018 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.255 ( 0.018 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3, off: 1757184) = 0xc19ad000
1.281 ( 0.011 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: 4294967295, off: 0) = 0xc19b3000
1.328 ( 0.008 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609e000
1.346 ( 0.008 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609c000
1.443 ( 0.013 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.459 ( 0.011 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.477 ( 0.011 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
1.855 ( 0.013 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: PRIVATE, fd: 3, off: 0) = 0x9fcac000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-23 20:48:33 +07:00
|
|
|
P_MMAP_FLAG(LOCKED);
|
|
|
|
P_MMAP_FLAG(NONBLOCK);
|
|
|
|
P_MMAP_FLAG(NORESERVE);
|
|
|
|
P_MMAP_FLAG(POPULATE);
|
|
|
|
P_MMAP_FLAG(STACK);
|
|
|
|
#ifdef MAP_UNINITIALIZED
|
|
|
|
P_MMAP_FLAG(UNINITIALIZED);
|
|
|
|
#endif
|
|
|
|
#undef P_MMAP_FLAG
|
|
|
|
|
|
|
|
if (flags)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
|
|
|
|
|
perf trace: Add beautifier for mremap flags param
~/devel/kernel/tools/perf(branch:master*) » sudo ./perf trace ~/mremap_test
0.543 ( 0.003 ms): mprotect(start: 0x600000, len: 4096, prot: READ ) = 0
0.550 ( 0.003 ms): mprotect(start: 0x7f441260d000, len: 4096, prot: READ) = 0
0.561 ( 0.010 ms): munmap(addr: 0x7f44125e2000, len: 165572 ) = 0
0.595 ( 0.012 ms): mmap(len: 12288, prot: READ|WRITE, flags: SHARED|ANONYMOUS|LOCKED, fd: -1) = 0x12608000
0.603 ( 0.006 ms): mremap(addr: 0x7f4412608000, old_len: 4096, new_len: 4096, flags: MAYMOVE|FIXED, new_addr: 0x7f16da295000) = 0xda295000
0.608 ( 0.003 ms): mremap(addr: 0x7f441260a000, old_len: 4096, new_len: 4096, flags: MAYMOVE|FIXED, new_addr: 0x7f16da297000) = 0xda297000
0.612 ( 0.003 ms): mremap(addr: 0x7f4412609000, old_len: 4096, new_len: 4096, flags: MAYMOVE|FIXED, new_addr: 0x7f16da296000) = 0xda296000
0.619 ( 0.000 ms): exit_group(
Signed-off-by: Alex Snast <asnast@gmail.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1407944560-26924-1-git-send-email-asnast@gmail.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-08-13 22:42:40 +07:00
|
|
|
static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int printed = 0, flags = arg->val;
|
|
|
|
|
|
|
|
#define P_MREMAP_FLAG(n) \
|
|
|
|
if (flags & MREMAP_##n) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
|
|
|
|
flags &= ~MREMAP_##n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_MREMAP_FLAG(MAYMOVE);
|
|
|
|
#ifdef MREMAP_FIXED
|
|
|
|
P_MREMAP_FLAG(FIXED);
|
|
|
|
#endif
|
|
|
|
#undef P_MREMAP_FLAG
|
|
|
|
|
|
|
|
if (flags)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_MREMAP_FLAGS syscall_arg__scnprintf_mremap_flags
|
|
|
|
|
2013-09-02 20:39:21 +07:00
|
|
|
static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
|
2013-09-03 22:20:12 +07:00
|
|
|
struct syscall_arg *arg)
|
2013-08-23 20:06:41 +07:00
|
|
|
{
|
2013-09-03 22:20:12 +07:00
|
|
|
int behavior = arg->val;
|
2013-08-23 20:06:41 +07:00
|
|
|
|
|
|
|
switch (behavior) {
|
|
|
|
#define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
|
|
|
|
P_MADV_BHV(NORMAL);
|
|
|
|
P_MADV_BHV(RANDOM);
|
|
|
|
P_MADV_BHV(SEQUENTIAL);
|
|
|
|
P_MADV_BHV(WILLNEED);
|
|
|
|
P_MADV_BHV(DONTNEED);
|
|
|
|
P_MADV_BHV(REMOVE);
|
|
|
|
P_MADV_BHV(DONTFORK);
|
|
|
|
P_MADV_BHV(DOFORK);
|
|
|
|
P_MADV_BHV(HWPOISON);
|
|
|
|
#ifdef MADV_SOFT_OFFLINE
|
|
|
|
P_MADV_BHV(SOFT_OFFLINE);
|
|
|
|
#endif
|
|
|
|
P_MADV_BHV(MERGEABLE);
|
|
|
|
P_MADV_BHV(UNMERGEABLE);
|
2013-08-27 23:50:40 +07:00
|
|
|
#ifdef MADV_HUGEPAGE
|
2013-08-23 20:06:41 +07:00
|
|
|
P_MADV_BHV(HUGEPAGE);
|
2013-08-27 23:50:40 +07:00
|
|
|
#endif
|
|
|
|
#ifdef MADV_NOHUGEPAGE
|
2013-08-23 20:06:41 +07:00
|
|
|
P_MADV_BHV(NOHUGEPAGE);
|
2013-08-27 23:50:40 +07:00
|
|
|
#endif
|
2013-08-23 20:06:41 +07:00
|
|
|
#ifdef MADV_DONTDUMP
|
|
|
|
P_MADV_BHV(DONTDUMP);
|
|
|
|
#endif
|
|
|
|
#ifdef MADV_DODUMP
|
|
|
|
P_MADV_BHV(DODUMP);
|
|
|
|
#endif
|
|
|
|
#undef P_MADV_PHV
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return scnprintf(bf, size, "%#x", behavior);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
|
|
|
|
|
2013-09-20 21:49:50 +07:00
|
|
|
static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int printed = 0, op = arg->val;
|
|
|
|
|
|
|
|
if (op == 0)
|
|
|
|
return scnprintf(bf, size, "NONE");
|
|
|
|
#define P_CMD(cmd) \
|
|
|
|
if ((op & LOCK_##cmd) == LOCK_##cmd) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
|
|
|
|
op &= ~LOCK_##cmd; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_CMD(SH);
|
|
|
|
P_CMD(EX);
|
|
|
|
P_CMD(NB);
|
|
|
|
P_CMD(UN);
|
|
|
|
P_CMD(MAND);
|
|
|
|
P_CMD(RW);
|
|
|
|
P_CMD(READ);
|
|
|
|
P_CMD(WRITE);
|
|
|
|
#undef P_OP
|
|
|
|
|
|
|
|
if (op)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_FLOCK syscall_arg__scnprintf_flock
|
|
|
|
|
2013-09-03 22:20:12 +07:00
|
|
|
static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
|
2013-09-02 23:46:44 +07:00
|
|
|
{
|
|
|
|
enum syscall_futex_args {
|
|
|
|
SCF_UADDR = (1 << 0),
|
|
|
|
SCF_OP = (1 << 1),
|
|
|
|
SCF_VAL = (1 << 2),
|
|
|
|
SCF_TIMEOUT = (1 << 3),
|
|
|
|
SCF_UADDR2 = (1 << 4),
|
|
|
|
SCF_VAL3 = (1 << 5),
|
|
|
|
};
|
2013-09-03 22:20:12 +07:00
|
|
|
int op = arg->val;
|
2013-09-02 23:46:44 +07:00
|
|
|
int cmd = op & FUTEX_CMD_MASK;
|
|
|
|
size_t printed = 0;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
#define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
|
2013-09-03 22:20:12 +07:00
|
|
|
P_FUTEX_OP(WAIT); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
|
|
|
|
P_FUTEX_OP(WAKE); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
|
|
|
|
P_FUTEX_OP(FD); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
|
|
|
|
P_FUTEX_OP(REQUEUE); arg->mask |= SCF_VAL3|SCF_TIMEOUT; break;
|
|
|
|
P_FUTEX_OP(CMP_REQUEUE); arg->mask |= SCF_TIMEOUT; break;
|
|
|
|
P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT; break;
|
2013-09-02 23:46:44 +07:00
|
|
|
P_FUTEX_OP(WAKE_OP); break;
|
2013-09-03 22:20:12 +07:00
|
|
|
P_FUTEX_OP(LOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
|
|
|
|
P_FUTEX_OP(UNLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
|
|
|
|
P_FUTEX_OP(TRYLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
|
|
|
|
P_FUTEX_OP(WAIT_BITSET); arg->mask |= SCF_UADDR2; break;
|
|
|
|
P_FUTEX_OP(WAKE_BITSET); arg->mask |= SCF_UADDR2; break;
|
2013-09-02 23:46:44 +07:00
|
|
|
P_FUTEX_OP(WAIT_REQUEUE_PI); break;
|
|
|
|
default: printed = scnprintf(bf, size, "%#x", cmd); break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (op & FUTEX_PRIVATE_FLAG)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "|PRIV");
|
|
|
|
|
|
|
|
if (op & FUTEX_CLOCK_REALTIME)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "|CLKRT");
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
2013-09-04 02:15:12 +07:00
|
|
|
#define SCA_FUTEX_OP syscall_arg__scnprintf_futex_op
|
|
|
|
|
2013-10-09 02:00:21 +07:00
|
|
|
static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
|
|
|
|
static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
|
perf trace: Beautify epoll_ctl 'op' arg
[root@sandy ~]# perf trace -e epoll_ctl
2.490 (0.003 ms): systemd-logind/586 epoll_ctl(epfd: 10, op: ADD, fd: 24, event: 0x7fff22314ef0) = 0
2.621 (0.003 ms): systemd-logind/586 epoll_ctl(epfd: 10, op: DEL, fd: 24 ) = 0
2.833 (0.010 ms): systemd-logind/586 epoll_ctl(epfd: 10, op: ADD, fd: 24, event: 0x7fff22314cd0) = 0
2.953 (0.002 ms): systemd-logind/586 epoll_ctl(epfd: 10, op: DEL, fd: 24 ) = 0
3.118 (0.002 ms): systemd-logind/586 epoll_ctl(epfd: 10, op: ADD, fd: 24, event: 0x7fff22314d20) = 0
4.762 (0.002 ms): systemd-logind/586 epoll_ctl(epfd: 10, op: DEL, fd: 24 ) = 0
^C[root@sandy ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-88xz9phc8cbicnxonud6if8h@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-20 21:27:32 +07:00
|
|
|
|
2013-09-04 01:50:28 +07:00
|
|
|
static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
|
|
|
|
static DEFINE_STRARRAY(itimers);
|
|
|
|
|
2013-09-04 02:15:12 +07:00
|
|
|
static const char *whences[] = { "SET", "CUR", "END",
|
|
|
|
#ifdef SEEK_DATA
|
|
|
|
"DATA",
|
|
|
|
#endif
|
|
|
|
#ifdef SEEK_HOLE
|
|
|
|
"HOLE",
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
static DEFINE_STRARRAY(whences);
|
2013-09-02 23:46:44 +07:00
|
|
|
|
2013-09-04 02:28:58 +07:00
|
|
|
static const char *fcntl_cmds[] = {
|
|
|
|
"DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
|
|
|
|
"SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
|
|
|
|
"F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
|
|
|
|
"F_GETOWNER_UIDS",
|
|
|
|
};
|
|
|
|
static DEFINE_STRARRAY(fcntl_cmds);
|
|
|
|
|
2013-09-04 21:52:33 +07:00
|
|
|
static const char *rlimit_resources[] = {
|
|
|
|
"CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
|
|
|
|
"MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
|
|
|
|
"RTTIME",
|
|
|
|
};
|
|
|
|
static DEFINE_STRARRAY(rlimit_resources);
|
|
|
|
|
2013-09-04 02:37:46 +07:00
|
|
|
static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
|
|
|
|
static DEFINE_STRARRAY(sighow);
|
|
|
|
|
2013-09-23 08:45:00 +07:00
|
|
|
static const char *clockid[] = {
|
|
|
|
"REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
|
|
|
|
"MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE",
|
|
|
|
};
|
|
|
|
static DEFINE_STRARRAY(clockid);
|
|
|
|
|
2013-09-04 20:27:41 +07:00
|
|
|
static const char *socket_families[] = {
|
|
|
|
"UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
|
|
|
|
"BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
|
|
|
|
"SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
|
|
|
|
"RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
|
|
|
|
"BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
|
|
|
|
"ALG", "NFC", "VSOCK",
|
|
|
|
};
|
|
|
|
static DEFINE_STRARRAY(socket_families);
|
|
|
|
|
2013-09-04 21:00:44 +07:00
|
|
|
#ifndef SOCK_TYPE_MASK
|
|
|
|
#define SOCK_TYPE_MASK 0xf
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
size_t printed;
|
|
|
|
int type = arg->val,
|
|
|
|
flags = type & ~SOCK_TYPE_MASK;
|
|
|
|
|
|
|
|
type &= SOCK_TYPE_MASK;
|
|
|
|
/*
|
|
|
|
* Can't use a strarray, MIPS may override for ABI reasons.
|
|
|
|
*/
|
|
|
|
switch (type) {
|
|
|
|
#define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
|
|
|
|
P_SK_TYPE(STREAM);
|
|
|
|
P_SK_TYPE(DGRAM);
|
|
|
|
P_SK_TYPE(RAW);
|
|
|
|
P_SK_TYPE(RDM);
|
|
|
|
P_SK_TYPE(SEQPACKET);
|
|
|
|
P_SK_TYPE(DCCP);
|
|
|
|
P_SK_TYPE(PACKET);
|
|
|
|
#undef P_SK_TYPE
|
|
|
|
default:
|
|
|
|
printed = scnprintf(bf, size, "%#x", type);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define P_SK_FLAG(n) \
|
|
|
|
if (flags & SOCK_##n) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
|
|
|
|
flags &= ~SOCK_##n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_SK_FLAG(CLOEXEC);
|
|
|
|
P_SK_FLAG(NONBLOCK);
|
|
|
|
#undef P_SK_FLAG
|
|
|
|
|
|
|
|
if (flags)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
|
|
|
|
|
perf trace: Beautify send/recv syscall 'flags' arg
[root@sandy ~]# perf trace -a -e recvmmsg,recvmsg,recvfrom,sendto,sendmsg,sendmmsg
6.901 (0.002 ms): 589 recvmsg(fd: 51, msg: 0x7fff35673420, flags: CMSG_CLOEXEC) = -1 EAGAIN Resource temporarily unavailable
6.966 (0.008 ms): 589 sendmsg(fd: 50, msg: 0x7fff35673230, flags: NOSIGNAL ) = 961
6.984 (0.004 ms): 979 sendmsg(fd: 3, msg: 0x7fff5b484940, flags: NOSIGNAL ) = 945
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-h25k5k50nac0ej5cl5iwgvae@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 21:54:48 +07:00
|
|
|
#ifndef MSG_PROBE
|
|
|
|
#define MSG_PROBE 0x10
|
|
|
|
#endif
|
2013-09-23 08:44:56 +07:00
|
|
|
#ifndef MSG_WAITFORONE
|
|
|
|
#define MSG_WAITFORONE 0x10000
|
|
|
|
#endif
|
perf trace: Beautify send/recv syscall 'flags' arg
[root@sandy ~]# perf trace -a -e recvmmsg,recvmsg,recvfrom,sendto,sendmsg,sendmmsg
6.901 (0.002 ms): 589 recvmsg(fd: 51, msg: 0x7fff35673420, flags: CMSG_CLOEXEC) = -1 EAGAIN Resource temporarily unavailable
6.966 (0.008 ms): 589 sendmsg(fd: 50, msg: 0x7fff35673230, flags: NOSIGNAL ) = 961
6.984 (0.004 ms): 979 sendmsg(fd: 3, msg: 0x7fff5b484940, flags: NOSIGNAL ) = 945
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-h25k5k50nac0ej5cl5iwgvae@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 21:54:48 +07:00
|
|
|
#ifndef MSG_SENDPAGE_NOTLAST
|
|
|
|
#define MSG_SENDPAGE_NOTLAST 0x20000
|
|
|
|
#endif
|
|
|
|
#ifndef MSG_FASTOPEN
|
|
|
|
#define MSG_FASTOPEN 0x20000000
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int printed = 0, flags = arg->val;
|
|
|
|
|
|
|
|
if (flags == 0)
|
|
|
|
return scnprintf(bf, size, "NONE");
|
|
|
|
#define P_MSG_FLAG(n) \
|
|
|
|
if (flags & MSG_##n) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
|
|
|
|
flags &= ~MSG_##n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_MSG_FLAG(OOB);
|
|
|
|
P_MSG_FLAG(PEEK);
|
|
|
|
P_MSG_FLAG(DONTROUTE);
|
|
|
|
P_MSG_FLAG(TRYHARD);
|
|
|
|
P_MSG_FLAG(CTRUNC);
|
|
|
|
P_MSG_FLAG(PROBE);
|
|
|
|
P_MSG_FLAG(TRUNC);
|
|
|
|
P_MSG_FLAG(DONTWAIT);
|
|
|
|
P_MSG_FLAG(EOR);
|
|
|
|
P_MSG_FLAG(WAITALL);
|
|
|
|
P_MSG_FLAG(FIN);
|
|
|
|
P_MSG_FLAG(SYN);
|
|
|
|
P_MSG_FLAG(CONFIRM);
|
|
|
|
P_MSG_FLAG(RST);
|
|
|
|
P_MSG_FLAG(ERRQUEUE);
|
|
|
|
P_MSG_FLAG(NOSIGNAL);
|
|
|
|
P_MSG_FLAG(MORE);
|
|
|
|
P_MSG_FLAG(WAITFORONE);
|
|
|
|
P_MSG_FLAG(SENDPAGE_NOTLAST);
|
|
|
|
P_MSG_FLAG(FASTOPEN);
|
|
|
|
P_MSG_FLAG(CMSG_CLOEXEC);
|
|
|
|
#undef P_MSG_FLAG
|
|
|
|
|
|
|
|
if (flags)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
|
|
|
|
|
2013-09-04 21:42:27 +07:00
|
|
|
static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
size_t printed = 0;
|
|
|
|
int mode = arg->val;
|
|
|
|
|
|
|
|
if (mode == F_OK) /* 0 */
|
|
|
|
return scnprintf(bf, size, "F");
|
|
|
|
#define P_MODE(n) \
|
|
|
|
if (mode & n##_OK) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s", #n); \
|
|
|
|
mode &= ~n##_OK; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_MODE(R);
|
|
|
|
P_MODE(W);
|
|
|
|
P_MODE(X);
|
|
|
|
#undef P_MODE
|
|
|
|
|
|
|
|
if (mode)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_ACCMODE syscall_arg__scnprintf_access_mode
|
|
|
|
|
2013-09-03 02:22:31 +07:00
|
|
|
static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
|
2013-09-03 22:20:12 +07:00
|
|
|
struct syscall_arg *arg)
|
2013-09-03 02:22:31 +07:00
|
|
|
{
|
2013-09-03 22:20:12 +07:00
|
|
|
int printed = 0, flags = arg->val;
|
2013-09-03 02:22:31 +07:00
|
|
|
|
|
|
|
if (!(flags & O_CREAT))
|
2013-09-03 22:20:12 +07:00
|
|
|
arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
|
2013-09-03 02:22:31 +07:00
|
|
|
|
|
|
|
if (flags == 0)
|
|
|
|
return scnprintf(bf, size, "RDONLY");
|
|
|
|
#define P_FLAG(n) \
|
|
|
|
if (flags & O_##n) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
|
|
|
|
flags &= ~O_##n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_FLAG(APPEND);
|
|
|
|
P_FLAG(ASYNC);
|
|
|
|
P_FLAG(CLOEXEC);
|
|
|
|
P_FLAG(CREAT);
|
|
|
|
P_FLAG(DIRECT);
|
|
|
|
P_FLAG(DIRECTORY);
|
|
|
|
P_FLAG(EXCL);
|
|
|
|
P_FLAG(LARGEFILE);
|
|
|
|
P_FLAG(NOATIME);
|
|
|
|
P_FLAG(NOCTTY);
|
|
|
|
#ifdef O_NONBLOCK
|
|
|
|
P_FLAG(NONBLOCK);
|
|
|
|
#elif O_NDELAY
|
|
|
|
P_FLAG(NDELAY);
|
|
|
|
#endif
|
|
|
|
#ifdef O_PATH
|
|
|
|
P_FLAG(PATH);
|
|
|
|
#endif
|
|
|
|
P_FLAG(RDWR);
|
|
|
|
#ifdef O_DSYNC
|
|
|
|
if ((flags & O_SYNC) == O_SYNC)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
|
|
|
|
else {
|
|
|
|
P_FLAG(DSYNC);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
P_FLAG(SYNC);
|
|
|
|
#endif
|
|
|
|
P_FLAG(TRUNC);
|
|
|
|
P_FLAG(WRONLY);
|
|
|
|
#undef P_FLAG
|
|
|
|
|
|
|
|
if (flags)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
|
|
|
|
|
2013-09-12 22:18:56 +07:00
|
|
|
static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int printed = 0, flags = arg->val;
|
|
|
|
|
|
|
|
if (flags == 0)
|
|
|
|
return scnprintf(bf, size, "NONE");
|
|
|
|
#define P_FLAG(n) \
|
|
|
|
if (flags & EFD_##n) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
|
|
|
|
flags &= ~EFD_##n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_FLAG(SEMAPHORE);
|
|
|
|
P_FLAG(CLOEXEC);
|
|
|
|
P_FLAG(NONBLOCK);
|
|
|
|
#undef P_FLAG
|
|
|
|
|
|
|
|
if (flags)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
|
|
|
|
|
2013-09-23 22:52:04 +07:00
|
|
|
static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int printed = 0, flags = arg->val;
|
|
|
|
|
|
|
|
#define P_FLAG(n) \
|
|
|
|
if (flags & O_##n) { \
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
|
|
|
|
flags &= ~O_##n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
P_FLAG(CLOEXEC);
|
|
|
|
P_FLAG(NONBLOCK);
|
|
|
|
#undef P_FLAG
|
|
|
|
|
|
|
|
if (flags)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
|
|
|
|
|
2013-09-04 03:17:15 +07:00
|
|
|
static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int sig = arg->val;
|
|
|
|
|
|
|
|
switch (sig) {
|
|
|
|
#define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
|
|
|
|
P_SIGNUM(HUP);
|
|
|
|
P_SIGNUM(INT);
|
|
|
|
P_SIGNUM(QUIT);
|
|
|
|
P_SIGNUM(ILL);
|
|
|
|
P_SIGNUM(TRAP);
|
|
|
|
P_SIGNUM(ABRT);
|
|
|
|
P_SIGNUM(BUS);
|
|
|
|
P_SIGNUM(FPE);
|
|
|
|
P_SIGNUM(KILL);
|
|
|
|
P_SIGNUM(USR1);
|
|
|
|
P_SIGNUM(SEGV);
|
|
|
|
P_SIGNUM(USR2);
|
|
|
|
P_SIGNUM(PIPE);
|
|
|
|
P_SIGNUM(ALRM);
|
|
|
|
P_SIGNUM(TERM);
|
|
|
|
P_SIGNUM(CHLD);
|
|
|
|
P_SIGNUM(CONT);
|
|
|
|
P_SIGNUM(STOP);
|
|
|
|
P_SIGNUM(TSTP);
|
|
|
|
P_SIGNUM(TTIN);
|
|
|
|
P_SIGNUM(TTOU);
|
|
|
|
P_SIGNUM(URG);
|
|
|
|
P_SIGNUM(XCPU);
|
|
|
|
P_SIGNUM(XFSZ);
|
|
|
|
P_SIGNUM(VTALRM);
|
|
|
|
P_SIGNUM(PROF);
|
|
|
|
P_SIGNUM(WINCH);
|
|
|
|
P_SIGNUM(IO);
|
|
|
|
P_SIGNUM(PWR);
|
|
|
|
P_SIGNUM(SYS);
|
2014-02-06 08:00:41 +07:00
|
|
|
#ifdef SIGEMT
|
|
|
|
P_SIGNUM(EMT);
|
|
|
|
#endif
|
|
|
|
#ifdef SIGSTKFLT
|
|
|
|
P_SIGNUM(STKFLT);
|
|
|
|
#endif
|
|
|
|
#ifdef SIGSWI
|
|
|
|
P_SIGNUM(SWI);
|
|
|
|
#endif
|
2013-09-04 03:17:15 +07:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return scnprintf(bf, size, "%#x", sig);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SCA_SIGNUM syscall_arg__scnprintf_signum
|
|
|
|
|
2014-02-11 00:09:48 +07:00
|
|
|
#if defined(__i386__) || defined(__x86_64__)
|
|
|
|
/*
|
|
|
|
* FIXME: Make this available to all arches.
|
|
|
|
*/
|
perf trace: Initial beautifier for ioctl's 'cmd' arg
[root@zoo linux]# trace -e ioctl | grep -v "cmd: 0x" | head -10
0.386 ( 0.001 ms): trace/1602 ioctl(fd: 1<pipe:[127057]>, cmd: TCGETS, arg: 0x7fff59fcb4d0 ) = -1 ENOTTY Inappropriate ioctl for device
1459.368 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.586 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.611 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
3740.526 ( 0.002 ms): awk/1612 ioctl(fd: 1<pipe:[128265]>, cmd: TCGETS, arg: 0x7fff4d166b90 ) = -1 ENOTTY Inappropriate ioctl for device
3740.704 ( 0.001 ms): awk/1612 ioctl(fd: 3</proc/meminfo>, cmd: TCGETS, arg: 0x7fff4d1669a0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.550 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.555 ( 0.003 ms): ps/1614 ioctl(fd: 2<socket:[19550]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.558 ( 0.002 ms): ps/1614 ioctl(cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.572 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TCGETS, arg: 0x7fff59176220 ) = -1 ENOTTY Inappropriate ioctl for device
[root@zoo linux]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-afajwap3mr60dfl4qpdl1pxn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-09 03:43:20 +07:00
|
|
|
#define TCGETS 0x5401
|
|
|
|
|
|
|
|
static const char *tioctls[] = {
|
|
|
|
"TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
|
|
|
|
"TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
|
|
|
|
"TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
|
|
|
|
"TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
|
|
|
|
"TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
|
|
|
|
"TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
|
|
|
|
"TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
|
|
|
|
"TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
|
|
|
|
"TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
|
|
|
|
"TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
|
|
|
|
"TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
|
|
|
|
[0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
|
|
|
|
"TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
|
|
|
|
"TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
|
|
|
|
"TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
|
2014-02-11 00:09:48 +07:00
|
|
|
#endif /* defined(__i386__) || defined(__x86_64__) */
|
perf trace: Initial beautifier for ioctl's 'cmd' arg
[root@zoo linux]# trace -e ioctl | grep -v "cmd: 0x" | head -10
0.386 ( 0.001 ms): trace/1602 ioctl(fd: 1<pipe:[127057]>, cmd: TCGETS, arg: 0x7fff59fcb4d0 ) = -1 ENOTTY Inappropriate ioctl for device
1459.368 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.586 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.611 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
3740.526 ( 0.002 ms): awk/1612 ioctl(fd: 1<pipe:[128265]>, cmd: TCGETS, arg: 0x7fff4d166b90 ) = -1 ENOTTY Inappropriate ioctl for device
3740.704 ( 0.001 ms): awk/1612 ioctl(fd: 3</proc/meminfo>, cmd: TCGETS, arg: 0x7fff4d1669a0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.550 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.555 ( 0.003 ms): ps/1614 ioctl(fd: 2<socket:[19550]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.558 ( 0.002 ms): ps/1614 ioctl(cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.572 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TCGETS, arg: 0x7fff59176220 ) = -1 ENOTTY Inappropriate ioctl for device
[root@zoo linux]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-afajwap3mr60dfl4qpdl1pxn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-09 03:43:20 +07:00
|
|
|
|
2013-09-20 22:13:37 +07:00
|
|
|
#define STRARRAY(arg, name, array) \
|
|
|
|
.arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
|
|
|
|
.arg_parm = { [arg] = &strarray__##array, }
|
|
|
|
|
2012-09-27 06:05:56 +07:00
|
|
|
static struct syscall_fmt {
|
|
|
|
const char *name;
|
2012-09-27 23:16:00 +07:00
|
|
|
const char *alias;
|
2013-09-03 22:20:12 +07:00
|
|
|
size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
|
2013-09-04 01:50:28 +07:00
|
|
|
void *arg_parm[6];
|
2012-09-27 06:05:56 +07:00
|
|
|
bool errmsg;
|
|
|
|
bool timeout;
|
2013-08-26 21:36:30 +07:00
|
|
|
bool hexret;
|
2012-09-27 06:05:56 +07:00
|
|
|
} syscall_fmts[] = {
|
2013-09-04 21:42:27 +07:00
|
|
|
{ .name = "access", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [1] = SCA_ACCMODE, /* mode */ }, },
|
2012-09-27 23:16:00 +07:00
|
|
|
{ .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
|
2013-08-26 22:29:38 +07:00
|
|
|
{ .name = "brk", .hexret = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
|
2013-09-23 08:45:00 +07:00
|
|
|
{ .name = "clock_gettime", .errmsg = true, STRARRAY(0, clk_id, clockid), },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "close", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
|
2013-07-31 02:38:23 +07:00
|
|
|
{ .name = "connect", .errmsg = true, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "dup", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "dup2", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "dup3", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-20 22:13:37 +07:00
|
|
|
{ .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
|
2013-09-12 22:18:56 +07:00
|
|
|
{ .name = "eventfd2", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "faccessat", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
|
|
|
|
{ .name = "fadvise64", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fallocate", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fchdir", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fchmod", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fchmodat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fchown", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fchownat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fcntl", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */
|
|
|
|
[1] = SCA_STRARRAY, /* cmd */ },
|
|
|
|
.arg_parm = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
|
|
|
|
{ .name = "fdatasync", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-20 21:49:50 +07:00
|
|
|
{ .name = "flock", .errmsg = true,
|
2013-09-24 21:04:32 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */
|
|
|
|
[1] = SCA_FLOCK, /* cmd */ }, },
|
|
|
|
{ .name = "fsetxattr", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fstat", .errmsg = true, .alias = "newfstat",
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fstatat", .errmsg = true, .alias = "newfstatat",
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fstatfs", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "fsync", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "ftruncate", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-02 23:46:44 +07:00
|
|
|
{ .name = "futex", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "futimesat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "getdents", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "getdents64", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-20 22:13:37 +07:00
|
|
|
{ .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
|
|
|
|
{ .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
|
2013-08-26 22:29:38 +07:00
|
|
|
{ .name = "ioctl", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */
|
2014-02-11 00:09:48 +07:00
|
|
|
#if defined(__i386__) || defined(__x86_64__)
|
|
|
|
/*
|
|
|
|
* FIXME: Make this available to all arches.
|
|
|
|
*/
|
perf trace: Initial beautifier for ioctl's 'cmd' arg
[root@zoo linux]# trace -e ioctl | grep -v "cmd: 0x" | head -10
0.386 ( 0.001 ms): trace/1602 ioctl(fd: 1<pipe:[127057]>, cmd: TCGETS, arg: 0x7fff59fcb4d0 ) = -1 ENOTTY Inappropriate ioctl for device
1459.368 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.586 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
1463.611 ( 0.002 ms): inotify_reader/10352 ioctl(fd: 18<anon_inode:inotify>, cmd: FIONREAD, arg: 0x7fb835228bcc ) = 0
3740.526 ( 0.002 ms): awk/1612 ioctl(fd: 1<pipe:[128265]>, cmd: TCGETS, arg: 0x7fff4d166b90 ) = -1 ENOTTY Inappropriate ioctl for device
3740.704 ( 0.001 ms): awk/1612 ioctl(fd: 3</proc/meminfo>, cmd: TCGETS, arg: 0x7fff4d1669a0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.550 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.555 ( 0.003 ms): ps/1614 ioctl(fd: 2<socket:[19550]>, cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.558 ( 0.002 ms): ps/1614 ioctl(cmd: TIOCGWINSZ, arg: 0x7fff591762b0 ) = -1 ENOTTY Inappropriate ioctl for device
3742.572 ( 0.002 ms): ps/1614 ioctl(fd: 1<pipe:[128266]>, cmd: TCGETS, arg: 0x7fff59176220 ) = -1 ENOTTY Inappropriate ioctl for device
[root@zoo linux]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-afajwap3mr60dfl4qpdl1pxn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-09 03:43:20 +07:00
|
|
|
[1] = SCA_STRHEXARRAY, /* cmd */
|
|
|
|
[2] = SCA_HEX, /* arg */ },
|
|
|
|
.arg_parm = { [1] = &strarray__tioctls, /* cmd */ }, },
|
2014-02-11 00:09:48 +07:00
|
|
|
#else
|
|
|
|
[2] = SCA_HEX, /* arg */ }, },
|
|
|
|
#endif
|
2013-09-04 03:17:15 +07:00
|
|
|
{ .name = "kill", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "linkat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "lseek", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */
|
|
|
|
[2] = SCA_STRARRAY, /* whence */ },
|
|
|
|
.arg_parm = { [2] = &strarray__whences, /* whence */ }, },
|
2013-08-26 22:21:41 +07:00
|
|
|
{ .name = "lstat", .errmsg = true, .alias = "newlstat", },
|
2013-08-23 20:06:41 +07:00
|
|
|
{ .name = "madvise", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* start */
|
|
|
|
[2] = SCA_MADV_BHV, /* behavior */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "mkdirat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "mknodat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
|
2013-09-24 10:09:38 +07:00
|
|
|
{ .name = "mlock", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
|
|
|
|
{ .name = "mlockall", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
|
2013-08-26 22:29:38 +07:00
|
|
|
{ .name = "mmap", .hexret = true,
|
perf trace: Add beautifier for mmap prot parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.984 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd62ae000
1.114 ( 0.016 ms): mmap(addr: 0, len: 125100, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xd628f000
1.252 ( 0.020 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: 2050, fd: 3, off: 0) = 0xc1600000
1.282 ( 0.024 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.315 ( 0.026 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: 2066, fd: 3, off: 1757184) = 0xc19ad000
1.352 ( 0.017 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: 50, fd: 4294967295, off: 0) = 0xc19b3000
1.415 ( 0.011 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628e000
1.440 ( 0.011 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628c000
1.569 ( 0.019 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.591 ( 0.017 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.616 ( 0.016 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
2.105 ( 0.018 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xcfe9c000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-21 03:44:42 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* addr */
|
perf trace: Add beautifier for mmap flags parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.992 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa60be000
1.108 ( 0.012 ms): mmap(addr: 0, len: 125100, prot: READ, flags: PRIVATE, fd: 3, off: 0 ) = 0xa609f000
1.209 ( 0.014 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3, off: 0) = 0xc1600000
1.232 ( 0.018 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.255 ( 0.018 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3, off: 1757184) = 0xc19ad000
1.281 ( 0.011 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: 4294967295, off: 0) = 0xc19b3000
1.328 ( 0.008 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609e000
1.346 ( 0.008 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: 4294967295, off: 0) = 0xa609c000
1.443 ( 0.013 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.459 ( 0.011 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.477 ( 0.011 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
1.855 ( 0.013 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: PRIVATE, fd: 3, off: 0) = 0x9fcac000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-23 20:48:33 +07:00
|
|
|
[2] = SCA_MMAP_PROT, /* prot */
|
2013-11-12 13:24:59 +07:00
|
|
|
[3] = SCA_MMAP_FLAGS, /* flags */
|
|
|
|
[4] = SCA_FD, /* fd */ }, },
|
2013-08-26 22:29:38 +07:00
|
|
|
{ .name = "mprotect", .errmsg = true,
|
perf trace: Add beautifier for mmap prot parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.984 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd62ae000
1.114 ( 0.016 ms): mmap(addr: 0, len: 125100, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xd628f000
1.252 ( 0.020 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: 2050, fd: 3, off: 0) = 0xc1600000
1.282 ( 0.024 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.315 ( 0.026 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: 2066, fd: 3, off: 1757184) = 0xc19ad000
1.352 ( 0.017 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: 50, fd: 4294967295, off: 0) = 0xc19b3000
1.415 ( 0.011 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628e000
1.440 ( 0.011 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628c000
1.569 ( 0.019 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.591 ( 0.017 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.616 ( 0.016 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
2.105 ( 0.018 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xcfe9c000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-21 03:44:42 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* start */
|
|
|
|
[2] = SCA_MMAP_PROT, /* prot */ }, },
|
|
|
|
{ .name = "mremap", .hexret = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* addr */
|
perf trace: Add beautifier for mremap flags param
~/devel/kernel/tools/perf(branch:master*) » sudo ./perf trace ~/mremap_test
0.543 ( 0.003 ms): mprotect(start: 0x600000, len: 4096, prot: READ ) = 0
0.550 ( 0.003 ms): mprotect(start: 0x7f441260d000, len: 4096, prot: READ) = 0
0.561 ( 0.010 ms): munmap(addr: 0x7f44125e2000, len: 165572 ) = 0
0.595 ( 0.012 ms): mmap(len: 12288, prot: READ|WRITE, flags: SHARED|ANONYMOUS|LOCKED, fd: -1) = 0x12608000
0.603 ( 0.006 ms): mremap(addr: 0x7f4412608000, old_len: 4096, new_len: 4096, flags: MAYMOVE|FIXED, new_addr: 0x7f16da295000) = 0xda295000
0.608 ( 0.003 ms): mremap(addr: 0x7f441260a000, old_len: 4096, new_len: 4096, flags: MAYMOVE|FIXED, new_addr: 0x7f16da297000) = 0xda297000
0.612 ( 0.003 ms): mremap(addr: 0x7f4412609000, old_len: 4096, new_len: 4096, flags: MAYMOVE|FIXED, new_addr: 0x7f16da296000) = 0xda296000
0.619 ( 0.000 ms): exit_group(
Signed-off-by: Alex Snast <asnast@gmail.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1407944560-26924-1-git-send-email-asnast@gmail.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-08-13 22:42:40 +07:00
|
|
|
[3] = SCA_MREMAP_FLAGS, /* flags */
|
perf trace: Add beautifier for mmap prot parm
[root@zoo ~]# perf trace -e mmap,mprotect sleep 1
0.984 ( 0.015 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd62ae000
1.114 ( 0.016 ms): mmap(addr: 0, len: 125100, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xd628f000
1.252 ( 0.020 ms): mmap(addr: 0x33c1600000, len: 3896312, prot: EXEC|READ, flags: 2050, fd: 3, off: 0) = 0xc1600000
1.282 ( 0.024 ms): mprotect(start: 0x33c17ad000, len: 2097152, prot: NONE ) = 0
1.315 ( 0.026 ms): mmap(addr: 0x33c19ad000, len: 24576, prot: READ|WRITE, flags: 2066, fd: 3, off: 1757184) = 0xc19ad000
1.352 ( 0.017 ms): mmap(addr: 0x33c19b3000, len: 17400, prot: READ|WRITE, flags: 50, fd: 4294967295, off: 0) = 0xc19b3000
1.415 ( 0.011 ms): mmap(addr: 0, len: 4096, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628e000
1.440 ( 0.011 ms): mmap(addr: 0, len: 8192, prot: READ|WRITE, flags: 34, fd: 4294967295, off: 0) = 0xd628c000
1.569 ( 0.019 ms): mprotect(start: 0x606000, len: 4096, prot: READ ) = 0
1.591 ( 0.017 ms): mprotect(start: 0x33c19ad000, len: 16384, prot: READ ) = 0
1.616 ( 0.016 ms): mprotect(start: 0x33c1420000, len: 4096, prot: READ ) = 0
2.105 ( 0.018 ms): mmap(addr: 0, len: 104789808, prot: READ, flags: 2, fd: 3, off: 0 ) = 0xcfe9c000
[root@zoo ~]#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-q1ubhdd9wigxneam616ggdsn@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-08-21 03:44:42 +07:00
|
|
|
[4] = SCA_HEX, /* new_addr */ }, },
|
2013-09-24 10:09:38 +07:00
|
|
|
{ .name = "munlock", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
|
2013-08-26 22:29:38 +07:00
|
|
|
{ .name = "munmap", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "name_to_handle_at", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "newfstatat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
|
2013-09-03 02:22:31 +07:00
|
|
|
{ .name = "open", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
|
2013-09-03 02:40:40 +07:00
|
|
|
{ .name = "open_by_handle_at", .errmsg = true,
|
2013-09-24 21:04:32 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
|
|
|
|
[2] = SCA_OPEN_FLAGS, /* flags */ }, },
|
2013-09-03 02:40:40 +07:00
|
|
|
{ .name = "openat", .errmsg = true,
|
2013-09-24 21:04:32 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
|
|
|
|
[2] = SCA_OPEN_FLAGS, /* flags */ }, },
|
2013-09-23 22:52:04 +07:00
|
|
|
{ .name = "pipe2", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
|
2012-09-27 23:16:00 +07:00
|
|
|
{ .name = "poll", .errmsg = true, .timeout = true, },
|
|
|
|
{ .name = "ppoll", .errmsg = true, .timeout = true, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "pread", .errmsg = true, .alias = "pread64",
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "preadv", .errmsg = true, .alias = "pread",
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-20 22:13:37 +07:00
|
|
|
{ .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "pwrite", .errmsg = true, .alias = "pwrite64",
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "pwritev", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "read", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "readlinkat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "readv", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
perf trace: Beautify send/recv syscall 'flags' arg
[root@sandy ~]# perf trace -a -e recvmmsg,recvmsg,recvfrom,sendto,sendmsg,sendmmsg
6.901 (0.002 ms): 589 recvmsg(fd: 51, msg: 0x7fff35673420, flags: CMSG_CLOEXEC) = -1 EAGAIN Resource temporarily unavailable
6.966 (0.008 ms): 589 sendmsg(fd: 50, msg: 0x7fff35673230, flags: NOSIGNAL ) = 961
6.984 (0.004 ms): 979 sendmsg(fd: 3, msg: 0x7fff5b484940, flags: NOSIGNAL ) = 945
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-h25k5k50nac0ej5cl5iwgvae@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 21:54:48 +07:00
|
|
|
{ .name = "recvfrom", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
|
|
|
|
{ .name = "recvmmsg", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
|
|
|
|
{ .name = "recvmsg", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "renameat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
|
2013-09-04 03:17:15 +07:00
|
|
|
{ .name = "rt_sigaction", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
|
2013-09-20 22:13:37 +07:00
|
|
|
{ .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
|
2013-09-04 03:17:15 +07:00
|
|
|
{ .name = "rt_sigqueueinfo", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
|
|
|
|
{ .name = "rt_tgsigqueueinfo", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
|
2012-09-27 23:16:00 +07:00
|
|
|
{ .name = "select", .errmsg = true, .timeout = true, },
|
perf trace: Beautify send/recv syscall 'flags' arg
[root@sandy ~]# perf trace -a -e recvmmsg,recvmsg,recvfrom,sendto,sendmsg,sendmmsg
6.901 (0.002 ms): 589 recvmsg(fd: 51, msg: 0x7fff35673420, flags: CMSG_CLOEXEC) = -1 EAGAIN Resource temporarily unavailable
6.966 (0.008 ms): 589 sendmsg(fd: 50, msg: 0x7fff35673230, flags: NOSIGNAL ) = 961
6.984 (0.004 ms): 979 sendmsg(fd: 3, msg: 0x7fff5b484940, flags: NOSIGNAL ) = 945
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-h25k5k50nac0ej5cl5iwgvae@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 21:54:48 +07:00
|
|
|
{ .name = "sendmmsg", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
|
|
|
|
{ .name = "sendmsg", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
|
|
|
|
{ .name = "sendto", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
|
2013-09-20 22:13:37 +07:00
|
|
|
{ .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
|
|
|
|
{ .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "shutdown", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-04 20:27:41 +07:00
|
|
|
{ .name = "socket", .errmsg = true,
|
2013-09-04 21:00:44 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
|
|
|
|
[1] = SCA_SK_TYPE, /* type */ },
|
2013-09-20 22:24:20 +07:00
|
|
|
.arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
|
|
|
|
{ .name = "socketpair", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
|
|
|
|
[1] = SCA_SK_TYPE, /* type */ },
|
2013-09-04 20:27:41 +07:00
|
|
|
.arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
|
2012-09-27 23:16:00 +07:00
|
|
|
{ .name = "stat", .errmsg = true, .alias = "newstat", },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "symlinkat", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
|
2013-09-04 03:17:15 +07:00
|
|
|
{ .name = "tgkill", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
|
|
|
|
{ .name = "tkill", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
|
2013-08-26 22:21:41 +07:00
|
|
|
{ .name = "uname", .errmsg = true, .alias = "newuname", },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "unlinkat", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
|
|
|
|
{ .name = "utimensat", .errmsg = true,
|
|
|
|
.arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */ }, },
|
|
|
|
{ .name = "write", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2013-09-24 21:04:32 +07:00
|
|
|
{ .name = "writev", .errmsg = true,
|
2014-12-18 03:24:45 +07:00
|
|
|
.arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
|
2012-09-27 06:05:56 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int syscall_fmt__cmp(const void *name, const void *fmtp)
|
|
|
|
{
|
|
|
|
const struct syscall_fmt *fmt = fmtp;
|
|
|
|
return strcmp(name, fmt->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct syscall_fmt *syscall_fmt__find(const char *name)
|
|
|
|
{
|
|
|
|
const int nmemb = ARRAY_SIZE(syscall_fmts);
|
|
|
|
return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct syscall {
|
|
|
|
struct event_format *tp_format;
|
2015-03-21 03:46:53 +07:00
|
|
|
int nr_args;
|
|
|
|
struct format_field *args;
|
2012-09-27 06:05:56 +07:00
|
|
|
const char *name;
|
2013-08-09 22:28:31 +07:00
|
|
|
bool filtered;
|
2014-06-18 00:29:24 +07:00
|
|
|
bool is_exit;
|
2012-09-27 06:05:56 +07:00
|
|
|
struct syscall_fmt *fmt;
|
2013-09-03 22:20:12 +07:00
|
|
|
size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
|
2013-09-04 01:50:28 +07:00
|
|
|
void **arg_parm;
|
2012-09-27 06:05:56 +07:00
|
|
|
};
|
|
|
|
|
perf trace: Add an event duration column
# perf trace usleep 1 | tail -10
0.453 ( 0.002 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763342848
0.456 ( 0.001 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763346944
0.459 ( 0.001 ms): arch_prctl(option: 4098, arg2: 140126839658240, arg3: 140126839652352, arg4: 34, arg5: 4294967295) = 0
0.473 ( 0.003 ms): mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
0.477 ( 0.003 ms): mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
0.483 ( 0.004 ms): munmap(addr: 140126839664640, len: 91882 ) = 0
0.540 ( 0.001 ms): brk(brk: 0 ) = 31928320
0.542 ( 0.002 ms): brk(brk: 32063488 ) = 32063488
1.456 ( 0.901 ms): nanosleep(rqtp: 140735472817168, rmtp: 0 ) = 0
1.462 ( 0.000 ms): exit_group(error_code: 0
#
This also comes from the tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-g9akh5hjw2kvjerpo9xror6f@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-25 02:24:47 +07:00
|
|
|
static size_t fprintf_duration(unsigned long t, FILE *fp)
|
|
|
|
{
|
|
|
|
double duration = (double)t / NSEC_PER_MSEC;
|
|
|
|
size_t printed = fprintf(fp, "(");
|
|
|
|
|
|
|
|
if (duration >= 1.0)
|
|
|
|
printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
|
|
|
|
else if (duration >= 0.01)
|
|
|
|
printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
|
|
|
|
else
|
|
|
|
printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
|
2013-08-19 22:01:10 +07:00
|
|
|
return printed + fprintf(fp, "): ");
|
perf trace: Add an event duration column
# perf trace usleep 1 | tail -10
0.453 ( 0.002 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763342848
0.456 ( 0.001 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763346944
0.459 ( 0.001 ms): arch_prctl(option: 4098, arg2: 140126839658240, arg3: 140126839652352, arg4: 34, arg5: 4294967295) = 0
0.473 ( 0.003 ms): mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
0.477 ( 0.003 ms): mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
0.483 ( 0.004 ms): munmap(addr: 140126839664640, len: 91882 ) = 0
0.540 ( 0.001 ms): brk(brk: 0 ) = 31928320
0.542 ( 0.002 ms): brk(brk: 32063488 ) = 32063488
1.456 ( 0.901 ms): nanosleep(rqtp: 140735472817168, rmtp: 0 ) = 0
1.462 ( 0.000 ms): exit_group(error_code: 0
#
This also comes from the tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-g9akh5hjw2kvjerpo9xror6f@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-25 02:24:47 +07:00
|
|
|
}
|
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
struct thread_trace {
|
|
|
|
u64 entry_time;
|
|
|
|
u64 exit_time;
|
|
|
|
bool entry_pending;
|
2012-10-18 03:09:46 +07:00
|
|
|
unsigned long nr_events;
|
2014-07-09 01:05:16 +07:00
|
|
|
unsigned long pfmaj, pfmin;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
char *entry_str;
|
2012-10-18 03:13:12 +07:00
|
|
|
double runtime_ms;
|
2013-09-24 21:04:32 +07:00
|
|
|
struct {
|
|
|
|
int max;
|
|
|
|
char **table;
|
|
|
|
} paths;
|
2013-10-09 10:26:53 +07:00
|
|
|
|
|
|
|
struct intlist *syscall_stats;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct thread_trace *thread_trace__new(void)
|
|
|
|
{
|
2013-09-24 21:04:32 +07:00
|
|
|
struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
|
|
|
|
|
|
|
|
if (ttrace)
|
|
|
|
ttrace->paths.max = -1;
|
|
|
|
|
2013-10-09 10:26:53 +07:00
|
|
|
ttrace->syscall_stats = intlist__new(NULL);
|
|
|
|
|
2013-09-24 21:04:32 +07:00
|
|
|
return ttrace;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
}
|
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
{
|
2012-10-18 03:09:46 +07:00
|
|
|
struct thread_trace *ttrace;
|
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
if (thread == NULL)
|
|
|
|
goto fail;
|
|
|
|
|
2014-10-06 07:46:03 +07:00
|
|
|
if (thread__priv(thread) == NULL)
|
|
|
|
thread__set_priv(thread, thread_trace__new());
|
2014-12-18 03:24:45 +07:00
|
|
|
|
2014-10-06 07:46:03 +07:00
|
|
|
if (thread__priv(thread) == NULL)
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
goto fail;
|
|
|
|
|
2014-10-06 07:46:03 +07:00
|
|
|
ttrace = thread__priv(thread);
|
2012-10-18 03:09:46 +07:00
|
|
|
++ttrace->nr_events;
|
|
|
|
|
|
|
|
return ttrace;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
fail:
|
2013-08-19 22:01:10 +07:00
|
|
|
color_fprintf(fp, PERF_COLOR_RED,
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
"WARNING: not enough memory, dropping samples!\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-06-26 23:14:25 +07:00
|
|
|
#define TRACE_PFMAJ (1 << 0)
|
|
|
|
#define TRACE_PFMIN (1 << 1)
|
|
|
|
|
2012-09-27 06:05:56 +07:00
|
|
|
struct trace {
|
2013-08-19 22:01:10 +07:00
|
|
|
struct perf_tool tool;
|
2013-09-28 04:06:19 +07:00
|
|
|
struct {
|
|
|
|
int machine;
|
|
|
|
int open_id;
|
|
|
|
} audit;
|
2012-09-27 06:05:56 +07:00
|
|
|
struct {
|
|
|
|
int max;
|
|
|
|
struct syscall *table;
|
|
|
|
} syscalls;
|
2013-12-20 00:43:45 +07:00
|
|
|
struct record_opts opts;
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
struct perf_evlist *evlist;
|
2013-09-29 02:13:00 +07:00
|
|
|
struct machine *host;
|
perf trace: Handle multiple threads better wrt syscalls being intermixed
$ trace time taskset -c 0 usleep 1
0.845 ( 0.021 ms): time/16722 wait4(upid: 4294967295, stat_addr: 0x7fff17f443d4, ru: 0x7fff17f44438 ) ...
0.865 ( 0.008 ms): time/16723 execve(arg0: 140733595272004, arg1: 140733595272720, arg2: 140733595272768, arg3: 139755107218496, arg4: 7307199665339051828, arg5: 3) = -2
2.395 ( 1.523 ms): taskset/16723 execve(arg0: 140733595272013, arg1: 140733595272720, arg2: 140733595272768, arg3: 139755107218496, arg4: 7307199665339051828, arg5: 3) = 0
2.411 ( 0.002 ms): taskset/16723 brk( ) = 0x1915000
3.300 ( 0.058 ms): usleep/16723 nanosleep(rqtp: 0x7ffff4ada190 ) = 0
<SNIP>
3.305 ( 0.000 ms): usleep/16723 exit_group(
3.363 ( 2.539 ms): time/16722 ... [continued]: wait4()) = 16723
3.366 ( 0.001 ms): time/16722 rt_sigaction(sig: INT, act: 0x7fff17f44160, oact: 0x7fff17f44200, sigsetsize: 8) = 0
We we're not seeing this line:
0.845 ( 0.021 ms): time/16722 wait4(upid: 4294967295, stat_addr: 0x7fff17f443d4, ru: 0x7fff17f44438 ) ...
just the one when it finishes:
3.363 ( 2.539 ms): time/16722 ... [continued]: wait4()) = 16723
Still some issues left till we move to ordered_samples when multiple
CPUs/threads are involved...
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-zq9x30a1ky3djqewqn2v3ja3@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-13 23:22:21 +07:00
|
|
|
struct thread *current;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
u64 base_time;
|
2013-08-19 22:01:10 +07:00
|
|
|
FILE *output;
|
2012-10-18 03:09:46 +07:00
|
|
|
unsigned long nr_events;
|
2013-08-21 22:56:21 +07:00
|
|
|
struct strlist *ev_qualifier;
|
2013-09-28 04:06:19 +07:00
|
|
|
const char *last_vfs_getname;
|
2013-08-29 11:29:53 +07:00
|
|
|
struct intlist *tid_list;
|
|
|
|
struct intlist *pid_list;
|
perf trace: Introduce --filter-pids
When tracing in X we get event loops due to the tracing activity, i.e.
updates to a gnome-terminal that generate syscalls for X.org, etc.
To get a more useful view of what is happening, syscall wise, system
wide, we need to filter those, like in:
# ps ax|egrep '981|2296|1519' | grep -v egrep
981 tty1 Ss+ 5:40 /usr/bin/Xorg :0 -background none ...
1519 ? Sl 2:22 /usr/bin/gnome-shell
2296 ? Sl 4:16 /usr/libexec/gnome-terminal-server
#
# trace -e write --filter-pids 981,2296,1519
0.385 ( 0.021 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 136) = 136
0.922 ( 0.014 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 140) = 140
5006.525 ( 0.029 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 136) = 136
5007.235 ( 0.023 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 140) = 140
5177.646 ( 0.018 ms): rtkit-daemon/782 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7f7eea70be88, count: 8) = 8
8314.497 ( 0.004 ms): gsd-locate-poi/2084 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7fffe96af7b0, count: 8) = 8
8314.518 ( 0.002 ms): gsd-locate-poi/2084 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7fffe96af0e0, count: 8) = 8
^C#
When this option is used the tracer pid is also filtered.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-f5qmiyy7c0uxdm21ncatpeek@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-22 02:36:52 +07:00
|
|
|
struct {
|
|
|
|
size_t nr;
|
|
|
|
pid_t *entries;
|
|
|
|
} filter_pids;
|
2014-01-07 01:43:02 +07:00
|
|
|
double duration_filter;
|
|
|
|
double runtime_ms;
|
|
|
|
struct {
|
|
|
|
u64 vfs_getname,
|
|
|
|
proc_getname;
|
|
|
|
} stats;
|
|
|
|
bool not_ev_qualifier;
|
|
|
|
bool live;
|
|
|
|
bool full_time;
|
2012-10-18 03:13:12 +07:00
|
|
|
bool sched;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
bool multiple_threads;
|
2013-10-09 10:26:53 +07:00
|
|
|
bool summary;
|
2013-11-12 23:31:15 +07:00
|
|
|
bool summary_only;
|
perf trace: Add option to show process COMM
Enabled by default, disable with --no-comm, e.g.:
181.821 (0.001 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: PEEK|TRUNC|CMSG_CLOEXEC ) = 20
181.824 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.825 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.834 (0.002 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: CMSG_CLOEXEC ) = 20
181.836 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.838 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.705 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 1256
181.710 (0.002 ms): evolution-addr/10924 geteuid( ) = 1000
181.712 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.727 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 1256
181.731 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.734 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.908 (0.002 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 20
181.913 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.915 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.930 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 20
181.934 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.937 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
220.718 (0.010 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.741 (0.000 ms): dbus-daemon/10711 ... [continued]: epoll_wait()) = 1
220.759 (0.004 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.780 (0.002 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.788 (0.001 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = -1 EAGAIN Resource temporarily unavailable
220.760 (0.004 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.771 (0.023 ms): perf/26347 open(filename: 0xf2e780, mode: 15918976 ) = 19
220.850 (0.002 ms): perf/26347 close(fd: 19 ) = 0
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-6be5jvnkdzjptdrebfn5263n@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 22:35:21 +07:00
|
|
|
bool show_comm;
|
2013-09-28 04:06:19 +07:00
|
|
|
bool show_tool_stats;
|
2014-06-26 23:14:28 +07:00
|
|
|
bool trace_syscalls;
|
perf trace: Support using -f to override perf.data file ownership
Enable perf trace to use perf.data when it is not owned by current user
or root.
Example:
# perf trace record ls
# chown Yunlong.Song:Yunlong.Song perf.data
# ls -al perf.data
-rw------- 1 Yunlong.Song Yunlong.Song 4153101 Apr 2 15:28 perf.data
# id
uid=0(root) gid=0(root) groups=0(root),64(pkcs11)
Before this patch:
# perf trace -i perf.data
File perf.data not owned by current user or root (use -f to override)
# perf trace -i perf.data -f
Error: unknown switch `f'
usage: perf trace [<options>] [<command>]
or: perf trace [<options>] -- <command> [<options>]
or: perf trace record [<options>] [<command>]
or: perf trace record [<options>] -- <command> [<options>]
--event <event> event selector. use 'perf list' to list
available events
--comm show the thread COMM next to its id
--tool_stats show tool stats
-e, --expr <expr> list of events to trace
-o, --output <file> output file name
-i, --input <file> Analyze events in file
-p, --pid <pid> trace events on existing process id
-t, --tid <tid> trace events on existing thread id
--filter-pids <float>
...
As shown above, the -f option does not work at all.
After this patch:
# perf trace -i perf.data
File perf.data not owned by current user or root (use -f to override)
# perf trace -i perf.data -f
0.056 ( 0.002 ms): ls/47325 brk( ...
0.108 ( 0.018 ms): ls/47325 mmap(len: 4096, prot: READ|WRITE, ...
0.145 ( 0.013 ms): ls/47325 access(filename: 0x7f31259a0eb0, ...
0.172 ( 0.008 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.180 ( 0.004 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.185 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.189 ( 0.003 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.195 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.199 ( 0.002 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.205 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.211 ( 0.004 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.220 ( 0.007 ms): ls/47325 open(filename: 0x7f312599e8ff, ...
...
...
As shown above, the -f option really works now.
Signed-off-by: Yunlong Song <yunlong.song@huawei.com>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1427982439-27388-10-git-send-email-yunlong.song@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-02 20:47:18 +07:00
|
|
|
bool force;
|
2014-06-26 23:14:25 +07:00
|
|
|
int trace_pgfaults;
|
2012-09-27 06:05:56 +07:00
|
|
|
};
|
|
|
|
|
2013-09-28 03:34:10 +07:00
|
|
|
static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
|
2013-09-24 21:04:32 +07:00
|
|
|
{
|
2014-10-06 07:46:03 +07:00
|
|
|
struct thread_trace *ttrace = thread__priv(thread);
|
2013-09-24 21:04:32 +07:00
|
|
|
|
|
|
|
if (fd > ttrace->paths.max) {
|
|
|
|
char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
|
|
|
|
|
|
|
|
if (npath == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (ttrace->paths.max != -1) {
|
|
|
|
memset(npath + ttrace->paths.max + 1, 0,
|
|
|
|
(fd - ttrace->paths.max) * sizeof(char *));
|
|
|
|
} else {
|
|
|
|
memset(npath, 0, (fd + 1) * sizeof(char *));
|
|
|
|
}
|
|
|
|
|
|
|
|
ttrace->paths.table = npath;
|
|
|
|
ttrace->paths.max = fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
ttrace->paths.table[fd] = strdup(pathname);
|
|
|
|
|
|
|
|
return ttrace->paths.table[fd] != NULL ? 0 : -1;
|
|
|
|
}
|
|
|
|
|
2013-09-28 03:34:10 +07:00
|
|
|
static int thread__read_fd_path(struct thread *thread, int fd)
|
|
|
|
{
|
|
|
|
char linkname[PATH_MAX], pathname[PATH_MAX];
|
|
|
|
struct stat st;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (thread->pid_ == thread->tid) {
|
|
|
|
scnprintf(linkname, sizeof(linkname),
|
|
|
|
"/proc/%d/fd/%d", thread->pid_, fd);
|
|
|
|
} else {
|
|
|
|
scnprintf(linkname, sizeof(linkname),
|
|
|
|
"/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = readlink(linkname, pathname, sizeof(pathname));
|
|
|
|
|
|
|
|
if (ret < 0 || ret > st.st_size)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
pathname[ret] = '\0';
|
|
|
|
return trace__set_fd_pathname(thread, fd, pathname);
|
|
|
|
}
|
|
|
|
|
2013-09-28 04:06:19 +07:00
|
|
|
static const char *thread__fd_path(struct thread *thread, int fd,
|
|
|
|
struct trace *trace)
|
2013-09-24 21:04:32 +07:00
|
|
|
{
|
2014-10-06 07:46:03 +07:00
|
|
|
struct thread_trace *ttrace = thread__priv(thread);
|
2013-09-24 21:04:32 +07:00
|
|
|
|
|
|
|
if (ttrace == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (fd < 0)
|
|
|
|
return NULL;
|
|
|
|
|
perf trace: Fix up fd -> pathname resolution
There was a brown paper bag bug in the patch that introduced a reference
implementation on using 'perf probe' made wannabe tracepoints that broke fd ->
pathname resolution, fix it:
[root@zoo ~]# perf probe 'vfs_getname=getname_flags:65 pathname=result->name:string'
Added new event:
probe:vfs_getname (on getname_flags:65 with pathname=result->name:string)
You can now use it in all perf tools, such as:
perf record -e probe:vfs_getname -aR sleep 1
[root@zoo ~]
Before:
[acme@zoo linux]$ trace touch -e open,fstat /tmp/b
1.159 ( 0.007 ms): open(filename: 0x7fd73f2fe088, flags: CLOEXEC ) = 3
1.163 ( 0.002 ms): fstat(fd: 3, statbuf: 0x7fff1b25e610 ) = 0
1.192 ( 0.009 ms): open(filename: 0x7fd73f4fedb8, flags: CLOEXEC ) = 3
1.201 ( 0.002 ms): fstat(fd: 3, statbuf: 0x7fff1b25e660 ) = 0
1.501 ( 0.013 ms): open(filename: 0x7fd73f0a1610, flags: CLOEXEC ) = 3
1.505 ( 0.002 ms): fstat(fd: 3, statbuf: 0x7fd73f2ddb60 ) = 0
1.581 ( 0.011 ms): open(filename: 0x7fff1b2603da, flags: CREAT|NOCTTY|NONBLOCK|WRONLY, mode: 438) = 3
[acme@zoo linux]$
After:
[acme@zoo linux]$ trace touch -e open,fstat,dup2,mmap,close /tmp/b
1.105 ( 0.004 ms): mmap(len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: -1 ) = 0x2fbf000
1.136 ( 0.008 ms): open(filename: 0x7f8902dbc088, flags: CLOEXEC ) = 3
1.140 ( 0.002 ms): fstat(fd: 3</etc/ld.so.cache>, statbuf: 0x7fff19889ef0 ) = 0
1.146 ( 0.004 ms): mmap(len: 86079, prot: READ, flags: PRIVATE, fd: 3</etc/ld.so.cache> ) = 0x2fa9000
1.149 ( 0.001 ms): close(fd: 3</etc/ld.so.cache> ) = 0
1.170 ( 0.010 ms): open(filename: 0x7f8902fbcdb8, flags: CLOEXEC ) = 3
1.178 ( 0.002 ms): fstat(fd: 3</lib64/libc.so.6>, statbuf: 0x7fff19889f40 ) = 0
1.188 ( 0.006 ms): mmap(len: 3924576, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3</lib64/libc.so.6>) = 0x29e2000
1.207 ( 0.007 ms): mmap(addr: 0x7f8902d96000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3</lib64/libc.so.6>, off: 1785856) = 0x2d96000
1.217 ( 0.004 ms): mmap(addr: 0x7f8902d9c000, len: 16992, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: -1) = 0x2d9c000
1.228 ( 0.002 ms): close(fd: 3</lib64/libc.so.6> ) = 0
1.243 ( 0.003 ms): mmap(len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: -1 ) = 0x2fa8000
1.250 ( 0.003 ms): mmap(len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: -1 ) = 0x2fa6000
1.452 ( 0.010 ms): open(filename: 0x7f8902b5f610, flags: CLOEXEC ) = 3
1.455 ( 0.002 ms): fstat(fd: 3</usr/lib/locale/locale-archive>, statbuf: 0x7f8902d9bb60 ) = 0
1.461 ( 0.004 ms): mmap(len: 106070960, prot: READ, flags: PRIVATE, fd: 3</usr/lib/locale/locale-archive>) = 0xfc4b9000
1.469 ( 0.002 ms): close(fd: 3</usr/lib/locale/locale-archive> ) = 0
1.528 ( 0.010 ms): open(filename: 0x7fff1988c3da, flags: CREAT|NOCTTY|NONBLOCK|WRONLY, mode: 438) = 3
1.532 ( 0.002 ms): dup2(oldfd: 3</tmp/b> ) = 0
1.535 ( 0.001 ms): close(fd: 3</tmp/b> ) = 0
1.544 ( 0.001 ms): close( ) = 0
1.555 ( 0.001 ms): close(fd: 1 ) = 0
1.558 ( 0.001 ms): close(fd: 2 ) = 0
[acme@zoo linux]$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-vcm22xpjxc3j4hbyuzjzf7ik@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-06-11 02:00:18 +07:00
|
|
|
if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
|
2013-09-28 04:06:19 +07:00
|
|
|
if (!trace->live)
|
|
|
|
return NULL;
|
|
|
|
++trace->stats.proc_getname;
|
perf trace: Fix up fd -> pathname resolution
There was a brown paper bag bug in the patch that introduced a reference
implementation on using 'perf probe' made wannabe tracepoints that broke fd ->
pathname resolution, fix it:
[root@zoo ~]# perf probe 'vfs_getname=getname_flags:65 pathname=result->name:string'
Added new event:
probe:vfs_getname (on getname_flags:65 with pathname=result->name:string)
You can now use it in all perf tools, such as:
perf record -e probe:vfs_getname -aR sleep 1
[root@zoo ~]
Before:
[acme@zoo linux]$ trace touch -e open,fstat /tmp/b
1.159 ( 0.007 ms): open(filename: 0x7fd73f2fe088, flags: CLOEXEC ) = 3
1.163 ( 0.002 ms): fstat(fd: 3, statbuf: 0x7fff1b25e610 ) = 0
1.192 ( 0.009 ms): open(filename: 0x7fd73f4fedb8, flags: CLOEXEC ) = 3
1.201 ( 0.002 ms): fstat(fd: 3, statbuf: 0x7fff1b25e660 ) = 0
1.501 ( 0.013 ms): open(filename: 0x7fd73f0a1610, flags: CLOEXEC ) = 3
1.505 ( 0.002 ms): fstat(fd: 3, statbuf: 0x7fd73f2ddb60 ) = 0
1.581 ( 0.011 ms): open(filename: 0x7fff1b2603da, flags: CREAT|NOCTTY|NONBLOCK|WRONLY, mode: 438) = 3
[acme@zoo linux]$
After:
[acme@zoo linux]$ trace touch -e open,fstat,dup2,mmap,close /tmp/b
1.105 ( 0.004 ms): mmap(len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: -1 ) = 0x2fbf000
1.136 ( 0.008 ms): open(filename: 0x7f8902dbc088, flags: CLOEXEC ) = 3
1.140 ( 0.002 ms): fstat(fd: 3</etc/ld.so.cache>, statbuf: 0x7fff19889ef0 ) = 0
1.146 ( 0.004 ms): mmap(len: 86079, prot: READ, flags: PRIVATE, fd: 3</etc/ld.so.cache> ) = 0x2fa9000
1.149 ( 0.001 ms): close(fd: 3</etc/ld.so.cache> ) = 0
1.170 ( 0.010 ms): open(filename: 0x7f8902fbcdb8, flags: CLOEXEC ) = 3
1.178 ( 0.002 ms): fstat(fd: 3</lib64/libc.so.6>, statbuf: 0x7fff19889f40 ) = 0
1.188 ( 0.006 ms): mmap(len: 3924576, prot: EXEC|READ, flags: PRIVATE|DENYWRITE, fd: 3</lib64/libc.so.6>) = 0x29e2000
1.207 ( 0.007 ms): mmap(addr: 0x7f8902d96000, len: 24576, prot: READ|WRITE, flags: PRIVATE|DENYWRITE|FIXED, fd: 3</lib64/libc.so.6>, off: 1785856) = 0x2d96000
1.217 ( 0.004 ms): mmap(addr: 0x7f8902d9c000, len: 16992, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS|FIXED, fd: -1) = 0x2d9c000
1.228 ( 0.002 ms): close(fd: 3</lib64/libc.so.6> ) = 0
1.243 ( 0.003 ms): mmap(len: 4096, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: -1 ) = 0x2fa8000
1.250 ( 0.003 ms): mmap(len: 8192, prot: READ|WRITE, flags: PRIVATE|ANONYMOUS, fd: -1 ) = 0x2fa6000
1.452 ( 0.010 ms): open(filename: 0x7f8902b5f610, flags: CLOEXEC ) = 3
1.455 ( 0.002 ms): fstat(fd: 3</usr/lib/locale/locale-archive>, statbuf: 0x7f8902d9bb60 ) = 0
1.461 ( 0.004 ms): mmap(len: 106070960, prot: READ, flags: PRIVATE, fd: 3</usr/lib/locale/locale-archive>) = 0xfc4b9000
1.469 ( 0.002 ms): close(fd: 3</usr/lib/locale/locale-archive> ) = 0
1.528 ( 0.010 ms): open(filename: 0x7fff1988c3da, flags: CREAT|NOCTTY|NONBLOCK|WRONLY, mode: 438) = 3
1.532 ( 0.002 ms): dup2(oldfd: 3</tmp/b> ) = 0
1.535 ( 0.001 ms): close(fd: 3</tmp/b> ) = 0
1.544 ( 0.001 ms): close( ) = 0
1.555 ( 0.001 ms): close(fd: 1 ) = 0
1.558 ( 0.001 ms): close(fd: 2 ) = 0
[acme@zoo linux]$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-vcm22xpjxc3j4hbyuzjzf7ik@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-06-11 02:00:18 +07:00
|
|
|
if (thread__read_fd_path(thread, fd))
|
2013-09-28 04:06:19 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
2013-09-24 21:04:32 +07:00
|
|
|
|
|
|
|
return ttrace->paths.table[fd];
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int fd = arg->val;
|
|
|
|
size_t printed = scnprintf(bf, size, "%d", fd);
|
2013-09-28 04:06:19 +07:00
|
|
|
const char *path = thread__fd_path(arg->thread, fd, arg->trace);
|
2013-09-24 21:04:32 +07:00
|
|
|
|
|
|
|
if (path)
|
|
|
|
printed += scnprintf(bf + printed, size - printed, "<%s>", path);
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
|
|
|
|
struct syscall_arg *arg)
|
|
|
|
{
|
|
|
|
int fd = arg->val;
|
|
|
|
size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
|
2014-10-06 07:46:03 +07:00
|
|
|
struct thread_trace *ttrace = thread__priv(arg->thread);
|
2013-09-24 21:04:32 +07:00
|
|
|
|
2013-12-27 03:41:15 +07:00
|
|
|
if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
|
|
|
|
zfree(&ttrace->paths.table[fd]);
|
2013-09-24 21:04:32 +07:00
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
perf trace: Add duration filter
Example:
[acme@sandy linux]$ perf trace --duration 0.025 usleep 1
2.221 ( 0.958 ms): 6724 execve(arg0: 140733557168278, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = -2
3.690 ( 1.443 ms): 6724 execve(arg0: 140733557168295, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = 0
3.979 ( 0.048 ms): 6724 open(filename: 208733843841, flags: 0, mode: 1 ) = 3
4.071 ( 0.075 ms): 6724 open(filename: 139744419925673, flags: 0, mode: 0 ) = 3
4.318 ( 0.056 ms): 6724 nanosleep(rqtp: 140734030404608, rmtp: 0 ) = 0
[acme@sandy linux]$ perf trace --duration 0.100 usleep 1
1.143 ( 1.021 ms): 6726 execve(arg0: 140736323962279, arg1: 140736323972752, arg2: 34926752, arg3: 140736323961824, arg4: 7955998171588342573, arg5: 6725) = 0
[acme@sandy linux]$
Cherry picked from tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-oslw2j2958we9qf0ctra4whd@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-08 19:56:00 +07:00
|
|
|
static bool trace__filter_duration(struct trace *trace, double t)
|
|
|
|
{
|
|
|
|
return t < (trace->duration_filter * NSEC_PER_MSEC);
|
|
|
|
}
|
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
|
|
|
|
{
|
|
|
|
double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
|
|
|
|
|
perf trace: Add an event duration column
# perf trace usleep 1 | tail -10
0.453 ( 0.002 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763342848
0.456 ( 0.001 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763346944
0.459 ( 0.001 ms): arch_prctl(option: 4098, arg2: 140126839658240, arg3: 140126839652352, arg4: 34, arg5: 4294967295) = 0
0.473 ( 0.003 ms): mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
0.477 ( 0.003 ms): mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
0.483 ( 0.004 ms): munmap(addr: 140126839664640, len: 91882 ) = 0
0.540 ( 0.001 ms): brk(brk: 0 ) = 31928320
0.542 ( 0.002 ms): brk(brk: 32063488 ) = 32063488
1.456 ( 0.901 ms): nanosleep(rqtp: 140735472817168, rmtp: 0 ) = 0
1.462 ( 0.000 ms): exit_group(error_code: 0
#
This also comes from the tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-g9akh5hjw2kvjerpo9xror6f@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-25 02:24:47 +07:00
|
|
|
return fprintf(fp, "%10.3f ", ts);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
}
|
|
|
|
|
2012-10-05 12:02:16 +07:00
|
|
|
static bool done = false;
|
2013-10-16 21:57:33 +07:00
|
|
|
static bool interrupted = false;
|
2012-10-05 12:02:16 +07:00
|
|
|
|
2013-10-16 21:57:33 +07:00
|
|
|
static void sig_handler(int sig)
|
2012-10-05 12:02:16 +07:00
|
|
|
{
|
|
|
|
done = true;
|
2013-10-16 21:57:33 +07:00
|
|
|
interrupted = sig == SIGINT;
|
2012-10-05 12:02:16 +07:00
|
|
|
}
|
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
|
perf trace: Add an event duration column
# perf trace usleep 1 | tail -10
0.453 ( 0.002 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763342848
0.456 ( 0.001 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763346944
0.459 ( 0.001 ms): arch_prctl(option: 4098, arg2: 140126839658240, arg3: 140126839652352, arg4: 34, arg5: 4294967295) = 0
0.473 ( 0.003 ms): mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
0.477 ( 0.003 ms): mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
0.483 ( 0.004 ms): munmap(addr: 140126839664640, len: 91882 ) = 0
0.540 ( 0.001 ms): brk(brk: 0 ) = 31928320
0.542 ( 0.002 ms): brk(brk: 32063488 ) = 32063488
1.456 ( 0.901 ms): nanosleep(rqtp: 140735472817168, rmtp: 0 ) = 0
1.462 ( 0.000 ms): exit_group(error_code: 0
#
This also comes from the tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-g9akh5hjw2kvjerpo9xror6f@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-25 02:24:47 +07:00
|
|
|
u64 duration, u64 tstamp, FILE *fp)
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
{
|
|
|
|
size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
|
perf trace: Add an event duration column
# perf trace usleep 1 | tail -10
0.453 ( 0.002 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763342848
0.456 ( 0.001 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763346944
0.459 ( 0.001 ms): arch_prctl(option: 4098, arg2: 140126839658240, arg3: 140126839652352, arg4: 34, arg5: 4294967295) = 0
0.473 ( 0.003 ms): mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
0.477 ( 0.003 ms): mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
0.483 ( 0.004 ms): munmap(addr: 140126839664640, len: 91882 ) = 0
0.540 ( 0.001 ms): brk(brk: 0 ) = 31928320
0.542 ( 0.002 ms): brk(brk: 32063488 ) = 32063488
1.456 ( 0.901 ms): nanosleep(rqtp: 140735472817168, rmtp: 0 ) = 0
1.462 ( 0.000 ms): exit_group(error_code: 0
#
This also comes from the tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-g9akh5hjw2kvjerpo9xror6f@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-25 02:24:47 +07:00
|
|
|
printed += fprintf_duration(duration, fp);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
|
perf trace: Add option to show process COMM
Enabled by default, disable with --no-comm, e.g.:
181.821 (0.001 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: PEEK|TRUNC|CMSG_CLOEXEC ) = 20
181.824 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.825 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.834 (0.002 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: CMSG_CLOEXEC ) = 20
181.836 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.838 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.705 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 1256
181.710 (0.002 ms): evolution-addr/10924 geteuid( ) = 1000
181.712 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.727 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 1256
181.731 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.734 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.908 (0.002 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 20
181.913 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.915 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.930 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 20
181.934 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.937 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
220.718 (0.010 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.741 (0.000 ms): dbus-daemon/10711 ... [continued]: epoll_wait()) = 1
220.759 (0.004 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.780 (0.002 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.788 (0.001 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = -1 EAGAIN Resource temporarily unavailable
220.760 (0.004 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.771 (0.023 ms): perf/26347 open(filename: 0xf2e780, mode: 15918976 ) = 19
220.850 (0.002 ms): perf/26347 close(fd: 19 ) = 0
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-6be5jvnkdzjptdrebfn5263n@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 22:35:21 +07:00
|
|
|
if (trace->multiple_threads) {
|
|
|
|
if (trace->show_comm)
|
2013-09-11 21:56:44 +07:00
|
|
|
printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
|
2013-07-04 20:20:31 +07:00
|
|
|
printed += fprintf(fp, "%d ", thread->tid);
|
perf trace: Add option to show process COMM
Enabled by default, disable with --no-comm, e.g.:
181.821 (0.001 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: PEEK|TRUNC|CMSG_CLOEXEC ) = 20
181.824 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.825 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.834 (0.002 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: CMSG_CLOEXEC ) = 20
181.836 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.838 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.705 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 1256
181.710 (0.002 ms): evolution-addr/10924 geteuid( ) = 1000
181.712 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.727 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 1256
181.731 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.734 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.908 (0.002 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 20
181.913 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.915 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.930 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 20
181.934 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.937 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
220.718 (0.010 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.741 (0.000 ms): dbus-daemon/10711 ... [continued]: epoll_wait()) = 1
220.759 (0.004 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.780 (0.002 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.788 (0.001 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = -1 EAGAIN Resource temporarily unavailable
220.760 (0.004 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.771 (0.023 ms): perf/26347 open(filename: 0xf2e780, mode: 15918976 ) = 19
220.850 (0.002 ms): perf/26347 close(fd: 19 ) = 0
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-6be5jvnkdzjptdrebfn5263n@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 22:35:21 +07:00
|
|
|
}
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
static int trace__process_event(struct trace *trace, struct machine *machine,
|
2013-09-11 21:18:24 +07:00
|
|
|
union perf_event *event, struct perf_sample *sample)
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
switch (event->header.type) {
|
|
|
|
case PERF_RECORD_LOST:
|
2013-08-19 22:01:10 +07:00
|
|
|
color_fprintf(trace->output, PERF_COLOR_RED,
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
"LOST %" PRIu64 " events!\n", event->lost.lost);
|
2013-09-11 21:18:24 +07:00
|
|
|
ret = machine__process_lost_event(machine, event, sample);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
default:
|
2013-09-11 21:18:24 +07:00
|
|
|
ret = machine__process_event(machine, event, sample);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
static int trace__tool_process(struct perf_tool *tool,
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
union perf_event *event,
|
2013-09-11 21:18:24 +07:00
|
|
|
struct perf_sample *sample,
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
struct machine *machine)
|
|
|
|
{
|
2013-08-19 22:01:10 +07:00
|
|
|
struct trace *trace = container_of(tool, struct trace, tool);
|
2013-09-11 21:18:24 +07:00
|
|
|
return trace__process_event(trace, machine, event, sample);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
|
|
|
|
{
|
2014-08-12 13:40:45 +07:00
|
|
|
int err = symbol__init(NULL);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2013-09-29 02:13:00 +07:00
|
|
|
trace->host = machine__new_host();
|
|
|
|
if (trace->host == NULL)
|
|
|
|
return -ENOMEM;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
|
2013-11-11 21:36:12 +07:00
|
|
|
err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
|
|
|
|
evlist->threads, trace__tool_process, false);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
if (err)
|
|
|
|
symbol__exit();
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-24 04:14:48 +07:00
|
|
|
static int syscall__set_arg_fmts(struct syscall *sc)
|
|
|
|
{
|
|
|
|
struct format_field *field;
|
|
|
|
int idx = 0;
|
|
|
|
|
2015-03-21 03:46:53 +07:00
|
|
|
sc->arg_scnprintf = calloc(sc->nr_args, sizeof(void *));
|
2013-08-24 04:14:48 +07:00
|
|
|
if (sc->arg_scnprintf == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2013-09-04 01:50:28 +07:00
|
|
|
if (sc->fmt)
|
|
|
|
sc->arg_parm = sc->fmt->arg_parm;
|
|
|
|
|
2015-03-21 03:46:53 +07:00
|
|
|
for (field = sc->args; field; field = field->next) {
|
2013-08-26 22:29:38 +07:00
|
|
|
if (sc->fmt && sc->fmt->arg_scnprintf[idx])
|
|
|
|
sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
|
|
|
|
else if (field->flags & FIELD_IS_POINTER)
|
2013-08-24 04:14:48 +07:00
|
|
|
sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
|
|
|
|
++idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-27 06:05:56 +07:00
|
|
|
static int trace__read_syscall_info(struct trace *trace, int id)
|
|
|
|
{
|
|
|
|
char tp_name[128];
|
|
|
|
struct syscall *sc;
|
2013-09-28 04:06:19 +07:00
|
|
|
const char *name = audit_syscall_to_name(id, trace->audit.machine);
|
2012-10-20 22:39:03 +07:00
|
|
|
|
|
|
|
if (name == NULL)
|
|
|
|
return -1;
|
2012-09-27 06:05:56 +07:00
|
|
|
|
|
|
|
if (id > trace->syscalls.max) {
|
|
|
|
struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
|
|
|
|
|
|
|
|
if (nsyscalls == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (trace->syscalls.max != -1) {
|
|
|
|
memset(nsyscalls + trace->syscalls.max + 1, 0,
|
|
|
|
(id - trace->syscalls.max) * sizeof(*sc));
|
|
|
|
} else {
|
|
|
|
memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
|
|
|
|
}
|
|
|
|
|
|
|
|
trace->syscalls.table = nsyscalls;
|
|
|
|
trace->syscalls.max = id;
|
|
|
|
}
|
|
|
|
|
|
|
|
sc = trace->syscalls.table + id;
|
2012-10-20 22:39:03 +07:00
|
|
|
sc->name = name;
|
2013-08-09 22:28:31 +07:00
|
|
|
|
2013-08-21 22:56:21 +07:00
|
|
|
if (trace->ev_qualifier) {
|
|
|
|
bool in = strlist__find(trace->ev_qualifier, name) != NULL;
|
|
|
|
|
|
|
|
if (!(in ^ trace->not_ev_qualifier)) {
|
|
|
|
sc->filtered = true;
|
|
|
|
/*
|
|
|
|
* No need to do read tracepoint information since this will be
|
|
|
|
* filtered out.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
2013-08-09 22:28:31 +07:00
|
|
|
}
|
|
|
|
|
2012-10-20 22:39:03 +07:00
|
|
|
sc->fmt = syscall_fmt__find(sc->name);
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2012-09-27 23:16:00 +07:00
|
|
|
snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
|
2013-12-03 20:09:24 +07:00
|
|
|
sc->tp_format = trace_event__tp_format("syscalls", tp_name);
|
2012-09-27 23:16:00 +07:00
|
|
|
|
|
|
|
if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
|
|
|
|
snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
|
2013-12-03 20:09:24 +07:00
|
|
|
sc->tp_format = trace_event__tp_format("syscalls", tp_name);
|
2012-09-27 23:16:00 +07:00
|
|
|
}
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2013-08-24 04:14:48 +07:00
|
|
|
if (sc->tp_format == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2015-03-21 03:46:53 +07:00
|
|
|
sc->args = sc->tp_format->format.fields;
|
|
|
|
sc->nr_args = sc->tp_format->format.nr_fields;
|
|
|
|
/* drop nr field - not relevant here; does not exist on older kernels */
|
|
|
|
if (sc->args && strcmp(sc->args->name, "nr") == 0) {
|
|
|
|
sc->args = sc->args->next;
|
|
|
|
--sc->nr_args;
|
|
|
|
}
|
|
|
|
|
2014-06-18 00:29:24 +07:00
|
|
|
sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
|
|
|
|
|
2013-08-24 04:14:48 +07:00
|
|
|
return syscall__set_arg_fmts(sc);
|
2012-09-27 06:05:56 +07:00
|
|
|
}
|
|
|
|
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
/*
|
|
|
|
* args is to be interpreted as a series of longs but we need to handle
|
|
|
|
* 8-byte unaligned accesses. args points to raw_data within the event
|
|
|
|
* and raw_data is guaranteed to be 8-byte unaligned because it is
|
|
|
|
* preceded by raw_size which is a u32. So we need to copy args to a temp
|
|
|
|
* variable to read it. Most notably this avoids extended load instructions
|
|
|
|
* on unaligned addresses
|
|
|
|
*/
|
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
unsigned char *args, struct trace *trace,
|
2013-09-24 21:04:32 +07:00
|
|
|
struct thread *thread)
|
2012-09-27 06:05:56 +07:00
|
|
|
{
|
|
|
|
size_t printed = 0;
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
unsigned char *p;
|
|
|
|
unsigned long val;
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2015-03-21 03:46:53 +07:00
|
|
|
if (sc->args != NULL) {
|
2012-09-27 06:05:56 +07:00
|
|
|
struct format_field *field;
|
2013-09-03 22:20:12 +07:00
|
|
|
u8 bit = 1;
|
|
|
|
struct syscall_arg arg = {
|
2013-09-24 21:04:32 +07:00
|
|
|
.idx = 0,
|
|
|
|
.mask = 0,
|
|
|
|
.trace = trace,
|
|
|
|
.thread = thread,
|
2013-09-03 22:20:12 +07:00
|
|
|
};
|
2013-09-02 20:39:21 +07:00
|
|
|
|
2015-03-21 03:46:53 +07:00
|
|
|
for (field = sc->args; field;
|
2013-09-03 22:20:12 +07:00
|
|
|
field = field->next, ++arg.idx, bit <<= 1) {
|
|
|
|
if (arg.mask & bit)
|
2013-09-02 20:39:21 +07:00
|
|
|
continue;
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
|
|
|
|
/* special care for unaligned accesses */
|
|
|
|
p = args + sizeof(unsigned long) * arg.idx;
|
|
|
|
memcpy(&val, p, sizeof(val));
|
|
|
|
|
2013-09-20 22:19:41 +07:00
|
|
|
/*
|
|
|
|
* Suppress this argument if its value is zero and
|
|
|
|
* and we don't have a string associated in an
|
|
|
|
* strarray for it.
|
|
|
|
*/
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
if (val == 0 &&
|
2013-09-20 22:19:41 +07:00
|
|
|
!(sc->arg_scnprintf &&
|
|
|
|
sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
|
|
|
|
sc->arg_parm[arg.idx]))
|
2013-09-12 21:27:34 +07:00
|
|
|
continue;
|
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
printed += scnprintf(bf + printed, size - printed,
|
2013-08-24 04:14:48 +07:00
|
|
|
"%s%s: ", printed ? ", " : "", field->name);
|
2013-09-03 22:20:12 +07:00
|
|
|
if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
arg.val = val;
|
2013-09-04 01:50:28 +07:00
|
|
|
if (sc->arg_parm)
|
|
|
|
arg.parm = sc->arg_parm[arg.idx];
|
2013-09-03 22:20:12 +07:00
|
|
|
printed += sc->arg_scnprintf[arg.idx](bf + printed,
|
|
|
|
size - printed, &arg);
|
2013-09-02 20:39:21 +07:00
|
|
|
} else {
|
2013-08-24 04:14:48 +07:00
|
|
|
printed += scnprintf(bf + printed, size - printed,
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
"%ld", val);
|
2013-09-02 20:39:21 +07:00
|
|
|
}
|
2012-09-27 06:05:56 +07:00
|
|
|
}
|
|
|
|
} else {
|
2013-09-03 22:20:12 +07:00
|
|
|
int i = 0;
|
|
|
|
|
2012-09-27 06:05:56 +07:00
|
|
|
while (i < 6) {
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
/* special care for unaligned accesses */
|
|
|
|
p = args + sizeof(unsigned long) * i;
|
|
|
|
memcpy(&val, p, sizeof(val));
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
printed += scnprintf(bf + printed, size - printed,
|
|
|
|
"%sarg%d: %ld",
|
perf trace: Fix SIGBUS failures due to misaligned accesses
On Sparc64 perf-trace is failing in many spots due to extended load
instructions being used on misaligned accesses.
(gdb) run trace ls
Starting program: /tmp/perf/perf trace ls
[Thread debugging using libthread_db enabled]
Detaching after fork from child process 169460.
<ls output removed>
Program received signal SIGBUS, Bus error.
0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
warning: Source file is more recent than executable.
61 TP_UINT_FIELD(64);
(gdb) bt
0 0x000000000014f4dc in tp_field__u64 (field=0x4cc700, sample=0x7feffffa098) at builtin-trace.c:61
1 0x0000000000156ad4 in trace__sys_exit (trace=0x7feffffc268, evsel=0x4cc580, event=0xfffffc0104912000,
sample=0x7feffffa098) at builtin-trace.c:1701
2 0x0000000000158c14 in trace__run (trace=0x7feffffc268, argc=1, argv=0x7fefffff360) at builtin-trace.c:2160
3 0x000000000015b78c in cmd_trace (argc=1, argv=0x7fefffff360, prefix=0x0) at builtin-trace.c:2609
4 0x0000000000107d94 in run_builtin (p=0x4549c8, argc=2, argv=0x7fefffff360) at perf.c:341
5 0x0000000000108140 in handle_internal_command (argc=2, argv=0x7fefffff360) at perf.c:400
6 0x0000000000108308 in run_argv (argcp=0x7feffffef2c, argv=0x7feffffef20) at perf.c:444
7 0x0000000000108728 in main (argc=2, argv=0x7fefffff360) at perf.c:559
(gdb) p *sample
$1 = {ip = 4391276, pid = 169472, tid = 169472, time = 6303014583281250, addr = 0, id = 72082,
stream_id = 18446744073709551615, period = 1, weight = 0, transaction = 0, cpu = 73, raw_size = 36,
data_src = 84410401, flags = 0, insn_len = 0, raw_data = 0xfffffc010491203c, callchain = 0x0,
branch_stack = 0x0, user_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0},
intr_regs = {abi = 0, mask = 0, regs = 0x0, cache_regs = 0x7feffffa098, cache_mask = 0}, user_stack = {
offset = 0, size = 0, data = 0x0}, read = {time_enabled = 0, time_running = 0, {group = {nr = 0,
values = 0x0}, one = {value = 0, id = 0}}}}
(gdb) p *field
$2 = {offset = 16, {integer = 0x14f4a8 <tp_field__u64>, pointer = 0x14f4a8 <tp_field__u64>}}
sample->raw_data is guaranteed to not be 8-byte aligned because it is preceded
by the size as a u3. So accessing raw data with an extended load instruction causes
the SIGBUS. Resolve by using memcpy to a temporary variable of appropriate size.
Signed-off-by: David Ahern <david.ahern@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1424376022-140608-1-git-send-email-david.ahern@oracle.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-20 03:00:22 +07:00
|
|
|
printed ? ", " : "", i, val);
|
2012-09-27 06:05:56 +07:00
|
|
|
++i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
2012-09-29 03:58:36 +07:00
|
|
|
typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
|
2014-06-26 23:14:24 +07:00
|
|
|
union perf_event *event,
|
2012-09-29 03:58:36 +07:00
|
|
|
struct perf_sample *sample);
|
|
|
|
|
|
|
|
static struct syscall *trace__syscall_info(struct trace *trace,
|
2013-10-09 10:26:53 +07:00
|
|
|
struct perf_evsel *evsel, int id)
|
2012-09-29 03:58:36 +07:00
|
|
|
{
|
|
|
|
|
|
|
|
if (id < 0) {
|
2013-08-23 03:55:25 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
|
|
|
|
* before that, leaving at a higher verbosity level till that is
|
|
|
|
* explained. Reproduced with plain ftrace with:
|
|
|
|
*
|
|
|
|
* echo 1 > /t/events/raw_syscalls/sys_exit/enable
|
|
|
|
* grep "NR -1 " /t/trace_pipe
|
|
|
|
*
|
|
|
|
* After generating some load on the machine.
|
|
|
|
*/
|
|
|
|
if (verbose > 1) {
|
|
|
|
static u64 n;
|
|
|
|
fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
|
|
|
|
id, perf_evsel__name(evsel), ++n);
|
|
|
|
}
|
2012-09-29 03:58:36 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
|
|
|
|
trace__read_syscall_info(trace, id))
|
|
|
|
goto out_cant_read;
|
|
|
|
|
|
|
|
if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
|
|
|
|
goto out_cant_read;
|
|
|
|
|
|
|
|
return &trace->syscalls.table[id];
|
|
|
|
|
|
|
|
out_cant_read:
|
2013-08-23 02:49:54 +07:00
|
|
|
if (verbose) {
|
|
|
|
fprintf(trace->output, "Problems reading syscall %d", id);
|
|
|
|
if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
|
|
|
|
fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
|
|
|
|
fputs(" information\n", trace->output);
|
|
|
|
}
|
2012-09-29 03:58:36 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-10-09 10:26:53 +07:00
|
|
|
static void thread__update_stats(struct thread_trace *ttrace,
|
|
|
|
int id, struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
struct int_node *inode;
|
|
|
|
struct stats *stats;
|
|
|
|
u64 duration = 0;
|
|
|
|
|
|
|
|
inode = intlist__findnew(ttrace->syscall_stats, id);
|
|
|
|
if (inode == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
stats = inode->priv;
|
|
|
|
if (stats == NULL) {
|
|
|
|
stats = malloc(sizeof(struct stats));
|
|
|
|
if (stats == NULL)
|
|
|
|
return;
|
|
|
|
init_stats(stats);
|
|
|
|
inode->priv = stats;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ttrace->entry_time && sample->time > ttrace->entry_time)
|
|
|
|
duration = sample->time - ttrace->entry_time;
|
|
|
|
|
|
|
|
update_stats(stats, duration);
|
|
|
|
}
|
|
|
|
|
perf trace: Handle multiple threads better wrt syscalls being intermixed
$ trace time taskset -c 0 usleep 1
0.845 ( 0.021 ms): time/16722 wait4(upid: 4294967295, stat_addr: 0x7fff17f443d4, ru: 0x7fff17f44438 ) ...
0.865 ( 0.008 ms): time/16723 execve(arg0: 140733595272004, arg1: 140733595272720, arg2: 140733595272768, arg3: 139755107218496, arg4: 7307199665339051828, arg5: 3) = -2
2.395 ( 1.523 ms): taskset/16723 execve(arg0: 140733595272013, arg1: 140733595272720, arg2: 140733595272768, arg3: 139755107218496, arg4: 7307199665339051828, arg5: 3) = 0
2.411 ( 0.002 ms): taskset/16723 brk( ) = 0x1915000
3.300 ( 0.058 ms): usleep/16723 nanosleep(rqtp: 0x7ffff4ada190 ) = 0
<SNIP>
3.305 ( 0.000 ms): usleep/16723 exit_group(
3.363 ( 2.539 ms): time/16722 ... [continued]: wait4()) = 16723
3.366 ( 0.001 ms): time/16722 rt_sigaction(sig: INT, act: 0x7fff17f44160, oact: 0x7fff17f44200, sigsetsize: 8) = 0
We we're not seeing this line:
0.845 ( 0.021 ms): time/16722 wait4(upid: 4294967295, stat_addr: 0x7fff17f443d4, ru: 0x7fff17f44438 ) ...
just the one when it finishes:
3.363 ( 2.539 ms): time/16722 ... [continued]: wait4()) = 16723
Still some issues left till we move to ordered_samples when multiple
CPUs/threads are involved...
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-zq9x30a1ky3djqewqn2v3ja3@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-13 23:22:21 +07:00
|
|
|
static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
struct thread_trace *ttrace;
|
|
|
|
u64 duration;
|
|
|
|
size_t printed;
|
|
|
|
|
|
|
|
if (trace->current == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ttrace = thread__priv(trace->current);
|
|
|
|
|
|
|
|
if (!ttrace->entry_pending)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
duration = sample->time - ttrace->entry_time;
|
|
|
|
|
|
|
|
printed = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
|
|
|
|
printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
|
|
|
|
ttrace->entry_pending = false;
|
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
2012-09-29 03:58:36 +07:00
|
|
|
static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
|
2014-06-26 23:14:24 +07:00
|
|
|
union perf_event *event __maybe_unused,
|
2012-09-29 03:58:36 +07:00
|
|
|
struct perf_sample *sample)
|
|
|
|
{
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
char *msg;
|
2012-09-29 03:58:36 +07:00
|
|
|
void *args;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
size_t printed = 0;
|
2013-08-09 22:28:31 +07:00
|
|
|
struct thread *thread;
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
int id = perf_evsel__sc_tp_uint(evsel, id, sample);
|
2013-10-09 10:26:53 +07:00
|
|
|
struct syscall *sc = trace__syscall_info(trace, evsel, id);
|
2013-08-09 22:28:31 +07:00
|
|
|
struct thread_trace *ttrace;
|
|
|
|
|
|
|
|
if (sc == NULL)
|
|
|
|
return -1;
|
2012-09-29 03:58:36 +07:00
|
|
|
|
2013-08-09 22:28:31 +07:00
|
|
|
if (sc->filtered)
|
|
|
|
return 0;
|
|
|
|
|
2013-09-29 02:13:00 +07:00
|
|
|
thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
|
2013-08-19 22:01:10 +07:00
|
|
|
ttrace = thread__trace(thread, trace->output);
|
2013-08-09 22:28:31 +07:00
|
|
|
if (ttrace == NULL)
|
2012-09-29 03:58:36 +07:00
|
|
|
return -1;
|
|
|
|
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
args = perf_evsel__sc_tp_ptr(evsel, args, sample);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
|
|
|
|
if (ttrace->entry_str == NULL) {
|
|
|
|
ttrace->entry_str = malloc(1024);
|
|
|
|
if (!ttrace->entry_str)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-03-20 01:23:03 +07:00
|
|
|
if (!trace->summary_only)
|
2015-03-26 04:01:15 +07:00
|
|
|
trace__printf_interrupted_entry(trace, sample);
|
perf trace: Handle multiple threads better wrt syscalls being intermixed
$ trace time taskset -c 0 usleep 1
0.845 ( 0.021 ms): time/16722 wait4(upid: 4294967295, stat_addr: 0x7fff17f443d4, ru: 0x7fff17f44438 ) ...
0.865 ( 0.008 ms): time/16723 execve(arg0: 140733595272004, arg1: 140733595272720, arg2: 140733595272768, arg3: 139755107218496, arg4: 7307199665339051828, arg5: 3) = -2
2.395 ( 1.523 ms): taskset/16723 execve(arg0: 140733595272013, arg1: 140733595272720, arg2: 140733595272768, arg3: 139755107218496, arg4: 7307199665339051828, arg5: 3) = 0
2.411 ( 0.002 ms): taskset/16723 brk( ) = 0x1915000
3.300 ( 0.058 ms): usleep/16723 nanosleep(rqtp: 0x7ffff4ada190 ) = 0
<SNIP>
3.305 ( 0.000 ms): usleep/16723 exit_group(
3.363 ( 2.539 ms): time/16722 ... [continued]: wait4()) = 16723
3.366 ( 0.001 ms): time/16722 rt_sigaction(sig: INT, act: 0x7fff17f44160, oact: 0x7fff17f44200, sigsetsize: 8) = 0
We we're not seeing this line:
0.845 ( 0.021 ms): time/16722 wait4(upid: 4294967295, stat_addr: 0x7fff17f443d4, ru: 0x7fff17f44438 ) ...
just the one when it finishes:
3.363 ( 2.539 ms): time/16722 ... [continued]: wait4()) = 16723
Still some issues left till we move to ordered_samples when multiple
CPUs/threads are involved...
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-zq9x30a1ky3djqewqn2v3ja3@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-13 23:22:21 +07:00
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
ttrace->entry_time = sample->time;
|
|
|
|
msg = ttrace->entry_str;
|
|
|
|
printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
|
|
|
|
|
2013-09-24 21:04:32 +07:00
|
|
|
printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
|
|
|
|
args, trace, thread);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
|
2014-06-18 00:29:24 +07:00
|
|
|
if (sc->is_exit) {
|
2013-11-12 23:31:15 +07:00
|
|
|
if (!trace->duration_filter && !trace->summary_only) {
|
2013-08-19 22:01:10 +07:00
|
|
|
trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
|
|
|
|
fprintf(trace->output, "%-70s\n", ttrace->entry_str);
|
perf trace: Add duration filter
Example:
[acme@sandy linux]$ perf trace --duration 0.025 usleep 1
2.221 ( 0.958 ms): 6724 execve(arg0: 140733557168278, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = -2
3.690 ( 1.443 ms): 6724 execve(arg0: 140733557168295, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = 0
3.979 ( 0.048 ms): 6724 open(filename: 208733843841, flags: 0, mode: 1 ) = 3
4.071 ( 0.075 ms): 6724 open(filename: 139744419925673, flags: 0, mode: 0 ) = 3
4.318 ( 0.056 ms): 6724 nanosleep(rqtp: 140734030404608, rmtp: 0 ) = 0
[acme@sandy linux]$ perf trace --duration 0.100 usleep 1
1.143 ( 1.021 ms): 6726 execve(arg0: 140736323962279, arg1: 140736323972752, arg2: 34926752, arg3: 140736323961824, arg4: 7955998171588342573, arg5: 6725) = 0
[acme@sandy linux]$
Cherry picked from tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-oslw2j2958we9qf0ctra4whd@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-08 19:56:00 +07:00
|
|
|
}
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
} else
|
|
|
|
ttrace->entry_pending = true;
|
2012-09-29 03:58:36 +07:00
|
|
|
|
2015-03-03 08:21:35 +07:00
|
|
|
if (trace->current != thread) {
|
|
|
|
thread__put(trace->current);
|
|
|
|
trace->current = thread__get(thread);
|
|
|
|
}
|
perf trace: Handle multiple threads better wrt syscalls being intermixed
$ trace time taskset -c 0 usleep 1
0.845 ( 0.021 ms): time/16722 wait4(upid: 4294967295, stat_addr: 0x7fff17f443d4, ru: 0x7fff17f44438 ) ...
0.865 ( 0.008 ms): time/16723 execve(arg0: 140733595272004, arg1: 140733595272720, arg2: 140733595272768, arg3: 139755107218496, arg4: 7307199665339051828, arg5: 3) = -2
2.395 ( 1.523 ms): taskset/16723 execve(arg0: 140733595272013, arg1: 140733595272720, arg2: 140733595272768, arg3: 139755107218496, arg4: 7307199665339051828, arg5: 3) = 0
2.411 ( 0.002 ms): taskset/16723 brk( ) = 0x1915000
3.300 ( 0.058 ms): usleep/16723 nanosleep(rqtp: 0x7ffff4ada190 ) = 0
<SNIP>
3.305 ( 0.000 ms): usleep/16723 exit_group(
3.363 ( 2.539 ms): time/16722 ... [continued]: wait4()) = 16723
3.366 ( 0.001 ms): time/16722 rt_sigaction(sig: INT, act: 0x7fff17f44160, oact: 0x7fff17f44200, sigsetsize: 8) = 0
We we're not seeing this line:
0.845 ( 0.021 ms): time/16722 wait4(upid: 4294967295, stat_addr: 0x7fff17f443d4, ru: 0x7fff17f44438 ) ...
just the one when it finishes:
3.363 ( 2.539 ms): time/16722 ... [continued]: wait4()) = 16723
Still some issues left till we move to ordered_samples when multiple
CPUs/threads are involved...
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-zq9x30a1ky3djqewqn2v3ja3@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-13 23:22:21 +07:00
|
|
|
|
2012-09-29 03:58:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
|
2014-06-26 23:14:24 +07:00
|
|
|
union perf_event *event __maybe_unused,
|
2012-09-29 03:58:36 +07:00
|
|
|
struct perf_sample *sample)
|
|
|
|
{
|
2014-09-26 19:54:01 +07:00
|
|
|
long ret;
|
perf trace: Add an event duration column
# perf trace usleep 1 | tail -10
0.453 ( 0.002 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763342848
0.456 ( 0.001 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763346944
0.459 ( 0.001 ms): arch_prctl(option: 4098, arg2: 140126839658240, arg3: 140126839652352, arg4: 34, arg5: 4294967295) = 0
0.473 ( 0.003 ms): mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
0.477 ( 0.003 ms): mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
0.483 ( 0.004 ms): munmap(addr: 140126839664640, len: 91882 ) = 0
0.540 ( 0.001 ms): brk(brk: 0 ) = 31928320
0.542 ( 0.002 ms): brk(brk: 32063488 ) = 32063488
1.456 ( 0.901 ms): nanosleep(rqtp: 140735472817168, rmtp: 0 ) = 0
1.462 ( 0.000 ms): exit_group(error_code: 0
#
This also comes from the tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-g9akh5hjw2kvjerpo9xror6f@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-25 02:24:47 +07:00
|
|
|
u64 duration = 0;
|
2013-08-09 22:28:31 +07:00
|
|
|
struct thread *thread;
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
int id = perf_evsel__sc_tp_uint(evsel, id, sample);
|
2013-10-09 10:26:53 +07:00
|
|
|
struct syscall *sc = trace__syscall_info(trace, evsel, id);
|
2013-08-09 22:28:31 +07:00
|
|
|
struct thread_trace *ttrace;
|
|
|
|
|
|
|
|
if (sc == NULL)
|
|
|
|
return -1;
|
2012-09-29 03:58:36 +07:00
|
|
|
|
2013-08-09 22:28:31 +07:00
|
|
|
if (sc->filtered)
|
|
|
|
return 0;
|
|
|
|
|
2013-09-29 02:13:00 +07:00
|
|
|
thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
|
2013-08-19 22:01:10 +07:00
|
|
|
ttrace = thread__trace(thread, trace->output);
|
2013-08-09 22:28:31 +07:00
|
|
|
if (ttrace == NULL)
|
2012-09-29 03:58:36 +07:00
|
|
|
return -1;
|
|
|
|
|
2013-10-09 10:26:53 +07:00
|
|
|
if (trace->summary)
|
|
|
|
thread__update_stats(ttrace, id, sample);
|
|
|
|
|
perf trace: Don't relookup fields by name in each sample
Instead do the lookups just when creating the tracepoints, initially for
the most common, raw_syscalls:sys_{enter,exit}.
It works by having evsel->priv have a per tracepoint structure with
entries for the fields, for direct access, with the offset and a
function to get the value from the sample, doing the swap if needed.
Using a simple workload that does M millions write syscalls, we go from:
# perf stat -i -e cycles /tmp/oldperf trace ./sc_hello 100 > /dev/null
Performance counter stats for '/tmp/oldperf trace ./sc_hello 100':
8,366,771,459 cycles
2.668025928 seconds time elapsed
# perf stat -i -e cycles perf trace ./sc_hello 100 > /dev/null
Performance counter stats for 'perf trace ./sc_hello 100':
8,345,187,650 cycles
2.631748425 seconds time elapsed
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-eyfhvoo510a5i10b27dnvm88@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-11-07 02:35:57 +07:00
|
|
|
ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
|
2012-09-29 03:58:36 +07:00
|
|
|
|
2013-09-28 04:06:19 +07:00
|
|
|
if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
|
|
|
|
trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
|
|
|
|
trace->last_vfs_getname = NULL;
|
|
|
|
++trace->stats.vfs_getname;
|
|
|
|
}
|
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
ttrace->exit_time = sample->time;
|
|
|
|
|
perf trace: Add duration filter
Example:
[acme@sandy linux]$ perf trace --duration 0.025 usleep 1
2.221 ( 0.958 ms): 6724 execve(arg0: 140733557168278, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = -2
3.690 ( 1.443 ms): 6724 execve(arg0: 140733557168295, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = 0
3.979 ( 0.048 ms): 6724 open(filename: 208733843841, flags: 0, mode: 1 ) = 3
4.071 ( 0.075 ms): 6724 open(filename: 139744419925673, flags: 0, mode: 0 ) = 3
4.318 ( 0.056 ms): 6724 nanosleep(rqtp: 140734030404608, rmtp: 0 ) = 0
[acme@sandy linux]$ perf trace --duration 0.100 usleep 1
1.143 ( 1.021 ms): 6726 execve(arg0: 140736323962279, arg1: 140736323972752, arg2: 34926752, arg3: 140736323961824, arg4: 7955998171588342573, arg5: 6725) = 0
[acme@sandy linux]$
Cherry picked from tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-oslw2j2958we9qf0ctra4whd@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-08 19:56:00 +07:00
|
|
|
if (ttrace->entry_time) {
|
perf trace: Add an event duration column
# perf trace usleep 1 | tail -10
0.453 ( 0.002 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763342848
0.456 ( 0.001 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763346944
0.459 ( 0.001 ms): arch_prctl(option: 4098, arg2: 140126839658240, arg3: 140126839652352, arg4: 34, arg5: 4294967295) = 0
0.473 ( 0.003 ms): mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
0.477 ( 0.003 ms): mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
0.483 ( 0.004 ms): munmap(addr: 140126839664640, len: 91882 ) = 0
0.540 ( 0.001 ms): brk(brk: 0 ) = 31928320
0.542 ( 0.002 ms): brk(brk: 32063488 ) = 32063488
1.456 ( 0.901 ms): nanosleep(rqtp: 140735472817168, rmtp: 0 ) = 0
1.462 ( 0.000 ms): exit_group(error_code: 0
#
This also comes from the tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-g9akh5hjw2kvjerpo9xror6f@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-25 02:24:47 +07:00
|
|
|
duration = sample->time - ttrace->entry_time;
|
perf trace: Add duration filter
Example:
[acme@sandy linux]$ perf trace --duration 0.025 usleep 1
2.221 ( 0.958 ms): 6724 execve(arg0: 140733557168278, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = -2
3.690 ( 1.443 ms): 6724 execve(arg0: 140733557168295, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = 0
3.979 ( 0.048 ms): 6724 open(filename: 208733843841, flags: 0, mode: 1 ) = 3
4.071 ( 0.075 ms): 6724 open(filename: 139744419925673, flags: 0, mode: 0 ) = 3
4.318 ( 0.056 ms): 6724 nanosleep(rqtp: 140734030404608, rmtp: 0 ) = 0
[acme@sandy linux]$ perf trace --duration 0.100 usleep 1
1.143 ( 1.021 ms): 6726 execve(arg0: 140736323962279, arg1: 140736323972752, arg2: 34926752, arg3: 140736323961824, arg4: 7955998171588342573, arg5: 6725) = 0
[acme@sandy linux]$
Cherry picked from tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-oslw2j2958we9qf0ctra4whd@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-08 19:56:00 +07:00
|
|
|
if (trace__filter_duration(trace, duration))
|
|
|
|
goto out;
|
|
|
|
} else if (trace->duration_filter)
|
|
|
|
goto out;
|
perf trace: Add an event duration column
# perf trace usleep 1 | tail -10
0.453 ( 0.002 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763342848
0.456 ( 0.001 ms): mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -763346944
0.459 ( 0.001 ms): arch_prctl(option: 4098, arg2: 140126839658240, arg3: 140126839652352, arg4: 34, arg5: 4294967295) = 0
0.473 ( 0.003 ms): mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
0.477 ( 0.003 ms): mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
0.483 ( 0.004 ms): munmap(addr: 140126839664640, len: 91882 ) = 0
0.540 ( 0.001 ms): brk(brk: 0 ) = 31928320
0.542 ( 0.002 ms): brk(brk: 32063488 ) = 32063488
1.456 ( 0.901 ms): nanosleep(rqtp: 140735472817168, rmtp: 0 ) = 0
1.462 ( 0.000 ms): exit_group(error_code: 0
#
This also comes from the tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-g9akh5hjw2kvjerpo9xror6f@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-25 02:24:47 +07:00
|
|
|
|
2013-11-12 23:31:15 +07:00
|
|
|
if (trace->summary_only)
|
|
|
|
goto out;
|
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
|
|
|
|
if (ttrace->entry_pending) {
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, "%-70s", ttrace->entry_str);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
} else {
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, " ... [");
|
|
|
|
color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
|
|
|
|
fprintf(trace->output, "]: %s()", sc->name);
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
}
|
|
|
|
|
2013-08-26 21:28:34 +07:00
|
|
|
if (sc->fmt == NULL) {
|
|
|
|
signed_print:
|
2014-09-26 19:54:01 +07:00
|
|
|
fprintf(trace->output, ") = %ld", ret);
|
2013-08-26 21:28:34 +07:00
|
|
|
} else if (ret < 0 && sc->fmt->errmsg) {
|
2014-08-14 09:22:41 +07:00
|
|
|
char bf[STRERR_BUFSIZE];
|
2012-09-29 03:58:36 +07:00
|
|
|
const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
|
|
|
|
*e = audit_errno_to_name(-ret);
|
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, ") = -1 %s %s", e, emsg);
|
2013-08-26 21:28:34 +07:00
|
|
|
} else if (ret == 0 && sc->fmt->timeout)
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, ") = 0 Timeout");
|
2013-08-26 21:36:30 +07:00
|
|
|
else if (sc->fmt->hexret)
|
2014-09-26 19:54:01 +07:00
|
|
|
fprintf(trace->output, ") = %#lx", ret);
|
2012-09-29 03:58:36 +07:00
|
|
|
else
|
2013-08-26 21:28:34 +07:00
|
|
|
goto signed_print;
|
2012-09-29 03:58:36 +07:00
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
fputc('\n', trace->output);
|
perf trace: Add duration filter
Example:
[acme@sandy linux]$ perf trace --duration 0.025 usleep 1
2.221 ( 0.958 ms): 6724 execve(arg0: 140733557168278, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = -2
3.690 ( 1.443 ms): 6724 execve(arg0: 140733557168295, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = 0
3.979 ( 0.048 ms): 6724 open(filename: 208733843841, flags: 0, mode: 1 ) = 3
4.071 ( 0.075 ms): 6724 open(filename: 139744419925673, flags: 0, mode: 0 ) = 3
4.318 ( 0.056 ms): 6724 nanosleep(rqtp: 140734030404608, rmtp: 0 ) = 0
[acme@sandy linux]$ perf trace --duration 0.100 usleep 1
1.143 ( 1.021 ms): 6726 execve(arg0: 140736323962279, arg1: 140736323972752, arg2: 34926752, arg3: 140736323961824, arg4: 7955998171588342573, arg5: 6725) = 0
[acme@sandy linux]$
Cherry picked from tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-oslw2j2958we9qf0ctra4whd@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-08 19:56:00 +07:00
|
|
|
out:
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
ttrace->entry_pending = false;
|
|
|
|
|
2012-09-29 03:58:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-28 04:06:19 +07:00
|
|
|
static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
|
2014-06-26 23:14:24 +07:00
|
|
|
union perf_event *event __maybe_unused,
|
2013-09-28 04:06:19 +07:00
|
|
|
struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-18 03:13:12 +07:00
|
|
|
static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
|
2014-06-26 23:14:24 +07:00
|
|
|
union perf_event *event __maybe_unused,
|
2012-10-18 03:13:12 +07:00
|
|
|
struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
|
|
|
|
double runtime_ms = (double)runtime / NSEC_PER_MSEC;
|
2013-09-29 02:13:00 +07:00
|
|
|
struct thread *thread = machine__findnew_thread(trace->host,
|
2013-08-27 15:23:03 +07:00
|
|
|
sample->pid,
|
|
|
|
sample->tid);
|
2013-08-19 22:01:10 +07:00
|
|
|
struct thread_trace *ttrace = thread__trace(thread, trace->output);
|
2012-10-18 03:13:12 +07:00
|
|
|
|
|
|
|
if (ttrace == NULL)
|
|
|
|
goto out_dump;
|
|
|
|
|
|
|
|
ttrace->runtime_ms += runtime_ms;
|
|
|
|
trace->runtime_ms += runtime_ms;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_dump:
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
|
2012-10-18 03:13:12 +07:00
|
|
|
evsel->name,
|
|
|
|
perf_evsel__strval(evsel, sample, "comm"),
|
|
|
|
(pid_t)perf_evsel__intval(evsel, sample, "pid"),
|
|
|
|
runtime,
|
|
|
|
perf_evsel__intval(evsel, sample, "vruntime"));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
|
|
|
|
union perf_event *event __maybe_unused,
|
|
|
|
struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
trace__printf_interrupted_entry(trace, sample);
|
|
|
|
trace__fprintf_tstamp(trace, sample->time, trace->output);
|
2015-02-20 12:51:50 +07:00
|
|
|
|
|
|
|
if (trace->trace_syscalls)
|
|
|
|
fprintf(trace->output, "( ): ");
|
|
|
|
|
|
|
|
fprintf(trace->output, "%s:", evsel->name);
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
|
|
|
|
if (evsel->tp_format) {
|
|
|
|
event_format__fprintf(evsel->tp_format, sample->cpu,
|
|
|
|
sample->raw_data, sample->raw_size,
|
|
|
|
trace->output);
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(trace->output, ")\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-26 23:14:25 +07:00
|
|
|
static void print_location(FILE *f, struct perf_sample *sample,
|
|
|
|
struct addr_location *al,
|
|
|
|
bool print_dso, bool print_sym)
|
|
|
|
{
|
|
|
|
|
|
|
|
if ((verbose || print_dso) && al->map)
|
|
|
|
fprintf(f, "%s@", al->map->dso->long_name);
|
|
|
|
|
|
|
|
if ((verbose || print_sym) && al->sym)
|
2014-07-09 01:39:21 +07:00
|
|
|
fprintf(f, "%s+0x%" PRIx64, al->sym->name,
|
2014-06-26 23:14:25 +07:00
|
|
|
al->addr - al->sym->start);
|
|
|
|
else if (al->map)
|
2014-07-09 01:39:21 +07:00
|
|
|
fprintf(f, "0x%" PRIx64, al->addr);
|
2014-06-26 23:14:25 +07:00
|
|
|
else
|
2014-07-09 01:39:21 +07:00
|
|
|
fprintf(f, "0x%" PRIx64, sample->addr);
|
2014-06-26 23:14:25 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int trace__pgfault(struct trace *trace,
|
|
|
|
struct perf_evsel *evsel,
|
|
|
|
union perf_event *event,
|
|
|
|
struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
struct thread *thread;
|
|
|
|
u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
|
|
|
|
struct addr_location al;
|
|
|
|
char map_type = 'd';
|
2014-07-09 01:05:16 +07:00
|
|
|
struct thread_trace *ttrace;
|
2014-06-26 23:14:25 +07:00
|
|
|
|
|
|
|
thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
|
2014-07-09 01:05:16 +07:00
|
|
|
ttrace = thread__trace(thread, trace->output);
|
|
|
|
if (ttrace == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
|
|
|
|
ttrace->pfmaj++;
|
|
|
|
else
|
|
|
|
ttrace->pfmin++;
|
|
|
|
|
|
|
|
if (trace->summary_only)
|
|
|
|
return 0;
|
2014-06-26 23:14:25 +07:00
|
|
|
|
2014-10-23 22:50:25 +07:00
|
|
|
thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
|
2014-06-26 23:14:25 +07:00
|
|
|
sample->ip, &al);
|
|
|
|
|
|
|
|
trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
|
|
|
|
|
|
|
|
fprintf(trace->output, "%sfault [",
|
|
|
|
evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
|
|
|
|
"maj" : "min");
|
|
|
|
|
|
|
|
print_location(trace->output, sample, &al, false, true);
|
|
|
|
|
|
|
|
fprintf(trace->output, "] => ");
|
|
|
|
|
2014-10-23 22:50:25 +07:00
|
|
|
thread__find_addr_location(thread, cpumode, MAP__VARIABLE,
|
2014-06-26 23:14:25 +07:00
|
|
|
sample->addr, &al);
|
|
|
|
|
|
|
|
if (!al.map) {
|
2014-10-23 22:50:25 +07:00
|
|
|
thread__find_addr_location(thread, cpumode,
|
2014-06-26 23:14:25 +07:00
|
|
|
MAP__FUNCTION, sample->addr, &al);
|
|
|
|
|
|
|
|
if (al.map)
|
|
|
|
map_type = 'x';
|
|
|
|
else
|
|
|
|
map_type = '?';
|
|
|
|
}
|
|
|
|
|
|
|
|
print_location(trace->output, sample, &al, true, false);
|
|
|
|
|
|
|
|
fprintf(trace->output, " (%c%c)\n", map_type, al.level);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-29 11:29:53 +07:00
|
|
|
static bool skip_sample(struct trace *trace, struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
|
|
|
|
(trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (trace->pid_list || trace->tid_list)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-08-29 11:29:52 +07:00
|
|
|
static int trace__process_sample(struct perf_tool *tool,
|
2014-06-26 23:14:24 +07:00
|
|
|
union perf_event *event,
|
2013-08-29 11:29:52 +07:00
|
|
|
struct perf_sample *sample,
|
|
|
|
struct perf_evsel *evsel,
|
|
|
|
struct machine *machine __maybe_unused)
|
|
|
|
{
|
|
|
|
struct trace *trace = container_of(tool, struct trace, tool);
|
|
|
|
int err = 0;
|
|
|
|
|
2013-11-06 20:17:38 +07:00
|
|
|
tracepoint_handler handler = evsel->handler;
|
2013-08-29 11:29:52 +07:00
|
|
|
|
2013-08-29 11:29:53 +07:00
|
|
|
if (skip_sample(trace, sample))
|
|
|
|
return 0;
|
|
|
|
|
2013-09-05 01:37:43 +07:00
|
|
|
if (!trace->full_time && trace->base_time == 0)
|
2013-08-29 11:29:52 +07:00
|
|
|
trace->base_time = sample->time;
|
|
|
|
|
2013-12-05 09:41:41 +07:00
|
|
|
if (handler) {
|
|
|
|
++trace->nr_events;
|
2014-06-26 23:14:24 +07:00
|
|
|
handler(trace, evsel, event, sample);
|
2013-12-05 09:41:41 +07:00
|
|
|
}
|
2013-08-29 11:29:52 +07:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-29 11:29:53 +07:00
|
|
|
static int parse_target_str(struct trace *trace)
|
|
|
|
{
|
|
|
|
if (trace->opts.target.pid) {
|
|
|
|
trace->pid_list = intlist__new(trace->opts.target.pid);
|
|
|
|
if (trace->pid_list == NULL) {
|
|
|
|
pr_err("Error parsing process id string\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (trace->opts.target.tid) {
|
|
|
|
trace->tid_list = intlist__new(trace->opts.target.tid);
|
|
|
|
if (trace->tid_list == NULL) {
|
|
|
|
pr_err("Error parsing thread id string\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-26 23:14:26 +07:00
|
|
|
static int trace__record(struct trace *trace, int argc, const char **argv)
|
2013-09-29 02:13:01 +07:00
|
|
|
{
|
|
|
|
unsigned int rec_argc, i, j;
|
|
|
|
const char **rec_argv;
|
|
|
|
const char * const record_args[] = {
|
|
|
|
"record",
|
|
|
|
"-R",
|
|
|
|
"-m", "1024",
|
|
|
|
"-c", "1",
|
|
|
|
};
|
|
|
|
|
2014-06-26 23:14:26 +07:00
|
|
|
const char * const sc_args[] = { "-e", };
|
|
|
|
unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
|
|
|
|
const char * const majpf_args[] = { "-e", "major-faults" };
|
|
|
|
unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
|
|
|
|
const char * const minpf_args[] = { "-e", "minor-faults" };
|
|
|
|
unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
|
|
|
|
|
2013-12-05 09:41:39 +07:00
|
|
|
/* +1 is for the event string below */
|
2014-06-26 23:14:26 +07:00
|
|
|
rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
|
|
|
|
majpf_args_nr + minpf_args_nr + argc;
|
2013-09-29 02:13:01 +07:00
|
|
|
rec_argv = calloc(rec_argc + 1, sizeof(char *));
|
|
|
|
|
|
|
|
if (rec_argv == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-06-26 23:14:26 +07:00
|
|
|
j = 0;
|
2013-09-29 02:13:01 +07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(record_args); i++)
|
2014-06-26 23:14:26 +07:00
|
|
|
rec_argv[j++] = record_args[i];
|
|
|
|
|
2014-06-26 23:14:28 +07:00
|
|
|
if (trace->trace_syscalls) {
|
|
|
|
for (i = 0; i < sc_args_nr; i++)
|
|
|
|
rec_argv[j++] = sc_args[i];
|
|
|
|
|
|
|
|
/* event string may be different for older kernels - e.g., RHEL6 */
|
|
|
|
if (is_valid_tracepoint("raw_syscalls:sys_enter"))
|
|
|
|
rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
|
|
|
|
else if (is_valid_tracepoint("syscalls:sys_enter"))
|
|
|
|
rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
|
|
|
|
else {
|
|
|
|
pr_err("Neither raw_syscalls nor syscalls events exist.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
2013-12-05 09:41:39 +07:00
|
|
|
}
|
|
|
|
|
2014-06-26 23:14:26 +07:00
|
|
|
if (trace->trace_pgfaults & TRACE_PFMAJ)
|
|
|
|
for (i = 0; i < majpf_args_nr; i++)
|
|
|
|
rec_argv[j++] = majpf_args[i];
|
|
|
|
|
|
|
|
if (trace->trace_pgfaults & TRACE_PFMIN)
|
|
|
|
for (i = 0; i < minpf_args_nr; i++)
|
|
|
|
rec_argv[j++] = minpf_args[i];
|
|
|
|
|
|
|
|
for (i = 0; i < (unsigned int)argc; i++)
|
|
|
|
rec_argv[j++] = argv[i];
|
2013-09-29 02:13:01 +07:00
|
|
|
|
2014-06-26 23:14:26 +07:00
|
|
|
return cmd_record(j, rec_argv, NULL);
|
2013-09-29 02:13:01 +07:00
|
|
|
}
|
|
|
|
|
2013-10-09 10:26:53 +07:00
|
|
|
static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
|
|
|
|
|
2013-09-28 04:06:19 +07:00
|
|
|
static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
|
|
|
|
{
|
2013-11-08 02:41:19 +07:00
|
|
|
struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
|
2013-09-28 04:06:19 +07:00
|
|
|
if (evsel == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (perf_evsel__field(evsel, "pathname") == NULL) {
|
|
|
|
perf_evsel__delete(evsel);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-06 20:17:38 +07:00
|
|
|
evsel->handler = trace__vfs_getname;
|
2013-09-28 04:06:19 +07:00
|
|
|
perf_evlist__add(evlist, evsel);
|
|
|
|
}
|
|
|
|
|
2014-06-26 23:14:25 +07:00
|
|
|
static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
|
|
|
|
u64 config)
|
|
|
|
{
|
|
|
|
struct perf_evsel *evsel;
|
|
|
|
struct perf_event_attr attr = {
|
|
|
|
.type = PERF_TYPE_SOFTWARE,
|
|
|
|
.mmap_data = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
attr.config = config;
|
2014-07-24 04:15:09 +07:00
|
|
|
attr.sample_period = 1;
|
2014-06-26 23:14:25 +07:00
|
|
|
|
|
|
|
event_attr_init(&attr);
|
|
|
|
|
|
|
|
evsel = perf_evsel__new(&attr);
|
|
|
|
if (!evsel)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
evsel->handler = trace__pgfault;
|
|
|
|
perf_evlist__add(evlist, evsel);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-22 03:10:29 +07:00
|
|
|
static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
|
|
|
|
{
|
|
|
|
const u32 type = event->header.type;
|
|
|
|
struct perf_evsel *evsel;
|
|
|
|
|
|
|
|
if (!trace->full_time && trace->base_time == 0)
|
|
|
|
trace->base_time = sample->time;
|
|
|
|
|
|
|
|
if (type != PERF_RECORD_SAMPLE) {
|
|
|
|
trace__process_event(trace, trace->host, event, sample);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
|
|
|
|
if (evsel == NULL) {
|
|
|
|
fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
|
|
|
|
sample->raw_data == NULL) {
|
|
|
|
fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
|
|
|
|
perf_evsel__name(evsel), sample->tid,
|
|
|
|
sample->cpu, sample->raw_size);
|
|
|
|
} else {
|
|
|
|
tracepoint_handler handler = evsel->handler;
|
|
|
|
handler(trace, evsel, event, sample);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-05 12:02:16 +07:00
|
|
|
static int trace__run(struct trace *trace, int argc, const char **argv)
|
2012-09-27 06:05:56 +07:00
|
|
|
{
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
struct perf_evlist *evlist = trace->evlist;
|
2012-10-18 03:09:46 +07:00
|
|
|
int err = -1, i;
|
|
|
|
unsigned long before;
|
2012-10-05 12:02:16 +07:00
|
|
|
const bool forks = argc > 0;
|
2014-09-23 00:39:48 +07:00
|
|
|
bool draining = false;
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2013-09-24 21:04:32 +07:00
|
|
|
trace->live = true;
|
|
|
|
|
2014-06-26 23:14:28 +07:00
|
|
|
if (trace->trace_syscalls &&
|
|
|
|
perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
|
|
|
|
trace__sys_exit))
|
2015-01-22 20:52:55 +07:00
|
|
|
goto out_error_raw_syscalls;
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2014-06-26 23:14:28 +07:00
|
|
|
if (trace->trace_syscalls)
|
|
|
|
perf_evlist__add_vfs_getname(evlist);
|
2013-09-28 04:06:19 +07:00
|
|
|
|
2014-06-26 23:14:25 +07:00
|
|
|
if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
|
2015-01-22 20:34:22 +07:00
|
|
|
perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ)) {
|
2015-01-22 21:08:04 +07:00
|
|
|
goto out_error_mem;
|
2015-01-22 20:34:22 +07:00
|
|
|
}
|
2014-06-26 23:14:25 +07:00
|
|
|
|
|
|
|
if ((trace->trace_pgfaults & TRACE_PFMIN) &&
|
|
|
|
perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
|
2015-01-22 21:08:04 +07:00
|
|
|
goto out_error_mem;
|
2014-06-26 23:14:25 +07:00
|
|
|
|
2012-10-18 03:13:12 +07:00
|
|
|
if (trace->sched &&
|
2015-01-22 21:13:43 +07:00
|
|
|
perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
|
|
|
|
trace__sched_stat_runtime))
|
|
|
|
goto out_error_sched_stat_runtime;
|
2012-10-18 03:13:12 +07:00
|
|
|
|
2012-09-27 06:05:56 +07:00
|
|
|
err = perf_evlist__create_maps(evlist, &trace->opts.target);
|
|
|
|
if (err < 0) {
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
|
2012-09-27 06:05:56 +07:00
|
|
|
goto out_delete_evlist;
|
|
|
|
}
|
|
|
|
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
err = trace__symbols_init(trace, evlist);
|
|
|
|
if (err < 0) {
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, "Problems initializing symbol libraries!\n");
|
2014-01-04 01:56:06 +07:00
|
|
|
goto out_delete_evlist;
|
perf trace: Support interrupted syscalls
Using the same strategies as in the tmp.perf/trace2, i.e. the 'trace'
tool implemented by tglx, just updated to the current codebase.
Example:
[root@sandy linux]# perf trace usleep 1 | tail
2.003: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128396288
2.017: mmap(addr: 0, len: 4096, prot: 3, flags: 34, fd: 4294967295, off: 0 ) = -2128400384
2.029: arch_prctl(option: 4098, arg2: 140146949441280, arg3: 140146949435392, arg4: 34, arg5: 4294967295) = 0
2.084: mprotect(start: 208741634048, len: 16384, prot: 1 ) = 0
2.098: mprotect(start: 208735956992, len: 4096, prot: 1 ) = 0
2.122: munmap(addr: 140146949447680, len: 91882 ) = 0
2.359: brk(brk: 0 ) = 28987392
2.371: brk(brk: 29122560 ) = 29122560
2.490: nanosleep(rqtp: 140735694241504, rmtp: 0 ) = 0
2.507: exit_group(error_code: 0
[root@sandy linux]#
For now the timestamp and duration are always on, will be selectable.
Also if multiple threads are being monitored, its tid will appear.
The ret output continues to be interpreted a la strace.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-ly9ulroru4my5isn0xe9gr0m@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-07 04:43:19 +07:00
|
|
|
}
|
|
|
|
|
2012-12-11 02:41:31 +07:00
|
|
|
perf_evlist__config(evlist, &trace->opts);
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2012-10-05 12:02:16 +07:00
|
|
|
signal(SIGCHLD, sig_handler);
|
|
|
|
signal(SIGINT, sig_handler);
|
|
|
|
|
|
|
|
if (forks) {
|
2013-03-11 14:43:15 +07:00
|
|
|
err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
|
2014-01-04 00:56:49 +07:00
|
|
|
argv, false, NULL);
|
2012-10-05 12:02:16 +07:00
|
|
|
if (err < 0) {
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, "Couldn't run the workload!\n");
|
2014-01-04 01:56:06 +07:00
|
|
|
goto out_delete_evlist;
|
2012-10-05 12:02:16 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-27 06:05:56 +07:00
|
|
|
err = perf_evlist__open(evlist);
|
perf trace: Improve messages related to /proc/sys/kernel/perf_event_paranoid
kernel/events/core.c has:
/*
* perf event paranoia level:
* -1 - not paranoid at all
* 0 - disallow raw tracepoint access for unpriv
* 1 - disallow cpu events for unpriv
* 2 - disallow kernel profiling for unpriv
*/
int sysctl_perf_event_paranoid __read_mostly = 1;
So, with the default being 1, a non-root user can trace his stuff:
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
1
[acme@zoo ~]$ yes > /dev/null &
[1] 15338
[acme@zoo ~]$ trace -p 15338 | head -5
0.005 ( 0.005 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.045 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.085 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.125 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.165 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
[acme@zoo ~]$
[acme@zoo ~]$ trace --duration 1 sleep 1
1002.148 (1001.218 ms): nanosleep(rqtp: 0x7fff46c79250 ) = 0
[acme@zoo ~]$
[acme@zoo ~]$ trace -- usleep 1 | tail -5
0.905 ( 0.002 ms): brk( ) = 0x1c82000
0.910 ( 0.003 ms): brk(brk: 0x1ca3000 ) = 0x1ca3000
0.913 ( 0.001 ms): brk( ) = 0x1ca3000
0.990 ( 0.059 ms): nanosleep(rqtp: 0x7fffe31a3280 ) = 0
0.995 ( 0.000 ms): exit_group(
[acme@zoo ~]$
But can't do system wide tracing:
[acme@zoo ~]$ trace
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 0
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
If the paranoid level is >= 2, i.e. turn this perf stuff off for !root users:
[acme@zoo ~]$ sudo sh -c 'echo 2 > /proc/sys/kernel/perf_event_paranoid'
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
2
[acme@zoo ~]$
[acme@zoo ~]$ trace usleep 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
If the user manages to get what he/she wants, convincing root not
to be paranoid at all...
[root@zoo ~]# echo -1 > /proc/sys/kernel/perf_event_paranoid
[root@zoo ~]# cat /proc/sys/kernel/perf_event_paranoid
-1
[root@zoo ~]#
[acme@zoo ~]$ ps -eo user,pid,comm | grep Xorg
root 729 Xorg
[acme@zoo ~]$
[acme@zoo ~]$ trace -a --duration 0.001 -e \!select,ioctl,writev | grep Xorg | head -5
23.143 ( 0.003 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.152 ( 0.004 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = 8
23.161 ( 0.002 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = -1 EAGAIN Resource temporarily unavailable
23.175 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.235 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
[acme@zoo ~]$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-di28olfwd28rvkox7v3hqhu1@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-18 03:38:29 +07:00
|
|
|
if (err < 0)
|
|
|
|
goto out_error_open;
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2015-02-22 01:15:21 +07:00
|
|
|
/*
|
|
|
|
* Better not use !target__has_task() here because we need to cover the
|
|
|
|
* case where no threads were specified in the command line, but a
|
|
|
|
* workload was, and in that case we will fill in the thread_map when
|
|
|
|
* we fork the workload in perf_evlist__prepare_workload.
|
|
|
|
*/
|
perf trace: Introduce --filter-pids
When tracing in X we get event loops due to the tracing activity, i.e.
updates to a gnome-terminal that generate syscalls for X.org, etc.
To get a more useful view of what is happening, syscall wise, system
wide, we need to filter those, like in:
# ps ax|egrep '981|2296|1519' | grep -v egrep
981 tty1 Ss+ 5:40 /usr/bin/Xorg :0 -background none ...
1519 ? Sl 2:22 /usr/bin/gnome-shell
2296 ? Sl 4:16 /usr/libexec/gnome-terminal-server
#
# trace -e write --filter-pids 981,2296,1519
0.385 ( 0.021 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 136) = 136
0.922 ( 0.014 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 140) = 140
5006.525 ( 0.029 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 136) = 136
5007.235 ( 0.023 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 140) = 140
5177.646 ( 0.018 ms): rtkit-daemon/782 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7f7eea70be88, count: 8) = 8
8314.497 ( 0.004 ms): gsd-locate-poi/2084 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7fffe96af7b0, count: 8) = 8
8314.518 ( 0.002 ms): gsd-locate-poi/2084 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7fffe96af0e0, count: 8) = 8
^C#
When this option is used the tracer pid is also filtered.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-f5qmiyy7c0uxdm21ncatpeek@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-22 02:36:52 +07:00
|
|
|
if (trace->filter_pids.nr > 0)
|
|
|
|
err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
|
|
|
|
else if (evlist->threads->map[0] == -1)
|
|
|
|
err = perf_evlist__set_filter_pid(evlist, getpid());
|
|
|
|
|
|
|
|
if (err < 0) {
|
|
|
|
printf("err=%d,%s\n", -err, strerror(-err));
|
|
|
|
exit(1);
|
|
|
|
}
|
2015-02-22 01:15:21 +07:00
|
|
|
|
2013-11-28 23:57:22 +07:00
|
|
|
err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
|
2014-12-12 04:04:10 +07:00
|
|
|
if (err < 0)
|
|
|
|
goto out_error_mmap;
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2015-04-22 20:04:23 +07:00
|
|
|
if (!target__none(&trace->opts.target))
|
|
|
|
perf_evlist__enable(evlist);
|
|
|
|
|
2012-10-05 12:02:16 +07:00
|
|
|
if (forks)
|
|
|
|
perf_evlist__start_workload(evlist);
|
|
|
|
|
2015-02-13 22:32:45 +07:00
|
|
|
trace->multiple_threads = evlist->threads->map[0] == -1 ||
|
|
|
|
evlist->threads->nr > 1 ||
|
|
|
|
perf_evlist__first(evlist)->attr.inherit;
|
2012-09-27 06:05:56 +07:00
|
|
|
again:
|
2012-10-18 03:09:46 +07:00
|
|
|
before = trace->nr_events;
|
2012-09-27 06:05:56 +07:00
|
|
|
|
|
|
|
for (i = 0; i < evlist->nr_mmaps; i++) {
|
|
|
|
union perf_event *event;
|
|
|
|
|
|
|
|
while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
|
|
|
|
struct perf_sample sample;
|
|
|
|
|
2012-10-18 03:09:46 +07:00
|
|
|
++trace->nr_events;
|
2012-09-27 06:05:56 +07:00
|
|
|
|
|
|
|
err = perf_evlist__parse_sample(evlist, event, &sample);
|
|
|
|
if (err) {
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
|
2013-10-24 14:43:33 +07:00
|
|
|
goto next_event;
|
2012-09-27 06:05:56 +07:00
|
|
|
}
|
|
|
|
|
2015-02-22 03:10:29 +07:00
|
|
|
trace__handle_event(trace, event, &sample);
|
2013-10-24 14:43:33 +07:00
|
|
|
next_event:
|
|
|
|
perf_evlist__mmap_consume(evlist, i);
|
2013-09-03 21:55:07 +07:00
|
|
|
|
2013-10-16 21:57:33 +07:00
|
|
|
if (interrupted)
|
|
|
|
goto out_disable;
|
2012-09-27 06:05:56 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-18 03:09:46 +07:00
|
|
|
if (trace->nr_events == before) {
|
2013-10-16 21:57:33 +07:00
|
|
|
int timeout = done ? 100 : -1;
|
2012-10-05 12:02:16 +07:00
|
|
|
|
2014-09-23 00:39:48 +07:00
|
|
|
if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
|
|
|
|
if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
|
|
|
|
draining = true;
|
|
|
|
|
2013-10-16 21:57:33 +07:00
|
|
|
goto again;
|
2014-09-23 00:39:48 +07:00
|
|
|
}
|
2013-10-16 21:57:33 +07:00
|
|
|
} else {
|
|
|
|
goto again;
|
2012-10-05 12:02:16 +07:00
|
|
|
}
|
|
|
|
|
2013-10-16 21:57:33 +07:00
|
|
|
out_disable:
|
2015-03-03 08:21:35 +07:00
|
|
|
thread__zput(trace->current);
|
|
|
|
|
2013-10-16 21:57:33 +07:00
|
|
|
perf_evlist__disable(evlist);
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2013-09-28 04:06:19 +07:00
|
|
|
if (!err) {
|
|
|
|
if (trace->summary)
|
|
|
|
trace__fprintf_thread_summary(trace, trace->output);
|
|
|
|
|
|
|
|
if (trace->show_tool_stats) {
|
|
|
|
fprintf(trace->output, "Stats:\n "
|
|
|
|
" vfs_getname : %" PRIu64 "\n"
|
|
|
|
" proc_getname: %" PRIu64 "\n",
|
|
|
|
trace->stats.vfs_getname,
|
|
|
|
trace->stats.proc_getname);
|
|
|
|
}
|
|
|
|
}
|
2013-10-09 10:26:53 +07:00
|
|
|
|
2012-09-27 06:05:56 +07:00
|
|
|
out_delete_evlist:
|
|
|
|
perf_evlist__delete(evlist);
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
trace->evlist = NULL;
|
2013-09-24 21:04:32 +07:00
|
|
|
trace->live = false;
|
2012-09-27 06:05:56 +07:00
|
|
|
return err;
|
2013-10-17 22:07:58 +07:00
|
|
|
{
|
|
|
|
char errbuf[BUFSIZ];
|
perf trace: Improve messages related to /proc/sys/kernel/perf_event_paranoid
kernel/events/core.c has:
/*
* perf event paranoia level:
* -1 - not paranoid at all
* 0 - disallow raw tracepoint access for unpriv
* 1 - disallow cpu events for unpriv
* 2 - disallow kernel profiling for unpriv
*/
int sysctl_perf_event_paranoid __read_mostly = 1;
So, with the default being 1, a non-root user can trace his stuff:
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
1
[acme@zoo ~]$ yes > /dev/null &
[1] 15338
[acme@zoo ~]$ trace -p 15338 | head -5
0.005 ( 0.005 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.045 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.085 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.125 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.165 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
[acme@zoo ~]$
[acme@zoo ~]$ trace --duration 1 sleep 1
1002.148 (1001.218 ms): nanosleep(rqtp: 0x7fff46c79250 ) = 0
[acme@zoo ~]$
[acme@zoo ~]$ trace -- usleep 1 | tail -5
0.905 ( 0.002 ms): brk( ) = 0x1c82000
0.910 ( 0.003 ms): brk(brk: 0x1ca3000 ) = 0x1ca3000
0.913 ( 0.001 ms): brk( ) = 0x1ca3000
0.990 ( 0.059 ms): nanosleep(rqtp: 0x7fffe31a3280 ) = 0
0.995 ( 0.000 ms): exit_group(
[acme@zoo ~]$
But can't do system wide tracing:
[acme@zoo ~]$ trace
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 0
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
If the paranoid level is >= 2, i.e. turn this perf stuff off for !root users:
[acme@zoo ~]$ sudo sh -c 'echo 2 > /proc/sys/kernel/perf_event_paranoid'
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
2
[acme@zoo ~]$
[acme@zoo ~]$ trace usleep 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
If the user manages to get what he/she wants, convincing root not
to be paranoid at all...
[root@zoo ~]# echo -1 > /proc/sys/kernel/perf_event_paranoid
[root@zoo ~]# cat /proc/sys/kernel/perf_event_paranoid
-1
[root@zoo ~]#
[acme@zoo ~]$ ps -eo user,pid,comm | grep Xorg
root 729 Xorg
[acme@zoo ~]$
[acme@zoo ~]$ trace -a --duration 0.001 -e \!select,ioctl,writev | grep Xorg | head -5
23.143 ( 0.003 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.152 ( 0.004 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = 8
23.161 ( 0.002 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = -1 EAGAIN Resource temporarily unavailable
23.175 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.235 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
[acme@zoo ~]$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-di28olfwd28rvkox7v3hqhu1@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-18 03:38:29 +07:00
|
|
|
|
2015-01-22 21:13:43 +07:00
|
|
|
out_error_sched_stat_runtime:
|
|
|
|
debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
|
|
|
|
goto out_error;
|
|
|
|
|
2015-01-22 20:52:55 +07:00
|
|
|
out_error_raw_syscalls:
|
2015-01-22 21:13:43 +07:00
|
|
|
debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
|
perf trace: Improve messages related to /proc/sys/kernel/perf_event_paranoid
kernel/events/core.c has:
/*
* perf event paranoia level:
* -1 - not paranoid at all
* 0 - disallow raw tracepoint access for unpriv
* 1 - disallow cpu events for unpriv
* 2 - disallow kernel profiling for unpriv
*/
int sysctl_perf_event_paranoid __read_mostly = 1;
So, with the default being 1, a non-root user can trace his stuff:
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
1
[acme@zoo ~]$ yes > /dev/null &
[1] 15338
[acme@zoo ~]$ trace -p 15338 | head -5
0.005 ( 0.005 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.045 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.085 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.125 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.165 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
[acme@zoo ~]$
[acme@zoo ~]$ trace --duration 1 sleep 1
1002.148 (1001.218 ms): nanosleep(rqtp: 0x7fff46c79250 ) = 0
[acme@zoo ~]$
[acme@zoo ~]$ trace -- usleep 1 | tail -5
0.905 ( 0.002 ms): brk( ) = 0x1c82000
0.910 ( 0.003 ms): brk(brk: 0x1ca3000 ) = 0x1ca3000
0.913 ( 0.001 ms): brk( ) = 0x1ca3000
0.990 ( 0.059 ms): nanosleep(rqtp: 0x7fffe31a3280 ) = 0
0.995 ( 0.000 ms): exit_group(
[acme@zoo ~]$
But can't do system wide tracing:
[acme@zoo ~]$ trace
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 0
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
If the paranoid level is >= 2, i.e. turn this perf stuff off for !root users:
[acme@zoo ~]$ sudo sh -c 'echo 2 > /proc/sys/kernel/perf_event_paranoid'
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
2
[acme@zoo ~]$
[acme@zoo ~]$ trace usleep 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
If the user manages to get what he/she wants, convincing root not
to be paranoid at all...
[root@zoo ~]# echo -1 > /proc/sys/kernel/perf_event_paranoid
[root@zoo ~]# cat /proc/sys/kernel/perf_event_paranoid
-1
[root@zoo ~]#
[acme@zoo ~]$ ps -eo user,pid,comm | grep Xorg
root 729 Xorg
[acme@zoo ~]$
[acme@zoo ~]$ trace -a --duration 0.001 -e \!select,ioctl,writev | grep Xorg | head -5
23.143 ( 0.003 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.152 ( 0.004 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = 8
23.161 ( 0.002 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = -1 EAGAIN Resource temporarily unavailable
23.175 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.235 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
[acme@zoo ~]$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-di28olfwd28rvkox7v3hqhu1@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-18 03:38:29 +07:00
|
|
|
goto out_error;
|
|
|
|
|
2014-12-12 04:04:10 +07:00
|
|
|
out_error_mmap:
|
|
|
|
perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
|
|
|
|
goto out_error;
|
|
|
|
|
perf trace: Improve messages related to /proc/sys/kernel/perf_event_paranoid
kernel/events/core.c has:
/*
* perf event paranoia level:
* -1 - not paranoid at all
* 0 - disallow raw tracepoint access for unpriv
* 1 - disallow cpu events for unpriv
* 2 - disallow kernel profiling for unpriv
*/
int sysctl_perf_event_paranoid __read_mostly = 1;
So, with the default being 1, a non-root user can trace his stuff:
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
1
[acme@zoo ~]$ yes > /dev/null &
[1] 15338
[acme@zoo ~]$ trace -p 15338 | head -5
0.005 ( 0.005 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.045 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.085 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.125 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.165 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
[acme@zoo ~]$
[acme@zoo ~]$ trace --duration 1 sleep 1
1002.148 (1001.218 ms): nanosleep(rqtp: 0x7fff46c79250 ) = 0
[acme@zoo ~]$
[acme@zoo ~]$ trace -- usleep 1 | tail -5
0.905 ( 0.002 ms): brk( ) = 0x1c82000
0.910 ( 0.003 ms): brk(brk: 0x1ca3000 ) = 0x1ca3000
0.913 ( 0.001 ms): brk( ) = 0x1ca3000
0.990 ( 0.059 ms): nanosleep(rqtp: 0x7fffe31a3280 ) = 0
0.995 ( 0.000 ms): exit_group(
[acme@zoo ~]$
But can't do system wide tracing:
[acme@zoo ~]$ trace
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 0
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
If the paranoid level is >= 2, i.e. turn this perf stuff off for !root users:
[acme@zoo ~]$ sudo sh -c 'echo 2 > /proc/sys/kernel/perf_event_paranoid'
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
2
[acme@zoo ~]$
[acme@zoo ~]$ trace usleep 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
If the user manages to get what he/she wants, convincing root not
to be paranoid at all...
[root@zoo ~]# echo -1 > /proc/sys/kernel/perf_event_paranoid
[root@zoo ~]# cat /proc/sys/kernel/perf_event_paranoid
-1
[root@zoo ~]#
[acme@zoo ~]$ ps -eo user,pid,comm | grep Xorg
root 729 Xorg
[acme@zoo ~]$
[acme@zoo ~]$ trace -a --duration 0.001 -e \!select,ioctl,writev | grep Xorg | head -5
23.143 ( 0.003 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.152 ( 0.004 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = 8
23.161 ( 0.002 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = -1 EAGAIN Resource temporarily unavailable
23.175 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.235 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
[acme@zoo ~]$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-di28olfwd28rvkox7v3hqhu1@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-18 03:38:29 +07:00
|
|
|
out_error_open:
|
|
|
|
perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
|
|
|
|
|
|
|
|
out_error:
|
2013-10-17 22:07:58 +07:00
|
|
|
fprintf(trace->output, "%s\n", errbuf);
|
2013-10-04 12:17:31 +07:00
|
|
|
goto out_delete_evlist;
|
2012-09-27 06:05:56 +07:00
|
|
|
}
|
2015-01-22 21:08:04 +07:00
|
|
|
out_error_mem:
|
|
|
|
fprintf(trace->output, "Not enough memory to run!\n");
|
|
|
|
goto out_delete_evlist;
|
perf trace: Improve messages related to /proc/sys/kernel/perf_event_paranoid
kernel/events/core.c has:
/*
* perf event paranoia level:
* -1 - not paranoid at all
* 0 - disallow raw tracepoint access for unpriv
* 1 - disallow cpu events for unpriv
* 2 - disallow kernel profiling for unpriv
*/
int sysctl_perf_event_paranoid __read_mostly = 1;
So, with the default being 1, a non-root user can trace his stuff:
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
1
[acme@zoo ~]$ yes > /dev/null &
[1] 15338
[acme@zoo ~]$ trace -p 15338 | head -5
0.005 ( 0.005 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.045 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.085 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.125 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
0.165 ( 0.001 ms): write(fd: 1</dev/null>, buf: 0x7fe6db765000, count: 4096 ) = 4096
[acme@zoo ~]$
[acme@zoo ~]$ trace --duration 1 sleep 1
1002.148 (1001.218 ms): nanosleep(rqtp: 0x7fff46c79250 ) = 0
[acme@zoo ~]$
[acme@zoo ~]$ trace -- usleep 1 | tail -5
0.905 ( 0.002 ms): brk( ) = 0x1c82000
0.910 ( 0.003 ms): brk(brk: 0x1ca3000 ) = 0x1ca3000
0.913 ( 0.001 ms): brk( ) = 0x1ca3000
0.990 ( 0.059 ms): nanosleep(rqtp: 0x7fffe31a3280 ) = 0
0.995 ( 0.000 ms): exit_group(
[acme@zoo ~]$
But can't do system wide tracing:
[acme@zoo ~]$ trace
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 0
Error: Operation not permitted.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 1.
[acme@zoo ~]$
If the paranoid level is >= 2, i.e. turn this perf stuff off for !root users:
[acme@zoo ~]$ sudo sh -c 'echo 2 > /proc/sys/kernel/perf_event_paranoid'
[acme@zoo ~]$ cat /proc/sys/kernel/perf_event_paranoid
2
[acme@zoo ~]$
[acme@zoo ~]$ trace usleep 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
[acme@zoo ~]$ trace --cpu 1
Error: Permission denied.
Hint: Check /proc/sys/kernel/perf_event_paranoid setting.
Hint: For your workloads it needs to be <= 1
Hint: For system wide tracing it needs to be set to -1.
Hint: The current value is 2.
[acme@zoo ~]$
If the user manages to get what he/she wants, convincing root not
to be paranoid at all...
[root@zoo ~]# echo -1 > /proc/sys/kernel/perf_event_paranoid
[root@zoo ~]# cat /proc/sys/kernel/perf_event_paranoid
-1
[root@zoo ~]#
[acme@zoo ~]$ ps -eo user,pid,comm | grep Xorg
root 729 Xorg
[acme@zoo ~]$
[acme@zoo ~]$ trace -a --duration 0.001 -e \!select,ioctl,writev | grep Xorg | head -5
23.143 ( 0.003 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.152 ( 0.004 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = 8
23.161 ( 0.002 ms): Xorg/729 read(fd: 31, buf: 0x2544af0, count: 4096 ) = -1 EAGAIN Resource temporarily unavailable
23.175 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
23.235 ( 0.002 ms): Xorg/729 setitimer(which: REAL, value: 0x7fffaadf16e0 ) = 0
[acme@zoo ~]$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-di28olfwd28rvkox7v3hqhu1@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-10-18 03:38:29 +07:00
|
|
|
}
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2013-08-29 11:29:52 +07:00
|
|
|
static int trace__replay(struct trace *trace)
|
|
|
|
{
|
|
|
|
const struct perf_evsel_str_handler handlers[] = {
|
2013-09-28 04:06:19 +07:00
|
|
|
{ "probe:vfs_getname", trace__vfs_getname, },
|
2013-08-29 11:29:52 +07:00
|
|
|
};
|
2013-10-15 21:27:32 +07:00
|
|
|
struct perf_data_file file = {
|
|
|
|
.path = input_name,
|
|
|
|
.mode = PERF_DATA_MODE_READ,
|
perf trace: Support using -f to override perf.data file ownership
Enable perf trace to use perf.data when it is not owned by current user
or root.
Example:
# perf trace record ls
# chown Yunlong.Song:Yunlong.Song perf.data
# ls -al perf.data
-rw------- 1 Yunlong.Song Yunlong.Song 4153101 Apr 2 15:28 perf.data
# id
uid=0(root) gid=0(root) groups=0(root),64(pkcs11)
Before this patch:
# perf trace -i perf.data
File perf.data not owned by current user or root (use -f to override)
# perf trace -i perf.data -f
Error: unknown switch `f'
usage: perf trace [<options>] [<command>]
or: perf trace [<options>] -- <command> [<options>]
or: perf trace record [<options>] [<command>]
or: perf trace record [<options>] -- <command> [<options>]
--event <event> event selector. use 'perf list' to list
available events
--comm show the thread COMM next to its id
--tool_stats show tool stats
-e, --expr <expr> list of events to trace
-o, --output <file> output file name
-i, --input <file> Analyze events in file
-p, --pid <pid> trace events on existing process id
-t, --tid <tid> trace events on existing thread id
--filter-pids <float>
...
As shown above, the -f option does not work at all.
After this patch:
# perf trace -i perf.data
File perf.data not owned by current user or root (use -f to override)
# perf trace -i perf.data -f
0.056 ( 0.002 ms): ls/47325 brk( ...
0.108 ( 0.018 ms): ls/47325 mmap(len: 4096, prot: READ|WRITE, ...
0.145 ( 0.013 ms): ls/47325 access(filename: 0x7f31259a0eb0, ...
0.172 ( 0.008 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.180 ( 0.004 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.185 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.189 ( 0.003 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.195 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.199 ( 0.002 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.205 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.211 ( 0.004 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.220 ( 0.007 ms): ls/47325 open(filename: 0x7f312599e8ff, ...
...
...
As shown above, the -f option really works now.
Signed-off-by: Yunlong Song <yunlong.song@huawei.com>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1427982439-27388-10-git-send-email-yunlong.song@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-02 20:47:18 +07:00
|
|
|
.force = trace->force,
|
2013-10-15 21:27:32 +07:00
|
|
|
};
|
2013-08-29 11:29:52 +07:00
|
|
|
struct perf_session *session;
|
2013-11-12 13:25:00 +07:00
|
|
|
struct perf_evsel *evsel;
|
2013-08-29 11:29:52 +07:00
|
|
|
int err = -1;
|
|
|
|
|
|
|
|
trace->tool.sample = trace__process_sample;
|
|
|
|
trace->tool.mmap = perf_event__process_mmap;
|
2013-09-23 08:44:58 +07:00
|
|
|
trace->tool.mmap2 = perf_event__process_mmap2;
|
2013-08-29 11:29:52 +07:00
|
|
|
trace->tool.comm = perf_event__process_comm;
|
|
|
|
trace->tool.exit = perf_event__process_exit;
|
|
|
|
trace->tool.fork = perf_event__process_fork;
|
|
|
|
trace->tool.attr = perf_event__process_attr;
|
|
|
|
trace->tool.tracing_data = perf_event__process_tracing_data;
|
|
|
|
trace->tool.build_id = perf_event__process_build_id;
|
|
|
|
|
2014-07-06 19:18:21 +07:00
|
|
|
trace->tool.ordered_events = true;
|
2013-08-29 11:29:52 +07:00
|
|
|
trace->tool.ordering_requires_timestamps = true;
|
|
|
|
|
|
|
|
/* add tid to output */
|
|
|
|
trace->multiple_threads = true;
|
|
|
|
|
2013-10-15 21:27:32 +07:00
|
|
|
session = perf_session__new(&file, false, &trace->tool);
|
2013-08-29 11:29:52 +07:00
|
|
|
if (session == NULL)
|
2014-09-24 08:33:37 +07:00
|
|
|
return -1;
|
2013-08-29 11:29:52 +07:00
|
|
|
|
2014-08-12 13:40:45 +07:00
|
|
|
if (symbol__init(&session->header.env) < 0)
|
2014-08-12 13:40:44 +07:00
|
|
|
goto out;
|
|
|
|
|
2013-09-29 02:13:00 +07:00
|
|
|
trace->host = &session->machines.host;
|
|
|
|
|
2013-08-29 11:29:52 +07:00
|
|
|
err = perf_session__set_tracepoints_handlers(session, handlers);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2013-11-12 13:25:00 +07:00
|
|
|
evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
|
|
|
|
"raw_syscalls:sys_enter");
|
2013-12-05 09:41:39 +07:00
|
|
|
/* older kernels have syscalls tp versus raw_syscalls */
|
|
|
|
if (evsel == NULL)
|
|
|
|
evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
|
|
|
|
"syscalls:sys_enter");
|
2013-11-12 13:25:00 +07:00
|
|
|
|
2014-06-26 23:14:28 +07:00
|
|
|
if (evsel &&
|
|
|
|
(perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
|
|
|
|
perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
|
2013-11-12 13:25:00 +07:00
|
|
|
pr_err("Error during initialize raw_syscalls:sys_enter event\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
|
|
|
|
"raw_syscalls:sys_exit");
|
2013-12-05 09:41:39 +07:00
|
|
|
if (evsel == NULL)
|
|
|
|
evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
|
|
|
|
"syscalls:sys_exit");
|
2014-06-26 23:14:28 +07:00
|
|
|
if (evsel &&
|
|
|
|
(perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
|
|
|
|
perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
|
2013-11-12 13:25:00 +07:00
|
|
|
pr_err("Error during initialize raw_syscalls:sys_exit event\n");
|
2013-08-29 11:29:52 +07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-06-26 23:14:26 +07:00
|
|
|
evlist__for_each(session->evlist, evsel) {
|
|
|
|
if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
|
|
|
|
(evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
|
|
|
|
evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
|
|
|
|
evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
|
|
|
|
evsel->handler = trace__pgfault;
|
|
|
|
}
|
|
|
|
|
2013-08-29 11:29:53 +07:00
|
|
|
err = parse_target_str(trace);
|
|
|
|
if (err != 0)
|
|
|
|
goto out;
|
|
|
|
|
2013-08-29 11:29:52 +07:00
|
|
|
setup_pager();
|
|
|
|
|
2015-03-03 21:58:45 +07:00
|
|
|
err = perf_session__process_events(session);
|
2013-08-29 11:29:52 +07:00
|
|
|
if (err)
|
|
|
|
pr_err("Failed to process events, error %d", err);
|
|
|
|
|
2013-10-09 10:26:53 +07:00
|
|
|
else if (trace->summary)
|
|
|
|
trace__fprintf_thread_summary(trace, trace->output);
|
|
|
|
|
2013-08-29 11:29:52 +07:00
|
|
|
out:
|
|
|
|
perf_session__delete(session);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-10-18 03:13:12 +07:00
|
|
|
static size_t trace__fprintf_threads_header(FILE *fp)
|
|
|
|
{
|
|
|
|
size_t printed;
|
|
|
|
|
2013-11-12 21:42:14 +07:00
|
|
|
printed = fprintf(fp, "\n Summary of events:\n\n");
|
2013-10-09 10:26:53 +07:00
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t thread__dump_stats(struct thread_trace *ttrace,
|
|
|
|
struct trace *trace, FILE *fp)
|
|
|
|
{
|
|
|
|
struct stats *stats;
|
|
|
|
size_t printed = 0;
|
|
|
|
struct syscall *sc;
|
|
|
|
struct int_node *inode = intlist__first(ttrace->syscall_stats);
|
|
|
|
|
|
|
|
if (inode == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
printed += fprintf(fp, "\n");
|
|
|
|
|
2013-11-13 19:21:48 +07:00
|
|
|
printed += fprintf(fp, " syscall calls min avg max stddev\n");
|
|
|
|
printed += fprintf(fp, " (msec) (msec) (msec) (%%)\n");
|
|
|
|
printed += fprintf(fp, " --------------- -------- --------- --------- --------- ------\n");
|
2013-11-12 21:42:14 +07:00
|
|
|
|
2013-10-09 10:26:53 +07:00
|
|
|
/* each int_node is a syscall */
|
|
|
|
while (inode) {
|
|
|
|
stats = inode->priv;
|
|
|
|
if (stats) {
|
|
|
|
double min = (double)(stats->min) / NSEC_PER_MSEC;
|
|
|
|
double max = (double)(stats->max) / NSEC_PER_MSEC;
|
|
|
|
double avg = avg_stats(stats);
|
|
|
|
double pct;
|
|
|
|
u64 n = (u64) stats->n;
|
|
|
|
|
|
|
|
pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
|
|
|
|
avg /= NSEC_PER_MSEC;
|
|
|
|
|
|
|
|
sc = &trace->syscalls.table[inode->i];
|
2013-11-12 21:42:14 +07:00
|
|
|
printed += fprintf(fp, " %-15s", sc->name);
|
2013-11-13 19:21:48 +07:00
|
|
|
printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f",
|
2013-11-12 21:10:10 +07:00
|
|
|
n, min, avg);
|
2013-11-13 19:21:48 +07:00
|
|
|
printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
|
2013-10-09 10:26:53 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
inode = intlist__next(inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
printed += fprintf(fp, "\n\n");
|
2012-10-18 03:13:12 +07:00
|
|
|
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
2013-09-29 02:12:59 +07:00
|
|
|
/* struct used to pass data to per-thread function */
|
|
|
|
struct summary_data {
|
|
|
|
FILE *fp;
|
|
|
|
struct trace *trace;
|
|
|
|
size_t printed;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int trace__fprintf_one_thread(struct thread *thread, void *priv)
|
|
|
|
{
|
|
|
|
struct summary_data *data = priv;
|
|
|
|
FILE *fp = data->fp;
|
|
|
|
size_t printed = data->printed;
|
|
|
|
struct trace *trace = data->trace;
|
2014-10-06 07:46:03 +07:00
|
|
|
struct thread_trace *ttrace = thread__priv(thread);
|
2013-09-29 02:12:59 +07:00
|
|
|
double ratio;
|
|
|
|
|
|
|
|
if (ttrace == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
|
|
|
|
|
2013-11-14 23:43:30 +07:00
|
|
|
printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
|
2013-11-12 21:42:14 +07:00
|
|
|
printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
|
2013-11-14 23:43:30 +07:00
|
|
|
printed += fprintf(fp, "%.1f%%", ratio);
|
2014-07-09 01:05:16 +07:00
|
|
|
if (ttrace->pfmaj)
|
|
|
|
printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
|
|
|
|
if (ttrace->pfmin)
|
|
|
|
printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
|
2013-11-12 21:42:14 +07:00
|
|
|
printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
|
2013-10-09 10:26:53 +07:00
|
|
|
printed += thread__dump_stats(ttrace, trace, fp);
|
2013-09-29 02:12:59 +07:00
|
|
|
|
|
|
|
data->printed += printed;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-18 03:13:12 +07:00
|
|
|
static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
|
|
|
|
{
|
2013-09-29 02:12:59 +07:00
|
|
|
struct summary_data data = {
|
|
|
|
.fp = fp,
|
|
|
|
.trace = trace
|
|
|
|
};
|
|
|
|
data.printed = trace__fprintf_threads_header(fp);
|
2012-10-18 03:13:12 +07:00
|
|
|
|
2013-09-29 02:12:59 +07:00
|
|
|
machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
|
|
|
|
|
|
|
|
return data.printed;
|
2012-10-18 03:13:12 +07:00
|
|
|
}
|
|
|
|
|
perf trace: Add duration filter
Example:
[acme@sandy linux]$ perf trace --duration 0.025 usleep 1
2.221 ( 0.958 ms): 6724 execve(arg0: 140733557168278, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = -2
3.690 ( 1.443 ms): 6724 execve(arg0: 140733557168295, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = 0
3.979 ( 0.048 ms): 6724 open(filename: 208733843841, flags: 0, mode: 1 ) = 3
4.071 ( 0.075 ms): 6724 open(filename: 139744419925673, flags: 0, mode: 0 ) = 3
4.318 ( 0.056 ms): 6724 nanosleep(rqtp: 140734030404608, rmtp: 0 ) = 0
[acme@sandy linux]$ perf trace --duration 0.100 usleep 1
1.143 ( 1.021 ms): 6726 execve(arg0: 140736323962279, arg1: 140736323972752, arg2: 34926752, arg3: 140736323961824, arg4: 7955998171588342573, arg5: 6725) = 0
[acme@sandy linux]$
Cherry picked from tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-oslw2j2958we9qf0ctra4whd@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-08 19:56:00 +07:00
|
|
|
static int trace__set_duration(const struct option *opt, const char *str,
|
|
|
|
int unset __maybe_unused)
|
|
|
|
{
|
|
|
|
struct trace *trace = opt->value;
|
|
|
|
|
|
|
|
trace->duration_filter = atof(str);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
perf trace: Introduce --filter-pids
When tracing in X we get event loops due to the tracing activity, i.e.
updates to a gnome-terminal that generate syscalls for X.org, etc.
To get a more useful view of what is happening, syscall wise, system
wide, we need to filter those, like in:
# ps ax|egrep '981|2296|1519' | grep -v egrep
981 tty1 Ss+ 5:40 /usr/bin/Xorg :0 -background none ...
1519 ? Sl 2:22 /usr/bin/gnome-shell
2296 ? Sl 4:16 /usr/libexec/gnome-terminal-server
#
# trace -e write --filter-pids 981,2296,1519
0.385 ( 0.021 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 136) = 136
0.922 ( 0.014 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 140) = 140
5006.525 ( 0.029 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 136) = 136
5007.235 ( 0.023 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 140) = 140
5177.646 ( 0.018 ms): rtkit-daemon/782 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7f7eea70be88, count: 8) = 8
8314.497 ( 0.004 ms): gsd-locate-poi/2084 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7fffe96af7b0, count: 8) = 8
8314.518 ( 0.002 ms): gsd-locate-poi/2084 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7fffe96af0e0, count: 8) = 8
^C#
When this option is used the tracer pid is also filtered.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-f5qmiyy7c0uxdm21ncatpeek@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-22 02:36:52 +07:00
|
|
|
static int trace__set_filter_pids(const struct option *opt, const char *str,
|
|
|
|
int unset __maybe_unused)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
size_t i;
|
|
|
|
struct trace *trace = opt->value;
|
|
|
|
/*
|
|
|
|
* FIXME: introduce a intarray class, plain parse csv and create a
|
|
|
|
* { int nr, int entries[] } struct...
|
|
|
|
*/
|
|
|
|
struct intlist *list = intlist__new(str);
|
|
|
|
|
|
|
|
if (list == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
|
|
|
|
trace->filter_pids.entries = calloc(i, sizeof(pid_t));
|
|
|
|
|
|
|
|
if (trace->filter_pids.entries == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
trace->filter_pids.entries[0] = getpid();
|
|
|
|
|
|
|
|
for (i = 1; i < trace->filter_pids.nr; ++i)
|
|
|
|
trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
|
|
|
|
|
|
|
|
intlist__delete(list);
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
static int trace__open_output(struct trace *trace, const char *filename)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (!stat(filename, &st) && st.st_size) {
|
|
|
|
char oldname[PATH_MAX];
|
|
|
|
|
|
|
|
scnprintf(oldname, sizeof(oldname), "%s.old", filename);
|
|
|
|
unlink(oldname);
|
|
|
|
rename(filename, oldname);
|
|
|
|
}
|
|
|
|
|
|
|
|
trace->output = fopen(filename, "w");
|
|
|
|
|
|
|
|
return trace->output == NULL ? -errno : 0;
|
|
|
|
}
|
|
|
|
|
2014-06-26 23:14:25 +07:00
|
|
|
static int parse_pagefaults(const struct option *opt, const char *str,
|
|
|
|
int unset __maybe_unused)
|
|
|
|
{
|
|
|
|
int *trace_pgfaults = opt->value;
|
|
|
|
|
|
|
|
if (strcmp(str, "all") == 0)
|
|
|
|
*trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
|
|
|
|
else if (strcmp(str, "maj") == 0)
|
|
|
|
*trace_pgfaults |= TRACE_PFMAJ;
|
|
|
|
else if (strcmp(str, "min") == 0)
|
|
|
|
*trace_pgfaults |= TRACE_PFMIN;
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
|
|
|
|
{
|
|
|
|
struct perf_evsel *evsel;
|
|
|
|
|
|
|
|
evlist__for_each(evlist, evsel)
|
|
|
|
evsel->handler = handler;
|
|
|
|
}
|
|
|
|
|
2012-09-27 06:05:56 +07:00
|
|
|
int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
|
|
|
|
{
|
2015-03-18 20:35:57 +07:00
|
|
|
const char *trace_usage[] = {
|
2012-10-05 12:02:16 +07:00
|
|
|
"perf trace [<options>] [<command>]",
|
|
|
|
"perf trace [<options>] -- <command> [<options>]",
|
2013-09-29 02:13:01 +07:00
|
|
|
"perf trace record [<options>] [<command>]",
|
|
|
|
"perf trace record [<options>] -- <command> [<options>]",
|
2012-09-27 06:05:56 +07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
struct trace trace = {
|
2013-09-28 04:06:19 +07:00
|
|
|
.audit = {
|
|
|
|
.machine = audit_detect_machine(),
|
|
|
|
.open_id = audit_name_to_syscall("open", trace.audit.machine),
|
|
|
|
},
|
2012-09-27 06:05:56 +07:00
|
|
|
.syscalls = {
|
|
|
|
. max = -1,
|
|
|
|
},
|
|
|
|
.opts = {
|
|
|
|
.target = {
|
|
|
|
.uid = UINT_MAX,
|
|
|
|
.uses_mmap = true,
|
|
|
|
},
|
|
|
|
.user_freq = UINT_MAX,
|
|
|
|
.user_interval = ULLONG_MAX,
|
2014-01-15 03:52:14 +07:00
|
|
|
.no_buffering = true,
|
2014-12-13 03:28:32 +07:00
|
|
|
.mmap_pages = UINT_MAX,
|
2012-09-27 06:05:56 +07:00
|
|
|
},
|
2013-08-19 22:01:10 +07:00
|
|
|
.output = stdout,
|
perf trace: Add option to show process COMM
Enabled by default, disable with --no-comm, e.g.:
181.821 (0.001 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: PEEK|TRUNC|CMSG_CLOEXEC ) = 20
181.824 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.825 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.834 (0.002 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: CMSG_CLOEXEC ) = 20
181.836 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.838 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.705 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 1256
181.710 (0.002 ms): evolution-addr/10924 geteuid( ) = 1000
181.712 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.727 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 1256
181.731 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.734 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.908 (0.002 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 20
181.913 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.915 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.930 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 20
181.934 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.937 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
220.718 (0.010 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.741 (0.000 ms): dbus-daemon/10711 ... [continued]: epoll_wait()) = 1
220.759 (0.004 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.780 (0.002 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.788 (0.001 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = -1 EAGAIN Resource temporarily unavailable
220.760 (0.004 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.771 (0.023 ms): perf/26347 open(filename: 0xf2e780, mode: 15918976 ) = 19
220.850 (0.002 ms): perf/26347 close(fd: 19 ) = 0
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-6be5jvnkdzjptdrebfn5263n@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 22:35:21 +07:00
|
|
|
.show_comm = true,
|
2014-06-26 23:14:28 +07:00
|
|
|
.trace_syscalls = true,
|
2012-09-27 06:05:56 +07:00
|
|
|
};
|
2013-08-19 22:01:10 +07:00
|
|
|
const char *output_name = NULL;
|
2013-08-09 22:28:31 +07:00
|
|
|
const char *ev_qualifier_str = NULL;
|
2012-09-27 06:05:56 +07:00
|
|
|
const struct option trace_options[] = {
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
OPT_CALLBACK(0, "event", &trace.evlist, "event",
|
|
|
|
"event selector. use 'perf list' to list available events",
|
|
|
|
parse_events_option),
|
perf trace: Add option to show process COMM
Enabled by default, disable with --no-comm, e.g.:
181.821 (0.001 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: PEEK|TRUNC|CMSG_CLOEXEC ) = 20
181.824 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.825 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.834 (0.002 ms): deja-dup-monit/10784 recvmsg(fd: 8, msg: 0x7fff4342baf0, flags: CMSG_CLOEXEC ) = 20
181.836 (0.001 ms): deja-dup-monit/10784 geteuid( ) = 1000
181.838 (0.001 ms): deja-dup-monit/10784 getegid( ) = 1000
181.705 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 1256
181.710 (0.002 ms): evolution-addr/10924 geteuid( ) = 1000
181.712 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.727 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 1256
181.731 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.734 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.908 (0.002 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: PEEK|TRUNC|CMSG_CLOEXEC) = 20
181.913 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.915 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
181.930 (0.003 ms): evolution-addr/10924 recvmsg(fd: 10, msg: 0x7fff17dc6990, flags: CMSG_CLOEXEC ) = 20
181.934 (0.001 ms): evolution-addr/10924 geteuid( ) = 1000
181.937 (0.001 ms): evolution-addr/10924 getegid( ) = 1000
220.718 (0.010 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.741 (0.000 ms): dbus-daemon/10711 ... [continued]: epoll_wait()) = 1
220.759 (0.004 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.780 (0.002 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = 200
220.788 (0.001 ms): dbus-daemon/10711 recvmsg(fd: 11, msg: 0x7ffff94594d0, flags: CMSG_CLOEXEC ) = -1 EAGAIN Resource temporarily unavailable
220.760 (0.004 ms): at-spi2-regist/10715 sendmsg(fd: 3, msg: 0x7fffdb8756c0, flags: NOSIGNAL ) = 200
220.771 (0.023 ms): perf/26347 open(filename: 0xf2e780, mode: 15918976 ) = 19
220.850 (0.002 ms): perf/26347 close(fd: 19 ) = 0
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-6be5jvnkdzjptdrebfn5263n@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-12 22:35:21 +07:00
|
|
|
OPT_BOOLEAN(0, "comm", &trace.show_comm,
|
|
|
|
"show the thread COMM next to its id"),
|
2013-09-28 04:06:19 +07:00
|
|
|
OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
|
2013-08-09 22:28:31 +07:00
|
|
|
OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
|
|
|
|
"list of events to trace"),
|
2013-08-19 22:01:10 +07:00
|
|
|
OPT_STRING('o', "output", &output_name, "file", "output file name"),
|
2013-08-29 11:29:52 +07:00
|
|
|
OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
|
2012-09-27 06:05:56 +07:00
|
|
|
OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
|
|
|
|
"trace events on existing process id"),
|
2013-08-21 00:15:45 +07:00
|
|
|
OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
|
2012-09-27 06:05:56 +07:00
|
|
|
"trace events on existing thread id"),
|
perf trace: Introduce --filter-pids
When tracing in X we get event loops due to the tracing activity, i.e.
updates to a gnome-terminal that generate syscalls for X.org, etc.
To get a more useful view of what is happening, syscall wise, system
wide, we need to filter those, like in:
# ps ax|egrep '981|2296|1519' | grep -v egrep
981 tty1 Ss+ 5:40 /usr/bin/Xorg :0 -background none ...
1519 ? Sl 2:22 /usr/bin/gnome-shell
2296 ? Sl 4:16 /usr/libexec/gnome-terminal-server
#
# trace -e write --filter-pids 981,2296,1519
0.385 ( 0.021 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 136) = 136
0.922 ( 0.014 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 140) = 140
5006.525 ( 0.029 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 136) = 136
5007.235 ( 0.023 ms): goa-daemon/2061 write(fd: 1</dev/null>, buf: 0x7fbeb017b000, count: 140) = 140
5177.646 ( 0.018 ms): rtkit-daemon/782 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7f7eea70be88, count: 8) = 8
8314.497 ( 0.004 ms): gsd-locate-poi/2084 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7fffe96af7b0, count: 8) = 8
8314.518 ( 0.002 ms): gsd-locate-poi/2084 write(fd: 5<anon_inode:[eventfd]>, buf: 0x7fffe96af0e0, count: 8) = 8
^C#
When this option is used the tracer pid is also filtered.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-f5qmiyy7c0uxdm21ncatpeek@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-22 02:36:52 +07:00
|
|
|
OPT_CALLBACK(0, "filter-pids", &trace, "float",
|
|
|
|
"show only events with duration > N.M ms", trace__set_filter_pids),
|
2013-08-21 00:15:45 +07:00
|
|
|
OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
|
2012-09-27 06:05:56 +07:00
|
|
|
"system-wide collection from all CPUs"),
|
2013-08-21 00:15:45 +07:00
|
|
|
OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
|
2012-09-27 06:05:56 +07:00
|
|
|
"list of cpus to monitor"),
|
2013-08-29 11:29:52 +07:00
|
|
|
OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
|
2012-09-27 06:05:56 +07:00
|
|
|
"child tasks do not inherit counters"),
|
2013-09-01 17:36:12 +07:00
|
|
|
OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
|
|
|
|
"number of mmap data pages",
|
|
|
|
perf_evlist__parse_mmap_pages),
|
2013-08-21 00:15:45 +07:00
|
|
|
OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
|
2012-09-27 06:05:56 +07:00
|
|
|
"user to profile"),
|
perf trace: Add duration filter
Example:
[acme@sandy linux]$ perf trace --duration 0.025 usleep 1
2.221 ( 0.958 ms): 6724 execve(arg0: 140733557168278, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = -2
3.690 ( 1.443 ms): 6724 execve(arg0: 140733557168295, arg1: 140733557178768, arg2: 16134304, arg3: 140733557167840, arg4: 7955998171588342573, arg5: 6723) = 0
3.979 ( 0.048 ms): 6724 open(filename: 208733843841, flags: 0, mode: 1 ) = 3
4.071 ( 0.075 ms): 6724 open(filename: 139744419925673, flags: 0, mode: 0 ) = 3
4.318 ( 0.056 ms): 6724 nanosleep(rqtp: 140734030404608, rmtp: 0 ) = 0
[acme@sandy linux]$ perf trace --duration 0.100 usleep 1
1.143 ( 1.021 ms): 6726 execve(arg0: 140736323962279, arg1: 140736323972752, arg2: 34926752, arg3: 140736323961824, arg4: 7955998171588342573, arg5: 6725) = 0
[acme@sandy linux]$
Cherry picked from tmp.perf/trace2 branch.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/n/tip-oslw2j2958we9qf0ctra4whd@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2012-10-08 19:56:00 +07:00
|
|
|
OPT_CALLBACK(0, "duration", &trace, "float",
|
|
|
|
"show only events with duration > N.M ms",
|
|
|
|
trace__set_duration),
|
2012-10-18 03:13:12 +07:00
|
|
|
OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
|
2013-08-23 02:49:54 +07:00
|
|
|
OPT_INCR('v', "verbose", &verbose, "be more verbose"),
|
2013-09-05 01:37:43 +07:00
|
|
|
OPT_BOOLEAN('T', "time", &trace.full_time,
|
|
|
|
"Show full timestamp, not time relative to first start"),
|
2013-11-12 23:31:15 +07:00
|
|
|
OPT_BOOLEAN('s', "summary", &trace.summary_only,
|
|
|
|
"Show only syscall summary with statistics"),
|
|
|
|
OPT_BOOLEAN('S', "with-summary", &trace.summary,
|
|
|
|
"Show all syscalls and summary with statistics"),
|
2014-06-26 23:14:25 +07:00
|
|
|
OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
|
|
|
|
"Trace pagefaults", parse_pagefaults, "maj"),
|
2014-06-26 23:14:28 +07:00
|
|
|
OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
|
perf trace: Support using -f to override perf.data file ownership
Enable perf trace to use perf.data when it is not owned by current user
or root.
Example:
# perf trace record ls
# chown Yunlong.Song:Yunlong.Song perf.data
# ls -al perf.data
-rw------- 1 Yunlong.Song Yunlong.Song 4153101 Apr 2 15:28 perf.data
# id
uid=0(root) gid=0(root) groups=0(root),64(pkcs11)
Before this patch:
# perf trace -i perf.data
File perf.data not owned by current user or root (use -f to override)
# perf trace -i perf.data -f
Error: unknown switch `f'
usage: perf trace [<options>] [<command>]
or: perf trace [<options>] -- <command> [<options>]
or: perf trace record [<options>] [<command>]
or: perf trace record [<options>] -- <command> [<options>]
--event <event> event selector. use 'perf list' to list
available events
--comm show the thread COMM next to its id
--tool_stats show tool stats
-e, --expr <expr> list of events to trace
-o, --output <file> output file name
-i, --input <file> Analyze events in file
-p, --pid <pid> trace events on existing process id
-t, --tid <tid> trace events on existing thread id
--filter-pids <float>
...
As shown above, the -f option does not work at all.
After this patch:
# perf trace -i perf.data
File perf.data not owned by current user or root (use -f to override)
# perf trace -i perf.data -f
0.056 ( 0.002 ms): ls/47325 brk( ...
0.108 ( 0.018 ms): ls/47325 mmap(len: 4096, prot: READ|WRITE, ...
0.145 ( 0.013 ms): ls/47325 access(filename: 0x7f31259a0eb0, ...
0.172 ( 0.008 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.180 ( 0.004 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.185 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.189 ( 0.003 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.195 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.199 ( 0.002 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.205 ( 0.004 ms): ls/47325 open(filename: 0x7fffeb9a0d00, ...
0.211 ( 0.004 ms): ls/47325 stat(filename: 0x7fffeb9a0d00, ...
0.220 ( 0.007 ms): ls/47325 open(filename: 0x7f312599e8ff, ...
...
...
As shown above, the -f option really works now.
Signed-off-by: Yunlong Song <yunlong.song@huawei.com>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1427982439-27388-10-git-send-email-yunlong.song@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-02 20:47:18 +07:00
|
|
|
OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
|
2012-09-27 06:05:56 +07:00
|
|
|
OPT_END()
|
|
|
|
};
|
2015-03-18 20:35:57 +07:00
|
|
|
const char * const trace_subcommands[] = { "record", NULL };
|
2012-09-27 06:05:56 +07:00
|
|
|
int err;
|
2012-10-05 12:02:13 +07:00
|
|
|
char bf[BUFSIZ];
|
2012-09-27 06:05:56 +07:00
|
|
|
|
2015-02-25 01:35:55 +07:00
|
|
|
signal(SIGSEGV, sighandler_dump_stack);
|
|
|
|
signal(SIGFPE, sighandler_dump_stack);
|
|
|
|
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
trace.evlist = perf_evlist__new();
|
|
|
|
if (trace.evlist == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (trace.evlist == NULL) {
|
|
|
|
pr_err("Not enough memory to run!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-03-18 20:35:57 +07:00
|
|
|
argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
|
|
|
|
trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
|
2013-11-12 23:31:15 +07:00
|
|
|
|
2014-06-26 23:14:25 +07:00
|
|
|
if (trace.trace_pgfaults) {
|
|
|
|
trace.opts.sample_address = true;
|
|
|
|
trace.opts.sample_time = true;
|
|
|
|
}
|
|
|
|
|
perf trace: Allow mixing with other events
Basically adopting 'perf record' --event command line argument syntax:
# trace -e \!mprotect,mmap,munmap,open,close,read,fstat,access,arch_prctl --event sched:*switch,sched:*exec,sched:*exit usleep 1
0.048 ( ): sched:sched_process_exec:filename=/bin/usleep pid=24732 old_pid=24732)
0.078 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.430 (0.002 ms): usleep/24732 brk( ) = 0x78f000
0.434 (0.003 ms): usleep/24732 brk(brk: 0x7b0000 ) = 0x7b0000
0.438 (0.001 ms): usleep/24732 brk( ) = 0x7b0000
0.460 (0.004 ms): usleep/24732 nanosleep(rqtp: 0x7ffff3696a40) ...
0.460 ( ): sched:sched_switch:prev_comm=usleep prev_pid=24732 prev_prio=120 prev_state=S ==> next_comm=swapper/1 next_pid=0 next_prio=120)
0.515 (0.058 ms): usleep/24732 ... [continued]: nanosleep()) = 0
0.520 (0.000 ms): usleep/24732 exit_group(
0.550 ( ): sched:sched_process_exit:comm=usleep pid=24732 prio=120)
#
Next steps, probably in this order:
1) Use ordered_events code, the logic in trace needs the events to be
time ordered when needed, i.e. when multiple CPUs are involved.
2) Callchains!
3) Automatically account for interruptions when saying how long things
took.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-gpst8mph575yb4wgf91qibyb@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-02-03 22:58:57 +07:00
|
|
|
if (trace.evlist->nr_entries > 0)
|
|
|
|
evlist__set_evsel_handler(trace.evlist, trace__event_handler);
|
|
|
|
|
2014-06-26 23:14:26 +07:00
|
|
|
if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
|
|
|
|
return trace__record(&trace, argc-1, &argv[1]);
|
|
|
|
|
|
|
|
/* summary_only implies summary option, but don't overwrite summary if set */
|
|
|
|
if (trace.summary_only)
|
|
|
|
trace.summary = trace.summary_only;
|
|
|
|
|
2015-02-06 16:16:45 +07:00
|
|
|
if (!trace.trace_syscalls && !trace.trace_pgfaults &&
|
|
|
|
trace.evlist->nr_entries == 0 /* Was --events used? */) {
|
2014-06-26 23:14:28 +07:00
|
|
|
pr_err("Please specify something to trace.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
if (output_name != NULL) {
|
|
|
|
err = trace__open_output(&trace, output_name);
|
|
|
|
if (err < 0) {
|
|
|
|
perror("failed to create output file");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-09 22:28:31 +07:00
|
|
|
if (ev_qualifier_str != NULL) {
|
2013-08-21 22:56:21 +07:00
|
|
|
const char *s = ev_qualifier_str;
|
|
|
|
|
|
|
|
trace.not_ev_qualifier = *s == '!';
|
|
|
|
if (trace.not_ev_qualifier)
|
|
|
|
++s;
|
|
|
|
trace.ev_qualifier = strlist__new(true, s);
|
2013-08-09 22:28:31 +07:00
|
|
|
if (trace.ev_qualifier == NULL) {
|
2013-08-19 22:01:10 +07:00
|
|
|
fputs("Not enough memory to parse event qualifier",
|
|
|
|
trace.output);
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out_close;
|
2013-08-09 22:28:31 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-13 02:46:16 +07:00
|
|
|
err = target__validate(&trace.opts.target);
|
2012-10-05 12:02:13 +07:00
|
|
|
if (err) {
|
2013-11-13 02:46:16 +07:00
|
|
|
target__strerror(&trace.opts.target, err, bf, sizeof(bf));
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace.output, "%s", bf);
|
|
|
|
goto out_close;
|
2012-10-05 12:02:13 +07:00
|
|
|
}
|
|
|
|
|
2013-11-13 02:46:16 +07:00
|
|
|
err = target__parse_uid(&trace.opts.target);
|
2012-09-27 06:05:56 +07:00
|
|
|
if (err) {
|
2013-11-13 02:46:16 +07:00
|
|
|
target__strerror(&trace.opts.target, err, bf, sizeof(bf));
|
2013-08-19 22:01:10 +07:00
|
|
|
fprintf(trace.output, "%s", bf);
|
|
|
|
goto out_close;
|
2012-09-27 06:05:56 +07:00
|
|
|
}
|
|
|
|
|
2013-11-13 02:46:16 +07:00
|
|
|
if (!argc && target__none(&trace.opts.target))
|
2012-10-05 12:02:14 +07:00
|
|
|
trace.opts.target.system_wide = true;
|
|
|
|
|
2013-08-29 11:29:52 +07:00
|
|
|
if (input_name)
|
|
|
|
err = trace__replay(&trace);
|
|
|
|
else
|
|
|
|
err = trace__run(&trace, argc, argv);
|
2012-10-18 03:13:12 +07:00
|
|
|
|
2013-08-19 22:01:10 +07:00
|
|
|
out_close:
|
|
|
|
if (output_name != NULL)
|
|
|
|
fclose(trace.output);
|
|
|
|
out:
|
2012-10-18 03:13:12 +07:00
|
|
|
return err;
|
2012-09-27 06:05:56 +07:00
|
|
|
}
|