UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

perf/core improvements and fixes: 

perf top:
 
   Namhyung Kim:
 
   - Decay all events in the evlist, we were decaying just the first event
     in a group.
 
   - Fix linking of histograms in different evsels in a event group with more
     than two events.
 
   With the two fixes above a command line such as:
 
     # perf top -e '{cycles,instructions,cache-misses,cache-references}
 
     Should work as expected, with four columns and with all of them being
     decayed over time, i.e. less weight is given for older samples.
 
 perf record:
 
   Arnaldo Carvalho de Melo:
 
   - Fix collection of build-ids when using setns() to get into namespaces,
     which had been broken with the introduction of the extra thread to
     react to PERF_RECORD_BPF_EVENT, i.e. to collect extra info for BPF
     programs. We need to unshare(CLONE_FS) in that thread so that the
     main one can do the setns(CLONE_NEWNS) when collectingthe build-ids.
     Without that symbol resolution gets more difficult and potentially
     misresolves symbols.
 
 core:
 
   Igor Lubashev:
 
   - Further alignment in permission checking via capabilities to how the
     kernel checks what tooling tries to do.
 
 PowerPC:
 
   Naveen N. Rao:
 
   - Sync powerpc syscall.tbl, so that 'perf trace' gets the definitions
     for recent syscalls.
 
 libperf:
 
   Jiri Olsa:
 
   - Move the rest of the PERF_RECORD_ metadata struct definitions so that
     we can use 'union perf_event'.
 
 libtraceevent:
 
   Steven Rostedt (VMware):
 
   - Do not free tep->cmdlines in add_new_comm() on failure.
 
   - Remove unneeded qsort and uses memmove instead
 
 Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
 -----BEGIN PGP SIGNATURE-----
 
 iHUEABYIAB0WIQR2GiIUctdOfX2qHhGyPKLppCJ+JwUCXWfhNgAKCRCyPKLppCJ+
 J+c6AQD4pm/TYZWVUycI3HOyc1ghd48M1VhB3mljb3liaVbDtQEAq8V19/hFvhka
 F8Aewf1qc0g+aNnjG4nlBz/u9GIIQAM=
 =WZbH
 -----END PGP SIGNATURE-----

Merge tag 'perf-core-for-mingo-5.4-20190829' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

perf top:

  Namhyung Kim:

  - Decay all events in the evlist, we were decaying just the first event
    in a group.

  - Fix linking of histograms in different evsels in a event group with more
    than two events.

  With the two fixes above a command line such as:

    # perf top -e '{cycles,instructions,cache-misses,cache-references}

    Should work as expected, with four columns and with all of them being
    decayed over time, i.e. less weight is given for older samples.

perf record:

  Arnaldo Carvalho de Melo:

  - Fix collection of build-ids when using setns() to get into namespaces,
    which had been broken with the introduction of the extra thread to
    react to PERF_RECORD_BPF_EVENT, i.e. to collect extra info for BPF
    programs. We need to unshare(CLONE_FS) in that thread so that the
    main one can do the setns(CLONE_NEWNS) when collectingthe build-ids.
    Without that symbol resolution gets more difficult and potentially
    misresolves symbols.

core:

  Igor Lubashev:

  - Further alignment in permission checking via capabilities to how the
    kernel checks what tooling tries to do.

PowerPC:

  Naveen N. Rao:

  - Sync powerpc syscall.tbl, so that 'perf trace' gets the definitions
    for recent syscalls.

libperf:

  Jiri Olsa:

  - Move the rest of the PERF_RECORD_ metadata struct definitions so that
    we can use 'union perf_event'.

libtraceevent:

  Steven Rostedt (VMware):

  - Do not free tep->cmdlines in add_new_comm() on failure.

  - Remove unneeded qsort and uses memmove instead

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
Ingo Molnar 2019-08-29 20:56:32 +02:00
parent 42880f726c 301011ba62
commit 39c2ca4346
52 changed files with 684 additions and 540 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
tools/lib/traceevent/event-parse.c
View File

@ -142,6 +142,25 @@ static int cmdline_cmp(const void *a, const void *b)
return 0;
}
/* Looking for where to place the key */
static int cmdline_slot_cmp(const void *a, const void *b)
{
const struct tep_cmdline *ca = a;
const struct tep_cmdline *cb = b;
const struct tep_cmdline *cb1 = cb + 1;
if (ca->pid < cb->pid)
return -1;
if (ca->pid > cb->pid) {
if (ca->pid <= cb1->pid)
return 0;
return 1;
}
return 0;
}
struct cmdline_list {
struct cmdline_list *next;
char *comm;
@ -239,6 +258,7 @@ static int add_new_comm(struct tep_handle *tep,
struct tep_cmdline *cmdline;
struct tep_cmdline key;
char *new_comm;
int cnt;
if (!pid)
return 0;
@ -269,21 +289,43 @@ static int add_new_comm(struct tep_handle *tep,
errno = ENOMEM;
return -1;
}
tep->cmdlines = cmdlines;
cmdlines[tep->cmdline_count].comm = strdup(comm);
if (!cmdlines[tep->cmdline_count].comm) {
free(cmdlines);
key.comm = strdup(comm);
if (!key.comm) {
errno = ENOMEM;
return -1;
}
cmdlines[tep->cmdline_count].pid = pid;
if (cmdlines[tep->cmdline_count].comm)
if (!tep->cmdline_count) {
/* no entries yet */
tep->cmdlines[0] = key;
tep->cmdline_count++;
return 0;
}
qsort(cmdlines, tep->cmdline_count, sizeof(*cmdlines), cmdline_cmp);
tep->cmdlines = cmdlines;
/* Now find where we want to store the new cmdline */
cmdline = bsearch(&key, tep->cmdlines, tep->cmdline_count - 1,
sizeof(*tep->cmdlines), cmdline_slot_cmp);
cnt = tep->cmdline_count;
if (cmdline) {
/* cmdline points to the one before the spot we want */
cmdline++;
cnt -= cmdline - tep->cmdlines;
} else {
/* The new entry is either before or after the list */
if (key.pid > tep->cmdlines[tep->cmdline_count - 1].pid) {
tep->cmdlines[tep->cmdline_count++] = key;
return 0;
}
cmdline = &tep->cmdlines[0];
}
memmove(cmdline + 1, cmdline, (cnt * sizeof(*cmdline)));
*cmdline = key;
tep->cmdline_count++;
return 0;
}

7
tools/perf/arch/arm/util/cs-etm.c
View File

@ -18,6 +18,7 @@
#include "../../util/record.h"
#include "../../util/auxtrace.h"
#include "../../util/cpumap.h"
#include "../../util/event.h"
#include "../../util/evlist.h"
#include "../../util/evsel.h"
#include "../../util/pmu.h"
@ -254,7 +255,7 @@ static int cs_etm_recording_options(struct auxtrace_record *itr,
struct perf_pmu *cs_etm_pmu = ptr->cs_etm_pmu;
struct evsel *evsel, *cs_etm_evsel = NULL;
struct perf_cpu_map *cpus = evlist->core.cpus;
bool privileged = (geteuid() == 0 || perf_event_paranoid() < 0);
bool privileged = perf_event_paranoid_check(-1);
int err = 0;
ptr->evlist = evlist;
@ -564,7 +565,7 @@ static int cs_etm_get_ro(struct perf_pmu *pmu, int cpu, const char *path)
static void cs_etm_get_metadata(int cpu, u32 *offset,
struct auxtrace_record *itr,
struct auxtrace_info_event *info)
struct perf_record_auxtrace_info *info)
{
u32 increment;
u64 magic;
@ -629,7 +630,7 @@ static void cs_etm_get_metadata(int cpu, u32 *offset,
static int cs_etm_info_fill(struct auxtrace_record *itr,
struct perf_session *session,
struct auxtrace_info_event *info,
struct perf_record_auxtrace_info *info,
size_t priv_size)
{
int i;

5
tools/perf/arch/arm64/util/arm-spe.c
View File

@ -12,6 +12,7 @@
#include <time.h>
#include "../../util/cpumap.h"
#include "../../util/event.h"
#include "../../util/evsel.h"
#include "../../util/evlist.h"
#include "../../util/session.h"
@ -40,7 +41,7 @@ arm_spe_info_priv_size(struct auxtrace_record *itr __maybe_unused,
static int arm_spe_info_fill(struct auxtrace_record *itr,
struct perf_session *session,
struct auxtrace_info_event *auxtrace_info,
struct perf_record_auxtrace_info *auxtrace_info,
size_t priv_size)
{
struct arm_spe_recording *sper =
@ -67,7 +68,7 @@ static int arm_spe_recording_options(struct auxtrace_record *itr,
container_of(itr, struct arm_spe_recording, itr);
struct perf_pmu *arm_spe_pmu = sper->arm_spe_pmu;
struct evsel *evsel, *arm_spe_evsel = NULL;
bool privileged = geteuid() == 0 || perf_event_paranoid() < 0;
bool privileged = perf_event_paranoid_check(-1);
struct evsel *tracking_evsel;
int err;

146
tools/perf/arch/powerpc/entry/syscalls/syscall.tbl
View File

@ -20,7 +20,9 @@
10 common unlink sys_unlink
11 nospu execve sys_execve compat_sys_execve
12 common chdir sys_chdir
13 common time sys_time compat_sys_time
13 32 time sys_time32
13 64 time sys_time
13 spu time sys_time
14 common mknod sys_mknod
15 common chmod sys_chmod
16 common lchown sys_lchown
@ -36,14 +38,17 @@
22 spu umount sys_ni_syscall
23 common setuid sys_setuid
24 common getuid sys_getuid
25 common stime sys_stime compat_sys_stime
25 32 stime sys_stime32
25 64 stime sys_stime
25 spu stime sys_stime
26 nospu ptrace sys_ptrace compat_sys_ptrace
27 common alarm sys_alarm
28 32 oldfstat sys_fstat sys_ni_syscall
28 64 oldfstat sys_ni_syscall
28 spu oldfstat sys_ni_syscall
29 nospu pause sys_pause
30 nospu utime sys_utime compat_sys_utime
30 32 utime sys_utime32
30 64 utime sys_utime
31 common stty sys_ni_syscall
32 common gtty sys_ni_syscall
33 common access sys_access
@ -157,7 +162,9 @@
121 common setdomainname sys_setdomainname
122 common uname sys_newuname
123 common modify_ldt sys_ni_syscall
124 common adjtimex sys_adjtimex compat_sys_adjtimex
124 32 adjtimex sys_adjtimex_time32
124 64 adjtimex sys_adjtimex
124 spu adjtimex sys_adjtimex
125 common mprotect sys_mprotect
126 32 sigprocmask sys_sigprocmask compat_sys_sigprocmask
126 64 sigprocmask sys_ni_syscall
@ -198,8 +205,12 @@
158 common sched_yield sys_sched_yield
159 common sched_get_priority_max sys_sched_get_priority_max
160 common sched_get_priority_min sys_sched_get_priority_min
161 common sched_rr_get_interval sys_sched_rr_get_interval compat_sys_sched_rr_get_interval
162 common nanosleep sys_nanosleep compat_sys_nanosleep
161 32 sched_rr_get_interval sys_sched_rr_get_interval_time32
161 64 sched_rr_get_interval sys_sched_rr_get_interval
161 spu sched_rr_get_interval sys_sched_rr_get_interval
162 32 nanosleep sys_nanosleep_time32
162 64 nanosleep sys_nanosleep
162 spu nanosleep sys_nanosleep
163 common mremap sys_mremap
164 common setresuid sys_setresuid
165 common getresuid sys_getresuid
@ -213,7 +224,8 @@
173 nospu rt_sigaction sys_rt_sigaction compat_sys_rt_sigaction
174 nospu rt_sigprocmask sys_rt_sigprocmask compat_sys_rt_sigprocmask
175 nospu rt_sigpending sys_rt_sigpending compat_sys_rt_sigpending
176 nospu rt_sigtimedwait sys_rt_sigtimedwait compat_sys_rt_sigtimedwait
176 32 rt_sigtimedwait sys_rt_sigtimedwait_time32 compat_sys_rt_sigtimedwait_time32
176 64 rt_sigtimedwait sys_rt_sigtimedwait
177 nospu rt_sigqueueinfo sys_rt_sigqueueinfo compat_sys_rt_sigqueueinfo
178 nospu rt_sigsuspend sys_rt_sigsuspend compat_sys_rt_sigsuspend
179 common pread64 sys_pread64 compat_sys_pread64
@ -260,7 +272,9 @@
218 common removexattr sys_removexattr
219 common lremovexattr sys_lremovexattr
220 common fremovexattr sys_fremovexattr
221 common futex sys_futex compat_sys_futex
221 32 futex sys_futex_time32
221 64 futex sys_futex
221 spu futex sys_futex
222 common sched_setaffinity sys_sched_setaffinity compat_sys_sched_setaffinity
223 common sched_getaffinity sys_sched_getaffinity compat_sys_sched_getaffinity
# 224 unused
@ -268,7 +282,9 @@
226 32 sendfile64 sys_sendfile64 compat_sys_sendfile64
227 common io_setup sys_io_setup compat_sys_io_setup
228 common io_destroy sys_io_destroy
229 common io_getevents sys_io_getevents compat_sys_io_getevents
229 32 io_getevents sys_io_getevents_time32
229 64 io_getevents sys_io_getevents
229 spu io_getevents sys_io_getevents
230 common io_submit sys_io_submit compat_sys_io_submit
231 common io_cancel sys_io_cancel
232 nospu set_tid_address sys_set_tid_address
@ -280,19 +296,33 @@
238 common epoll_wait sys_epoll_wait
239 common remap_file_pages sys_remap_file_pages
240 common timer_create sys_timer_create compat_sys_timer_create
241 common timer_settime sys_timer_settime compat_sys_timer_settime
242 common timer_gettime sys_timer_gettime compat_sys_timer_gettime
241 32 timer_settime sys_timer_settime32
241 64 timer_settime sys_timer_settime
241 spu timer_settime sys_timer_settime
242 32 timer_gettime sys_timer_gettime32
242 64 timer_gettime sys_timer_gettime
242 spu timer_gettime sys_timer_gettime
243 common timer_getoverrun sys_timer_getoverrun
244 common timer_delete sys_timer_delete
245 common clock_settime sys_clock_settime compat_sys_clock_settime
246 common clock_gettime sys_clock_gettime compat_sys_clock_gettime
247 common clock_getres sys_clock_getres compat_sys_clock_getres
248 common clock_nanosleep sys_clock_nanosleep compat_sys_clock_nanosleep
245 32 clock_settime sys_clock_settime32
245 64 clock_settime sys_clock_settime
245 spu clock_settime sys_clock_settime
246 32 clock_gettime sys_clock_gettime32
246 64 clock_gettime sys_clock_gettime
246 spu clock_gettime sys_clock_gettime
247 32 clock_getres sys_clock_getres_time32
247 64 clock_getres sys_clock_getres
247 spu clock_getres sys_clock_getres
248 32 clock_nanosleep sys_clock_nanosleep_time32
248 64 clock_nanosleep sys_clock_nanosleep
248 spu clock_nanosleep sys_clock_nanosleep
249 32 swapcontext ppc_swapcontext ppc32_swapcontext
249 64 swapcontext ppc64_swapcontext
249 spu swapcontext sys_ni_syscall
250 common tgkill sys_tgkill
251 common utimes sys_utimes compat_sys_utimes
251 32 utimes sys_utimes_time32
251 64 utimes sys_utimes
251 spu utimes sys_utimes
252 common statfs64 sys_statfs64 compat_sys_statfs64
253 common fstatfs64 sys_fstatfs64 compat_sys_fstatfs64
254 32 fadvise64_64 ppc_fadvise64_64
@ -308,8 +338,10 @@
261 nospu set_mempolicy sys_set_mempolicy compat_sys_set_mempolicy
262 nospu mq_open sys_mq_open compat_sys_mq_open
263 nospu mq_unlink sys_mq_unlink
264 nospu mq_timedsend sys_mq_timedsend compat_sys_mq_timedsend
265 nospu mq_timedreceive sys_mq_timedreceive compat_sys_mq_timedreceive
264 32 mq_timedsend sys_mq_timedsend_time32
264 64 mq_timedsend sys_mq_timedsend
265 32 mq_timedreceive sys_mq_timedreceive_time32
265 64 mq_timedreceive sys_mq_timedreceive
266 nospu mq_notify sys_mq_notify compat_sys_mq_notify
267 nospu mq_getsetattr sys_mq_getsetattr compat_sys_mq_getsetattr
268 nospu kexec_load sys_kexec_load compat_sys_kexec_load
@ -324,8 +356,10 @@
277 nospu inotify_rm_watch sys_inotify_rm_watch
278 nospu spu_run sys_spu_run
279 nospu spu_create sys_spu_create
280 nospu pselect6 sys_pselect6 compat_sys_pselect6
281 nospu ppoll sys_ppoll compat_sys_ppoll
280 32 pselect6 sys_pselect6_time32 compat_sys_pselect6_time32
280 64 pselect6 sys_pselect6
281 32 ppoll sys_ppoll_time32 compat_sys_ppoll_time32
281 64 ppoll sys_ppoll
282 common unshare sys_unshare
283 common splice sys_splice
284 common tee sys_tee
@ -334,7 +368,9 @@
287 common mkdirat sys_mkdirat
288 common mknodat sys_mknodat
289 common fchownat sys_fchownat
290 common futimesat sys_futimesat compat_sys_futimesat
290 32 futimesat sys_futimesat_time32
290 64 futimesat sys_futimesat
290 spu utimesat sys_futimesat
291 32 fstatat64 sys_fstatat64
291 64 newfstatat sys_newfstatat
291 spu newfstatat sys_newfstatat
@ -350,15 +386,21 @@
301 common move_pages sys_move_pages compat_sys_move_pages
302 common getcpu sys_getcpu
303 nospu epoll_pwait sys_epoll_pwait compat_sys_epoll_pwait
304 common utimensat sys_utimensat compat_sys_utimensat
304 32 utimensat sys_utimensat_time32
304 64 utimensat sys_utimensat
304 spu utimensat sys_utimensat
305 common signalfd sys_signalfd compat_sys_signalfd
306 common timerfd_create sys_timerfd_create
307 common eventfd sys_eventfd
308 common sync_file_range2 sys_sync_file_range2 compat_sys_sync_file_range2
309 nospu fallocate sys_fallocate compat_sys_fallocate
310 nospu subpage_prot sys_subpage_prot
311 common timerfd_settime sys_timerfd_settime compat_sys_timerfd_settime
312 common timerfd_gettime sys_timerfd_gettime compat_sys_timerfd_gettime
311 32 timerfd_settime sys_timerfd_settime32
311 64 timerfd_settime sys_timerfd_settime
311 spu timerfd_settime sys_timerfd_settime
312 32 timerfd_gettime sys_timerfd_gettime32
312 64 timerfd_gettime sys_timerfd_gettime
312 spu timerfd_gettime sys_timerfd_gettime
313 common signalfd4 sys_signalfd4 compat_sys_signalfd4
314 common eventfd2 sys_eventfd2
315 common epoll_create1 sys_epoll_create1
@ -389,11 +431,15 @@
340 common getsockopt sys_getsockopt compat_sys_getsockopt
341 common sendmsg sys_sendmsg compat_sys_sendmsg
342 common recvmsg sys_recvmsg compat_sys_recvmsg
343 common recvmmsg sys_recvmmsg compat_sys_recvmmsg
343 32 recvmmsg sys_recvmmsg_time32 compat_sys_recvmmsg_time32
343 64 recvmmsg sys_recvmmsg
343 spu recvmmsg sys_recvmmsg
344 common accept4 sys_accept4
345 common name_to_handle_at sys_name_to_handle_at
346 common open_by_handle_at sys_open_by_handle_at compat_sys_open_by_handle_at
347 common clock_adjtime sys_clock_adjtime compat_sys_clock_adjtime
347 32 clock_adjtime sys_clock_adjtime32
347 64 clock_adjtime sys_clock_adjtime
347 spu clock_adjtime sys_clock_adjtime
348 common syncfs sys_syncfs
349 common sendmmsg sys_sendmmsg compat_sys_sendmmsg
350 common setns sys_setns
@ -414,6 +460,7 @@
363 spu switch_endian sys_ni_syscall
364 common userfaultfd sys_userfaultfd
365 common membarrier sys_membarrier
# 366-377 originally left for IPC, now unused
378 nospu mlock2 sys_mlock2
379 nospu copy_file_range sys_copy_file_range
380 common preadv2 sys_preadv2 compat_sys_preadv2
@ -424,4 +471,49 @@
385 nospu pkey_free sys_pkey_free
386 nospu pkey_mprotect sys_pkey_mprotect
387 nospu rseq sys_rseq
388 nospu io_pgetevents sys_io_pgetevents compat_sys_io_pgetevents
388 32 io_pgetevents sys_io_pgetevents_time32 compat_sys_io_pgetevents
388 64 io_pgetevents sys_io_pgetevents
# room for arch specific syscalls
392 64 semtimedop sys_semtimedop
393 common semget sys_semget
394 common semctl sys_semctl compat_sys_semctl
395 common shmget sys_shmget
396 common shmctl sys_shmctl compat_sys_shmctl
397 common shmat sys_shmat compat_sys_shmat
398 common shmdt sys_shmdt
399 common msgget sys_msgget
400 common msgsnd sys_msgsnd compat_sys_msgsnd
401 common msgrcv sys_msgrcv compat_sys_msgrcv
402 common msgctl sys_msgctl compat_sys_msgctl
403 32 clock_gettime64 sys_clock_gettime sys_clock_gettime
404 32 clock_settime64 sys_clock_settime sys_clock_settime
405 32 clock_adjtime64 sys_clock_adjtime sys_clock_adjtime
406 32 clock_getres_time64 sys_clock_getres sys_clock_getres
407 32 clock_nanosleep_time64 sys_clock_nanosleep sys_clock_nanosleep
408 32 timer_gettime64 sys_timer_gettime sys_timer_gettime
409 32 timer_settime64 sys_timer_settime sys_timer_settime
410 32 timerfd_gettime64 sys_timerfd_gettime sys_timerfd_gettime
411 32 timerfd_settime64 sys_timerfd_settime sys_timerfd_settime
412 32 utimensat_time64 sys_utimensat sys_utimensat
413 32 pselect6_time64 sys_pselect6 compat_sys_pselect6_time64
414 32 ppoll_time64 sys_ppoll compat_sys_ppoll_time64
416 32 io_pgetevents_time64 sys_io_pgetevents sys_io_pgetevents
417 32 recvmmsg_time64 sys_recvmmsg compat_sys_recvmmsg_time64
418 32 mq_timedsend_time64 sys_mq_timedsend sys_mq_timedsend
419 32 mq_timedreceive_time64 sys_mq_timedreceive sys_mq_timedreceive
420 32 semtimedop_time64 sys_semtimedop sys_semtimedop
421 32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64
422 32 futex_time64 sys_futex sys_futex
423 32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval
424 common pidfd_send_signal sys_pidfd_send_signal
425 common io_uring_setup sys_io_uring_setup
426 common io_uring_enter sys_io_uring_enter
427 common io_uring_register sys_io_uring_register
428 common open_tree sys_open_tree
429 common move_mount sys_move_mount
430 common fsopen sys_fsopen
431 common fsconfig sys_fsconfig
432 common fsmount sys_fsmount
433 common fspick sys_fspick
434 common pidfd_open sys_pidfd_open
435 nospu clone3 ppc_clone3

2
tools/perf/arch/s390/util/auxtrace.c
View File

@ -29,7 +29,7 @@ static size_t cpumsf_info_priv_size(struct auxtrace_record *itr __maybe_unused,
static int
cpumsf_info_fill(struct auxtrace_record *itr __maybe_unused,
struct perf_session *session __maybe_unused,
struct auxtrace_info_event *auxtrace_info __maybe_unused,
struct perf_record_auxtrace_info *auxtrace_info __maybe_unused,
size_t priv_size __maybe_unused)
{
auxtrace_info->type = PERF_AUXTRACE_S390_CPUMSF;

6
tools/perf/arch/x86/util/intel-bts.c
View File

@ -12,6 +12,7 @@
#include <linux/zalloc.h>
#include "../../util/cpumap.h"
#include "../../util/event.h"
#include "../../util/evsel.h"
#include "../../util/evlist.h"
#include "../../util/session.h"
@ -21,6 +22,7 @@
#include "../../util/tsc.h"
#include "../../util/auxtrace.h"
#include "../../util/intel-bts.h"
#include "../../util/util.h"
#define KiB(x) ((x) * 1024)
#define MiB(x) ((x) * 1024 * 1024)
@ -58,7 +60,7 @@ intel_bts_info_priv_size(struct auxtrace_record *itr __maybe_unused,
static int intel_bts_info_fill(struct auxtrace_record *itr,
struct perf_session *session,
struct auxtrace_info_event *auxtrace_info,
struct perf_record_auxtrace_info *auxtrace_info,
size_t priv_size)
{
struct intel_bts_recording *btsr =
@ -108,7 +110,7 @@ static int intel_bts_recording_options(struct auxtrace_record *itr,
struct perf_pmu *intel_bts_pmu = btsr->intel_bts_pmu;
struct evsel *evsel, *intel_bts_evsel = NULL;
const struct perf_cpu_map *cpus = evlist->core.cpus;
bool privileged = geteuid() == 0 || perf_event_paranoid() < 0;
bool privileged = perf_event_paranoid_check(-1);
btsr->evlist = evlist;
btsr->snapshot_mode = opts->auxtrace_snapshot_mode;

7
tools/perf/arch/x86/util/intel-pt.c
View File

@ -26,6 +26,7 @@
#include "../../util/record.h"
#include "../../util/target.h"
#include "../../util/tsc.h"
#include "../../util/util.h"
#include "../../util/intel-pt.h"
#define KiB(x) ((x) * 1024)
@ -313,7 +314,7 @@ static void intel_pt_tsc_ctc_ratio(u32 *n, u32 *d)
static int intel_pt_info_fill(struct auxtrace_record *itr,
struct perf_session *session,
struct auxtrace_info_event *auxtrace_info,
struct perf_record_auxtrace_info *auxtrace_info,
size_t priv_size)
{
struct intel_pt_recording *ptr =
@ -327,7 +328,7 @@ static int intel_pt_info_fill(struct auxtrace_record *itr,
unsigned long max_non_turbo_ratio;
size_t filter_str_len;
const char *filter;
u64 *info;
__u64 *info;
int err;
if (priv_size != ptr->priv_size)
@ -579,7 +580,7 @@ static int intel_pt_recording_options(struct auxtrace_record *itr,
bool have_timing_info, need_immediate = false;
struct evsel *evsel, *intel_pt_evsel = NULL;
const struct perf_cpu_map *cpus = evlist->core.cpus;
bool privileged = geteuid() == 0 || perf_event_paranoid() < 0;
bool privileged = perf_event_paranoid_check(-1);
u64 tsc_bit;
int err;

2
tools/perf/arch/x86/util/tsc.c
View File

@ -57,7 +57,7 @@ int perf_event__synth_time_conv(const struct perf_event_mmap_page *pc,
.time_conv = {
.header = {
.type = PERF_RECORD_TIME_CONV,
.size = sizeof(struct time_conv_event),
.size = sizeof(struct perf_record_time_conv),
},
},
};

1
tools/perf/builtin-buildid-cache.c
View File

@ -25,6 +25,7 @@
#include "util/session.h"
#include "util/symbol.h"
#include "util/time-utils.h"
#include "util/util.h"
#include "util/probe-file.h"
static int build_id_cache__kcore_buildid(const char *proc_dir, char *sbuildid)

6
tools/perf/builtin-record.c
View File

@ -898,7 +898,7 @@ static void record__adjust_affinity(struct record *rec, struct perf_mmap *map)
static size_t process_comp_header(void *record, size_t increment)
{
struct compressed_event *event = record;
struct perf_record_compressed *event = record;
size_t size = sizeof(*event);
if (increment) {
@ -916,7 +916,7 @@ static size_t zstd_compress(struct perf_session *session, void *dst, size_t dst_
void *src, size_t src_size)
{
size_t compressed;
size_t max_record_size = PERF_SAMPLE_MAX_SIZE - sizeof(struct compressed_event) - 1;
size_t max_record_size = PERF_SAMPLE_MAX_SIZE - sizeof(struct perf_record_compressed) - 1;
compressed = zstd_compress_stream_to_records(&session->zstd_data, dst, dst_size, src, src_size,
max_record_size, process_comp_header);
@ -2372,7 +2372,7 @@ int cmd_record(int argc, const char **argv)
if (symbol_conf.kptr_restrict && !perf_evlist__exclude_kernel(rec->evlist))
pr_warning(
"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
"check /proc/sys/kernel/kptr_restrict.\n\n"
"check /proc/sys/kernel/kptr_restrict and /proc/sys/kernel/perf_event_paranoid.\n\n"
"Samples in kernel functions may not be resolved if a suitable vmlinux\n"
"file is not found in the buildid cache or in the vmlinux path.\n\n"
"Samples in kernel modules won't be resolved at all.\n\n"

3
tools/perf/builtin-report.c
View File

@ -44,6 +44,7 @@
#include "util/auxtrace.h"
#include "util/units.h"
#include "util/branch.h"
#include "util/util.h"
#include <dlfcn.h>
#include <errno.h>
@ -211,7 +212,7 @@ static int process_feature_event(struct perf_session *session,
return perf_event__process_feature(session, event);
if (event->feat.feat_id != HEADER_LAST_FEATURE) {
pr_err("failed: wrong feature ID: %" PRIu64 "\n",
pr_err("failed: wrong feature ID: %" PRI_lu64 "\n",
event->feat.feat_id);
return -1;
}

3
tools/perf/builtin-script.c
View File

@ -52,6 +52,7 @@
#include <subcmd/pager.h>
#include <perf/evlist.h>
#include "util/record.h"
#include "util/util.h"
#include <linux/ctype.h>
@ -3243,7 +3244,7 @@ static void script__setup_sample_type(struct perf_script *script)
static int process_stat_round_event(struct perf_session *session,
union perf_event *event)
{
struct stat_round_event *round = &event->stat_round;
struct perf_record_stat_round *round = &event->stat_round;
struct evsel *counter;
evlist__for_each_entry(session->evlist, counter) {

2
tools/perf/builtin-stat.c
View File

@ -1462,7 +1462,7 @@ static int __cmd_record(int argc, const char **argv)
static int process_stat_round_event(struct perf_session *session,
union perf_event *event)
{
struct stat_round_event *stat_round = &event->stat_round;
struct perf_record_stat_round *stat_round = &event->stat_round;
struct evsel *counter;
struct timespec tsh, *ts = NULL;
const char **argv = session->header.env.cmdline_argv;

47
tools/perf/builtin-top.c
View File

@ -34,6 +34,7 @@
#include "util/thread.h"
#include "util/thread_map.h"
#include "util/top.h"
#include "util/util.h"
#include <linux/rbtree.h>
#include <subcmd/parse-options.h>
#include "util/parse-events.h"
@ -264,13 +265,29 @@ out_unlock:
pthread_mutex_unlock(&notes->lock);
}
static void evlist__resort_hists(struct evlist *evlist)
static void perf_top__resort_hists(struct perf_top *t)
{
struct evlist *evlist = t->evlist;
struct evsel *pos;
evlist__for_each_entry(evlist, pos) {
struct hists *hists = evsel__hists(pos);
/*
* unlink existing entries so that they can be linked
* in a correct order in hists__match() below.
*/
hists__unlink(hists);
if (evlist->enabled) {
if (t->zero) {
hists__delete_entries(hists);
} else {
hists__decay_entries(hists, t->hide_user_symbols,
t->hide_kernel_symbols);
}
}
hists__collapse_resort(hists, NULL);
/* Non-group events are considered as leader */
@ -319,16 +336,7 @@ static void perf_top__print_sym_table(struct perf_top *top)
return;
}
if (top->evlist->enabled) {
if (top->zero) {
hists__delete_entries(hists);
} else {
hists__decay_entries(hists, top->hide_user_symbols,
top->hide_kernel_symbols);
}
}
evlist__resort_hists(top->evlist);
perf_top__resort_hists(top);
hists__output_recalc_col_len(hists, top->print_entries - printed);
putchar('\n');
@ -576,24 +584,11 @@ static bool perf_top__handle_keypress(struct perf_top *top, int c)
static void perf_top__sort_new_samples(void *arg)
{
struct perf_top *t = arg;
struct evsel *evsel = t->sym_evsel;
struct hists *hists;
if (t->evlist->selected != NULL)
t->sym_evsel = t->evlist->selected;
hists = evsel__hists(evsel);
if (t->evlist->enabled) {
if (t->zero) {
hists__delete_entries(hists);
} else {
hists__decay_entries(hists, t->hide_user_symbols,
t->hide_kernel_symbols);
}
}
evlist__resort_hists(t->evlist);
perf_top__resort_hists(t);
if (t->lost || t->drop)
pr_warning("Too slow to read ring buffer (change period (-c/-F) or limit CPUs (-C)\n");
@ -770,7 +765,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
if (!perf_evlist__exclude_kernel(top->session->evlist)) {
ui__warning(
"Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
"Check /proc/sys/kernel/kptr_restrict.\n\n"
"Check /proc/sys/kernel/kptr_restrict and /proc/sys/kernel/perf_event_paranoid.\n\n"
"Kernel%s samples will not be resolved.\n",
al.map && map__has_symbols(al.map) ?
" modules" : "");

3
tools/perf/builtin-trace.c
View File

@ -41,6 +41,7 @@
#include "util/intlist.h"
#include "util/thread_map.h"
#include "util/stat.h"
#include "util/util.h"
#include "trace/beauty/beauty.h"
#include "trace-event.h"
#include "util/parse-events.h"
@ -1382,7 +1383,7 @@ static char *trace__machine__resolve_kernel_addr(void *vmachine, unsigned long l
if (symbol_conf.kptr_restrict) {
pr_warning("Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
"Check /proc/sys/kernel/kptr_restrict.\n\n"
"Check /proc/sys/kernel/kptr_restrict and /proc/sys/kernel/perf_event_paranoid.\n\n"
"Kernel samples will not be resolved.\n");
machine->kptr_restrict_warned = true;
return NULL;

2
tools/perf/builtin.h
View File

@ -2,8 +2,6 @@
#ifndef BUILTIN_H
#define BUILTIN_H
#include "util/util.h"
extern const char perf_usage_string[];
extern const char perf_more_info_string[];

273
tools/perf/lib/include/perf/event.h
View File

@ -6,6 +6,7 @@
#include <linux/types.h>
#include <linux/limits.h>
#include <linux/bpf.h>
#include <sys/types.h> /* pid_t */
struct perf_record_mmap {
struct perf_event_header header;
@ -109,4 +110,276 @@ struct perf_record_sample {
__u64 array[];
};
struct perf_record_switch {
struct perf_event_header header;
__u32 next_prev_pid;
__u32 next_prev_tid;
};
struct perf_record_header_attr {
struct perf_event_header header;
struct perf_event_attr attr;
__u64 id[];
};
enum {
PERF_CPU_MAP__CPUS = 0,
PERF_CPU_MAP__MASK = 1,
};
struct cpu_map_entries {
__u16 nr;
__u16 cpu[];
};
struct perf_record_record_cpu_map {
__u16 nr;
__u16 long_size;
unsigned long mask[];
};
struct perf_record_cpu_map_data {
__u16 type;
char data[];
};
struct perf_record_cpu_map {
struct perf_event_header header;
struct perf_record_cpu_map_data data;
};
enum {
PERF_EVENT_UPDATE__UNIT = 0,
PERF_EVENT_UPDATE__SCALE = 1,
PERF_EVENT_UPDATE__NAME = 2,
PERF_EVENT_UPDATE__CPUS = 3,
};
struct perf_record_event_update_cpus {
struct perf_record_cpu_map_data cpus;
};
struct perf_record_event_update_scale {
double scale;
};
struct perf_record_event_update {
struct perf_event_header header;
__u64 type;
__u64 id;
char data[];
};
#define MAX_EVENT_NAME 64
struct perf_trace_event_type {
__u64 event_id;
char name[MAX_EVENT_NAME];
};
struct perf_record_header_event_type {
struct perf_event_header header;
struct perf_trace_event_type event_type;
};
struct perf_record_header_tracing_data {
struct perf_event_header header;
__u32 size;
};
struct perf_record_header_build_id {
struct perf_event_header header;
pid_t pid;
__u8 build_id[24];
char filename[];
};
struct id_index_entry {
__u64 id;
__u64 idx;
__u64 cpu;
__u64 tid;
};
struct perf_record_id_index {
struct perf_event_header header;
__u64 nr;
struct id_index_entry entries[0];
};
struct perf_record_auxtrace_info {
struct perf_event_header header;
__u32 type;
__u32 reserved__; /* For alignment */
__u64 priv[];
};
struct perf_record_auxtrace {
struct perf_event_header header;
__u64 size;
__u64 offset;
__u64 reference;
__u32 idx;
__u32 tid;
__u32 cpu;
__u32 reserved__; /* For alignment */
};
#define MAX_AUXTRACE_ERROR_MSG 64
struct perf_record_auxtrace_error {
struct perf_event_header header;
__u32 type;
__u32 code;
__u32 cpu;
__u32 pid;
__u32 tid;
__u32 fmt;
__u64 ip;
__u64 time;
char msg[MAX_AUXTRACE_ERROR_MSG];
};
struct perf_record_aux {
struct perf_event_header header;
__u64 aux_offset;
__u64 aux_size;
__u64 flags;
};
struct perf_record_itrace_start {
struct perf_event_header header;
__u32 pid;
__u32 tid;
};
struct perf_record_thread_map_entry {
__u64 pid;
char comm[16];
};
struct perf_record_thread_map {
struct perf_event_header header;
__u64 nr;
struct perf_record_thread_map_entry entries[];
};
enum {
PERF_STAT_CONFIG_TERM__AGGR_MODE = 0,
PERF_STAT_CONFIG_TERM__INTERVAL = 1,
PERF_STAT_CONFIG_TERM__SCALE = 2,
PERF_STAT_CONFIG_TERM__MAX = 3,
};
struct perf_record_stat_config_entry {
__u64 tag;
__u64 val;
};
struct perf_record_stat_config {
struct perf_event_header header;
__u64 nr;
struct perf_record_stat_config_entry data[];
};
struct perf_record_stat {
struct perf_event_header header;
__u64 id;
__u32 cpu;
__u32 thread;
union {
struct {
__u64 val;
__u64 ena;
__u64 run;
};
__u64 values[3];
};
};
struct perf_record_stat_round {
struct perf_event_header header;
__u64 type;
__u64 time;
};
struct perf_record_time_conv {
struct perf_event_header header;
__u64 time_shift;
__u64 time_mult;
__u64 time_zero;
};
struct perf_record_header_feature {
struct perf_event_header header;
__u64 feat_id;
char data[];
};
struct perf_record_compressed {
struct perf_event_header header;
char data[];
};
enum perf_user_event_type { /* above any possible kernel type */
PERF_RECORD_USER_TYPE_START = 64,
PERF_RECORD_HEADER_ATTR = 64,
PERF_RECORD_HEADER_EVENT_TYPE = 65, /* deprecated */
PERF_RECORD_HEADER_TRACING_DATA = 66,
PERF_RECORD_HEADER_BUILD_ID = 67,
PERF_RECORD_FINISHED_ROUND = 68,
PERF_RECORD_ID_INDEX = 69,
PERF_RECORD_AUXTRACE_INFO = 70,
PERF_RECORD_AUXTRACE = 71,
PERF_RECORD_AUXTRACE_ERROR = 72,
PERF_RECORD_THREAD_MAP = 73,
PERF_RECORD_CPU_MAP = 74,
PERF_RECORD_STAT_CONFIG = 75,
PERF_RECORD_STAT = 76,
PERF_RECORD_STAT_ROUND = 77,
PERF_RECORD_EVENT_UPDATE = 78,
PERF_RECORD_TIME_CONV = 79,
PERF_RECORD_HEADER_FEATURE = 80,
PERF_RECORD_COMPRESSED = 81,
PERF_RECORD_HEADER_MAX
};
union perf_event {
struct perf_event_header header;
struct perf_record_mmap mmap;
struct perf_record_mmap2 mmap2;
struct perf_record_comm comm;
struct perf_record_namespaces namespaces;
struct perf_record_fork fork;
struct perf_record_lost lost;
struct perf_record_lost_samples lost_samples;
struct perf_record_read read;
struct perf_record_throttle throttle;
struct perf_record_sample sample;
struct perf_record_bpf_event bpf;
struct perf_record_ksymbol ksymbol;
struct perf_record_header_attr attr;
struct perf_record_event_update event_update;
struct perf_record_header_event_type event_type;
struct perf_record_header_tracing_data tracing_data;
struct perf_record_header_build_id build_id;
struct perf_record_id_index id_index;
struct perf_record_auxtrace_info auxtrace_info;
struct perf_record_auxtrace auxtrace;
struct perf_record_auxtrace_error auxtrace_error;
struct perf_record_aux aux;
struct perf_record_itrace_start itrace_start;
struct perf_record_switch context_switch;
struct perf_record_thread_map thread_map;
struct perf_record_cpu_map cpu_map;
struct perf_record_stat_config stat_config;
struct perf_record_stat stat;
struct perf_record_stat_round stat_round;
struct perf_record_time_conv time_conv;
struct perf_record_header_feature feat;
struct perf_record_compressed pack;
};
#endif /* __LIBPERF_EVENT_H */

1
tools/perf/perf.c
View File

@ -18,6 +18,7 @@
#include "util/bpf-loader.h"
#include "util/debug.h"
#include "util/event.h"
#include "util/util.h"
#include <api/fs/fs.h>
#include <api/fs/tracing_path.h>
#include <errno.h>

12
tools/perf/tests/cpumap.c
View File

@ -15,9 +15,9 @@ static int process_event_mask(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct cpu_map_event *map_event = &event->cpu_map;
struct cpu_map_mask *mask;
struct cpu_map_data *data;
struct perf_record_cpu_map *map_event = &event->cpu_map;
struct perf_record_record_cpu_map *mask;
struct perf_record_cpu_map_data *data;
struct perf_cpu_map *map;
int i;
@ -25,7 +25,7 @@ static int process_event_mask(struct perf_tool *tool __maybe_unused,
TEST_ASSERT_VAL("wrong type", data->type == PERF_CPU_MAP__MASK);
mask = (struct cpu_map_mask *)data->data;
mask = (struct perf_record_record_cpu_map *)data->data;
TEST_ASSERT_VAL("wrong nr", mask->nr == 1);
@ -49,9 +49,9 @@ static int process_event_cpus(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct cpu_map_event *map_event = &event->cpu_map;
struct perf_record_cpu_map *map_event = &event->cpu_map;
struct cpu_map_entries *cpus;
struct cpu_map_data *data;
struct perf_record_cpu_map_data *data;
struct perf_cpu_map *map;
data = &map_event->data;

16
tools/perf/tests/event_update.c
View File

@ -12,7 +12,7 @@ static int process_event_unit(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct event_update_event *ev = (struct event_update_event *) event;
struct perf_record_event_update *ev = (struct perf_record_event_update *)event;
TEST_ASSERT_VAL("wrong id", ev->id == 123);
TEST_ASSERT_VAL("wrong id", ev->type == PERF_EVENT_UPDATE__UNIT);
@ -25,10 +25,10 @@ static int process_event_scale(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct event_update_event *ev = (struct event_update_event *) event;
struct event_update_event_scale *ev_data;
struct perf_record_event_update *ev = (struct perf_record_event_update *)event;
struct perf_record_event_update_scale *ev_data;
ev_data = (struct event_update_event_scale *) ev->data;
ev_data = (struct perf_record_event_update_scale *)ev->data;
TEST_ASSERT_VAL("wrong id", ev->id == 123);
TEST_ASSERT_VAL("wrong id", ev->type == PERF_EVENT_UPDATE__SCALE);
@ -47,7 +47,7 @@ static int process_event_name(struct perf_tool *tool,
struct machine *machine __maybe_unused)
{
struct event_name *tmp = container_of(tool, struct event_name, tool);
struct event_update_event *ev = (struct event_update_event*) event;
struct perf_record_event_update *ev = (struct perf_record_event_update *)event;
TEST_ASSERT_VAL("wrong id", ev->id == 123);
TEST_ASSERT_VAL("wrong id", ev->type == PERF_EVENT_UPDATE__NAME);
@ -60,11 +60,11 @@ static int process_event_cpus(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct event_update_event *ev = (struct event_update_event*) event;
struct event_update_event_cpus *ev_data;
struct perf_record_event_update *ev = (struct perf_record_event_update *)event;
struct perf_record_event_update_cpus *ev_data;
struct perf_cpu_map *map;
ev_data = (struct event_update_event_cpus*) ev->data;
ev_data = (struct perf_record_event_update_cpus *) ev->data;
map = cpu_map__new_data(&ev_data->cpus);

1
tools/perf/tests/sdt.c
View File

@ -9,6 +9,7 @@
#include "debug.h"
#include "probe-file.h"
#include "build-id.h"
#include "util.h"
/* To test SDT event, we need libelf support to scan elf binary */
#if defined(HAVE_SDT_EVENT) && defined(HAVE_LIBELF_SUPPORT)

8
tools/perf/tests/stat.c
View File

@ -6,7 +6,7 @@
#include "counts.h"
#include "debug.h"
static bool has_term(struct stat_config_event *config,
static bool has_term(struct perf_record_stat_config *config,
u64 tag, u64 val)
{
unsigned i;
@ -25,7 +25,7 @@ static int process_stat_config_event(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct stat_config_event *config = &event->stat_config;
struct perf_record_stat_config *config = &event->stat_config;
struct perf_stat_config stat_config;
#define HAS(term, val) \
@ -65,7 +65,7 @@ static int process_stat_event(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct stat_event *st = &event->stat;
struct perf_record_stat *st = &event->stat;
TEST_ASSERT_VAL("wrong cpu", st->cpu == 1);
TEST_ASSERT_VAL("wrong thread", st->thread == 2);
@ -95,7 +95,7 @@ static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct stat_round_event *stat_round = &event->stat_round;
struct perf_record_stat_round *stat_round = &event->stat_round;
TEST_ASSERT_VAL("wrong time", stat_round->time == 0xdeadbeef);
TEST_ASSERT_VAL("wrong type", stat_round->type == PERF_STAT_ROUND_TYPE__INTERVAL);

2
tools/perf/tests/thread-map.c
View File

@ -56,7 +56,7 @@ static int process_event(struct perf_tool *tool __maybe_unused,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct thread_map_event *map = &event->thread_map;
struct perf_record_thread_map *map = &event->thread_map;
struct perf_thread_map *threads;
TEST_ASSERT_VAL("wrong nr", map->nr == 1);

6
tools/perf/util/arm-spe.c
View File

@ -181,7 +181,7 @@ static const char * const arm_spe_info_fmts[] = {
[ARM_SPE_PMU_TYPE] = " PMU Type %"PRId64"\n",
};
static void arm_spe_print_info(u64 *arr)
static void arm_spe_print_info(__u64 *arr)
{
if (!dump_trace)
return;
@ -192,12 +192,12 @@ static void arm_spe_print_info(u64 *arr)
int arm_spe_process_auxtrace_info(union perf_event *event,
struct perf_session *session)
{
struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
struct perf_record_auxtrace_info *auxtrace_info = &event->auxtrace_info;
size_t min_sz = sizeof(u64) * ARM_SPE_PMU_TYPE;
struct arm_spe *spe;
int err;
if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event) +
if (auxtrace_info->header.size < sizeof(struct perf_record_auxtrace_info) +
min_sz)
return -EINVAL;

21
tools/perf/util/auxtrace.c
View File

@ -50,6 +50,7 @@
#include "intel-bts.h"
#include "arm-spe.h"
#include "s390-cpumsf.h"
#include "util.h"
#include <linux/ctype.h>
#include "symbol/kallsyms.h"
@ -385,7 +386,7 @@ static int auxtrace_queues__add_indexed_event(struct auxtrace_queues *queues,
return err;
if (event->header.type == PERF_RECORD_AUXTRACE) {
if (event->header.size < sizeof(struct auxtrace_event) ||
if (event->header.size < sizeof(struct perf_record_auxtrace) ||
event->header.size != sz) {
err = -EINVAL;
goto out;
@ -518,7 +519,7 @@ static int auxtrace_not_supported(void)
int auxtrace_record__info_fill(struct auxtrace_record *itr,
struct perf_session *session,
struct auxtrace_info_event *auxtrace_info,
struct perf_record_auxtrace_info *auxtrace_info,
size_t priv_size)
{
if (itr)
@ -858,13 +859,13 @@ void auxtrace_buffer__free(struct auxtrace_buffer *buffer)
free(buffer);
}
void auxtrace_synth_error(struct auxtrace_error_event *auxtrace_error, int type,
void auxtrace_synth_error(struct perf_record_auxtrace_error *auxtrace_error, int type,
int code, int cpu, pid_t pid, pid_t tid, u64 ip,
const char *msg, u64 timestamp)
{
size_t size;
memset(auxtrace_error, 0, sizeof(struct auxtrace_error_event));
memset(auxtrace_error, 0, sizeof(struct perf_record_auxtrace_error));
auxtrace_error->header.type = PERF_RECORD_AUXTRACE_ERROR;
auxtrace_error->type = type;
@ -893,12 +894,12 @@ int perf_event__synthesize_auxtrace_info(struct auxtrace_record *itr,
pr_debug2("Synthesizing auxtrace information\n");
priv_size = auxtrace_record__info_priv_size(itr, session->evlist);
ev = zalloc(sizeof(struct auxtrace_info_event) + priv_size);
ev = zalloc(sizeof(struct perf_record_auxtrace_info) + priv_size);
if (!ev)
return -ENOMEM;
ev->auxtrace_info.header.type = PERF_RECORD_AUXTRACE_INFO;
ev->auxtrace_info.header.size = sizeof(struct auxtrace_info_event) +
ev->auxtrace_info.header.size = sizeof(struct perf_record_auxtrace_info) +
priv_size;
err = auxtrace_record__info_fill(itr, session, &ev->auxtrace_info,
priv_size);
@ -942,7 +943,7 @@ s64 perf_event__process_auxtrace(struct perf_session *session,
s64 err;
if (dump_trace)
fprintf(stdout, " size: %#"PRIx64" offset: %#"PRIx64" ref: %#"PRIx64" idx: %u tid: %d cpu: %d\n",
fprintf(stdout, " size: %#"PRI_lx64" offset: %#"PRI_lx64" ref: %#"PRI_lx64" idx: %u tid: %d cpu: %d\n",
event->auxtrace.size, event->auxtrace.offset,
event->auxtrace.reference, event->auxtrace.idx,
event->auxtrace.tid, event->auxtrace.cpu);
@ -1168,7 +1169,7 @@ static const char *auxtrace_error_name(int type)
size_t perf_event__fprintf_auxtrace_error(union perf_event *event, FILE *fp)
{
struct auxtrace_error_event *e = &event->auxtrace_error;
struct perf_record_auxtrace_error *e = &event->auxtrace_error;
unsigned long long nsecs = e->time;
const char *msg = e->msg;
int ret;
@ -1188,7 +1189,7 @@ size_t perf_event__fprintf_auxtrace_error(union perf_event *event, FILE *fp)
if (!e->fmt)
msg = (const char *)&e->time;
ret += fprintf(fp, " cpu %d pid %d tid %d ip %#"PRIx64" code %u: %s\n",
ret += fprintf(fp, " cpu %d pid %d tid %d ip %#"PRI_lx64" code %u: %s\n",
e->cpu, e->pid, e->tid, e->ip, e->code, msg);
return ret;
}
@ -1196,7 +1197,7 @@ size_t perf_event__fprintf_auxtrace_error(union perf_event *event, FILE *fp)
void perf_session__auxtrace_error_inc(struct perf_session *session,
union perf_event *event)
{
struct auxtrace_error_event *e = &event->auxtrace_error;
struct perf_record_auxtrace_error *e = &event->auxtrace_error;
if (e->type < PERF_AUXTRACE_ERROR_MAX)
session->evlist->stats.nr_auxtrace_errors[e->type] += 1;

8
tools/perf/util/auxtrace.h
View File

@ -28,7 +28,7 @@ struct perf_tool;
struct perf_mmap;
struct option;
struct record_opts;
struct auxtrace_info_event;
struct perf_record_auxtrace_info;
struct events_stats;
/* Auxtrace records must have the same alignment as perf event records */
@ -318,7 +318,7 @@ struct auxtrace_record {
struct evlist *evlist);
int (*info_fill)(struct auxtrace_record *itr,
struct perf_session *session,
struct auxtrace_info_event *auxtrace_info,
struct perf_record_auxtrace_info *auxtrace_info,
size_t priv_size);
void (*free)(struct auxtrace_record *itr);
int (*snapshot_start)(struct auxtrace_record *itr);
@ -498,7 +498,7 @@ size_t auxtrace_record__info_priv_size(struct auxtrace_record *itr,
struct evlist *evlist);
int auxtrace_record__info_fill(struct auxtrace_record *itr,
struct perf_session *session,
struct auxtrace_info_event *auxtrace_info,
struct perf_record_auxtrace_info *auxtrace_info,
size_t priv_size);
void auxtrace_record__free(struct auxtrace_record *itr);
int auxtrace_record__snapshot_start(struct auxtrace_record *itr);
@ -515,7 +515,7 @@ int auxtrace_index__process(int fd, u64 size, struct perf_session *session,
bool needs_swap);
void auxtrace_index__free(struct list_head *head);
void auxtrace_synth_error(struct auxtrace_error_event *auxtrace_error, int type,
void auxtrace_synth_error(struct perf_record_auxtrace_error *auxtrace_error, int type,
int code, int cpu, pid_t pid, pid_t tid, u64 ip,
const char *msg, u64 timestamp);

1
tools/perf/util/bpf-loader.c
View File

@ -23,6 +23,7 @@
#include "probe-finder.h" // for MAX_PROBES
#include "parse-events.h"
#include "strfilter.h"
#include "util.h"
#include "llvm-utils.h"
#include "c++/clang-c.h"

2
tools/perf/util/build-id.c
View File

@ -295,7 +295,7 @@ static int write_buildid(const char *name, size_t name_len, u8 *build_id,
pid_t pid, u16 misc, struct feat_fd *fd)
{
int err;
struct build_id_event b;
struct perf_record_header_build_id b;
size_t len;
len = name_len + 1;

2
tools/perf/util/c++/clang-c.h
View File

@ -3,7 +3,6 @@
#define PERF_UTIL_CLANG_C_H
#include <stddef.h> /* for size_t */
#include <util-cxx.h> /* for __maybe_unused */
#ifdef __cplusplus
extern "C" {
@ -22,6 +21,7 @@ extern int perf_clang__compile_bpf(const char *filename,
#else
#include <errno.h>
#include <linux/compiler.h> /* for __maybe_unused */
static inline void perf_clang__init(void) { }
static inline void perf_clang__cleanup(void) { }

4
tools/perf/util/c++/clang-test.cpp
View File

@ -1,10 +1,12 @@
// SPDX-License-Identifier: GPL-2.0
#include "clang.h"
#include "clang-c.h"
extern "C" {
#include "../util.h"
}
#include "llvm/IR/Function.h"
#include "llvm/IR/LLVMContext.h"
#include <util-cxx.h>
#include <tests/llvm.h>
#include <string>

6
tools/perf/util/cpumap.c
View File

@ -43,7 +43,7 @@ static struct perf_cpu_map *cpu_map__from_entries(struct cpu_map_entries *cpus)
return map;
}
static struct perf_cpu_map *cpu_map__from_mask(struct cpu_map_mask *mask)
static struct perf_cpu_map *cpu_map__from_mask(struct perf_record_record_cpu_map *mask)
{
struct perf_cpu_map *map;
int nr, nbits = mask->nr * mask->long_size * BITS_PER_BYTE;
@ -61,12 +61,12 @@ static struct perf_cpu_map *cpu_map__from_mask(struct cpu_map_mask *mask)
}
struct perf_cpu_map *cpu_map__new_data(struct cpu_map_data *data)
struct perf_cpu_map *cpu_map__new_data(struct perf_record_cpu_map_data *data)
{
if (data->type == PERF_CPU_MAP__CPUS)
return cpu_map__from_entries((struct cpu_map_entries *)data->data);
else
return cpu_map__from_mask((struct cpu_map_mask *)data->data);
return cpu_map__from_mask((struct perf_record_record_cpu_map *)data->data);
}
size_t cpu_map__fprintf(struct perf_cpu_map *map, FILE *fp)

4
tools/perf/util/cpumap.h
View File

@ -7,10 +7,10 @@
#include <internal/cpumap.h>
#include <perf/cpumap.h>
struct cpu_map_data;
struct perf_record_cpu_map_data;
struct perf_cpu_map *perf_cpu_map__empty_new(int nr);
struct perf_cpu_map *cpu_map__new_data(struct cpu_map_data *data);
struct perf_cpu_map *cpu_map__new_data(struct perf_record_cpu_map_data *data);
size_t cpu_map__snprint(struct perf_cpu_map *map, char *buf, size_t size);
size_t cpu_map__snprint_mask(struct perf_cpu_map *map, char *buf, size_t size);
size_t cpu_map__fprintf(struct perf_cpu_map *map, FILE *fp);

4
tools/perf/util/cs-etm.c
View File

@ -2370,7 +2370,7 @@ static const char * const cs_etmv4_priv_fmts[] = {
[CS_ETMV4_TRCAUTHSTATUS] = " TRCAUTHSTATUS %llx\n",
};
static void cs_etm__print_auxtrace_info(u64 *val, int num)
static void cs_etm__print_auxtrace_info(__u64 *val, int num)
{
int i, j, cpu = 0;
@ -2393,7 +2393,7 @@ static void cs_etm__print_auxtrace_info(u64 *val, int num)
int cs_etm__process_auxtrace_info(union perf_event *event,
struct perf_session *session)
{
struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
struct perf_record_auxtrace_info *auxtrace_info = &event->auxtrace_info;
struct cs_etm_auxtrace *etm = NULL;
struct int_node *inode;
unsigned int pmu_type;

45
tools/perf/util/event.c
View File

@ -913,11 +913,13 @@ static int __perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
int err;
union perf_event *event;
if (symbol_conf.kptr_restrict)
return -1;
if (map == NULL)
return -1;
kmap = map__kmap(map);
if (!kmap->ref_reloc_sym)
return -1;
/*
* We should get this from /sys/kernel/sections/.text, but till that is
* available use this, and after it is use this as a fallback for older
@ -940,7 +942,6 @@ static int __perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
}
kmap = map__kmap(map);
size = snprintf(event->mmap.filename, sizeof(event->mmap.filename),
"%s%s", machine->mmap_name, kmap->ref_reloc_sym->name) + 1;
size = PERF_ALIGN(size, sizeof(u64));
@ -991,7 +992,7 @@ int perf_event__synthesize_thread_map2(struct perf_tool *tool,
event->thread_map.nr = threads->nr;
for (i = 0; i < threads->nr; i++) {
struct thread_map_event_entry *entry = &event->thread_map.entries[i];
struct perf_record_thread_map_entry *entry = &event->thread_map.entries[i];
char *comm = perf_thread_map__comm(threads, i);
if (!comm)
@ -1018,7 +1019,7 @@ static void synthesize_cpus(struct cpu_map_entries *cpus,
cpus->cpu[i] = map->map[i];
}
static void synthesize_mask(struct cpu_map_mask *mask,
static void synthesize_mask(struct perf_record_record_cpu_map *mask,
struct perf_cpu_map *map, int max)
{
int i;
@ -1049,7 +1050,7 @@ static size_t mask_size(struct perf_cpu_map *map, int *max)
*max = bit;
}
return sizeof(struct cpu_map_mask) + BITS_TO_LONGS(*max) * sizeof(long);
return sizeof(struct perf_record_record_cpu_map) + BITS_TO_LONGS(*max) * sizeof(long);
}
void *cpu_map_data__alloc(struct perf_cpu_map *map, size_t *size, u16 *type, int *max)
@ -1060,15 +1061,15 @@ void *cpu_map_data__alloc(struct perf_cpu_map *map, size_t *size, u16 *type, int
/*
* Both array and mask data have variable size based
* on the number of cpus and their actual values.
* The size of the 'struct cpu_map_data' is:
* The size of the 'struct perf_record_cpu_map_data' is:
*
* array = size of 'struct cpu_map_entries' +
* number of cpus * sizeof(u64)
*
* mask = size of 'struct cpu_map_mask' +
* mask = size of 'struct perf_record_record_cpu_map' +
* maximum cpu bit converted to size of longs
*
* and finaly + the size of 'struct cpu_map_data'.
* and finaly + the size of 'struct perf_record_cpu_map_data'.
*/
size_cpus = cpus_size(map);
size_mask = mask_size(map, max);
@ -1081,12 +1082,12 @@ void *cpu_map_data__alloc(struct perf_cpu_map *map, size_t *size, u16 *type, int
*type = PERF_CPU_MAP__MASK;
}
*size += sizeof(struct cpu_map_data);
*size += sizeof(struct perf_record_cpu_map_data);
*size = PERF_ALIGN(*size, sizeof(u64));
return zalloc(*size);
}
void cpu_map_data__synthesize(struct cpu_map_data *data, struct perf_cpu_map *map,
void cpu_map_data__synthesize(struct perf_record_cpu_map_data *data, struct perf_cpu_map *map,
u16 type, int max)
{
data->type = type;
@ -1096,16 +1097,16 @@ void cpu_map_data__synthesize(struct cpu_map_data *data, struct perf_cpu_map *ma
synthesize_cpus((struct cpu_map_entries *) data->data, map);
break;
case PERF_CPU_MAP__MASK:
synthesize_mask((struct cpu_map_mask *) data->data, map, max);
synthesize_mask((struct perf_record_record_cpu_map *)data->data, map, max);
default:
break;
};
}
static struct cpu_map_event* cpu_map_event__new(struct perf_cpu_map *map)
static struct perf_record_cpu_map *cpu_map_event__new(struct perf_cpu_map *map)
{
size_t size = sizeof(struct cpu_map_event);
struct cpu_map_event *event;
size_t size = sizeof(struct perf_record_cpu_map);
struct perf_record_cpu_map *event;
int max;
u16 type;
@ -1126,7 +1127,7 @@ int perf_event__synthesize_cpu_map(struct perf_tool *tool,
perf_event__handler_t process,
struct machine *machine)
{
struct cpu_map_event *event;
struct perf_record_cpu_map *event;
int err;
event = cpu_map_event__new(map);
@ -1144,7 +1145,7 @@ int perf_event__synthesize_stat_config(struct perf_tool *tool,
perf_event__handler_t process,
struct machine *machine)
{
struct stat_config_event *event;
struct perf_record_stat_config *event;
int size, i = 0, err;
size = sizeof(*event);
@ -1183,7 +1184,7 @@ int perf_event__synthesize_stat(struct perf_tool *tool,
perf_event__handler_t process,
struct machine *machine)
{
struct stat_event event;
struct perf_record_stat event;
event.header.type = PERF_RECORD_STAT;
event.header.size = sizeof(event);
@ -1204,7 +1205,7 @@ int perf_event__synthesize_stat_round(struct perf_tool *tool,
perf_event__handler_t process,
struct machine *machine)
{
struct stat_round_event event;
struct perf_record_stat_round event;
event.header.type = PERF_RECORD_STAT_ROUND;
event.header.size = sizeof(event);
@ -1217,7 +1218,7 @@ int perf_event__synthesize_stat_round(struct perf_tool *tool,
}
void perf_event__read_stat_config(struct perf_stat_config *config,
struct stat_config_event *event)
struct perf_record_stat_config *event)
{
unsigned i;
@ -1234,7 +1235,7 @@ void perf_event__read_stat_config(struct perf_stat_config *config,
CASE(INTERVAL, interval)
#undef CASE
default:
pr_warning("unknown stat config term %" PRIu64 "\n",
pr_warning("unknown stat config term %" PRI_lu64 "\n",
event->data[i].tag);
}
}
@ -1448,7 +1449,7 @@ int perf_event__process_exit(struct perf_tool *tool __maybe_unused,
size_t perf_event__fprintf_aux(union perf_event *event, FILE *fp)
{
return fprintf(fp, " offset: %#"PRIx64" size: %#"PRIx64" flags: %#"PRIx64" [%s%s%s]\n",
return fprintf(fp, " offset: %#"PRI_lx64" size: %#"PRI_lx64" flags: %#"PRI_lx64" [%s%s%s]\n",
event->aux.aux_offset, event->aux.aux_size,
event->aux.flags,
event->aux.flags & PERF_AUX_FLAG_TRUNCATED ? "T" : "",

278
tools/perf/util/event.h
View File

@ -22,9 +22,11 @@
*/
#define PRI_lu64 "l" PRIu64
#define PRI_lx64 "l" PRIx64
#define PRI_ld64 "l" PRId64
#else
#define PRI_lu64 PRIu64
#define PRI_lx64 PRIx64
#define PRI_ld64 PRId64
#endif
#define PERF_SAMPLE_MASK \
@ -144,36 +146,6 @@ struct perf_sample {
PERF_MEM_S(LOCK, NA) |\
PERF_MEM_S(TLB, NA))
struct build_id_event {
struct perf_event_header header;
pid_t pid;
u8 build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
char filename[];
};
enum perf_user_event_type { /* above any possible kernel type */
PERF_RECORD_USER_TYPE_START = 64,
PERF_RECORD_HEADER_ATTR = 64,
PERF_RECORD_HEADER_EVENT_TYPE = 65, /* deprecated */
PERF_RECORD_HEADER_TRACING_DATA = 66,
PERF_RECORD_HEADER_BUILD_ID = 67,
PERF_RECORD_FINISHED_ROUND = 68,
PERF_RECORD_ID_INDEX = 69,
PERF_RECORD_AUXTRACE_INFO = 70,
PERF_RECORD_AUXTRACE = 71,
PERF_RECORD_AUXTRACE_ERROR = 72,
PERF_RECORD_THREAD_MAP = 73,
PERF_RECORD_CPU_MAP = 74,
PERF_RECORD_STAT_CONFIG = 75,
PERF_RECORD_STAT = 76,
PERF_RECORD_STAT_ROUND = 77,
PERF_RECORD_EVENT_UPDATE = 78,
PERF_RECORD_TIME_CONV = 79,
PERF_RECORD_HEADER_FEATURE = 80,
PERF_RECORD_COMPRESSED = 81,
PERF_RECORD_HEADER_MAX
};
enum auxtrace_error_type {
PERF_AUXTRACE_ERROR_ITRACE = 1,
PERF_AUXTRACE_ERROR_MAX
@ -337,253 +309,11 @@ struct events_stats {
u32 nr_proc_map_timeout;
};
enum {
PERF_CPU_MAP__CPUS = 0,
PERF_CPU_MAP__MASK = 1,
};
struct cpu_map_entries {
u16 nr;
u16 cpu[];
};
struct cpu_map_mask {
u16 nr;
u16 long_size;
unsigned long mask[];
};
struct cpu_map_data {
u16 type;
char data[];
};
struct cpu_map_event {
struct perf_event_header header;
struct cpu_map_data data;
};
struct attr_event {
struct perf_event_header header;
struct perf_event_attr attr;
u64 id[];
};
enum {
PERF_EVENT_UPDATE__UNIT = 0,
PERF_EVENT_UPDATE__SCALE = 1,
PERF_EVENT_UPDATE__NAME = 2,
PERF_EVENT_UPDATE__CPUS = 3,
};
struct event_update_event_cpus {
struct cpu_map_data cpus;
};
struct event_update_event_scale {
double scale;
};
struct event_update_event {
struct perf_event_header header;
u64 type;
u64 id;
char data[];
};
#define MAX_EVENT_NAME 64
struct perf_trace_event_type {
u64 event_id;
char name[MAX_EVENT_NAME];
};
struct event_type_event {
struct perf_event_header header;
struct perf_trace_event_type event_type;
};
struct tracing_data_event {
struct perf_event_header header;
u32 size;
};
struct id_index_entry {
u64 id;
u64 idx;
u64 cpu;
u64 tid;
};
struct id_index_event {
struct perf_event_header header;
u64 nr;
struct id_index_entry entries[0];
};
struct auxtrace_info_event {
struct perf_event_header header;
u32 type;
u32 reserved__; /* For alignment */
u64 priv[];
};
struct auxtrace_event {
struct perf_event_header header;
u64 size;
u64 offset;
u64 reference;
u32 idx;
u32 tid;
u32 cpu;
u32 reserved__; /* For alignment */
};
#define MAX_AUXTRACE_ERROR_MSG 64
struct auxtrace_error_event {
struct perf_event_header header;
u32 type;
u32 code;
u32 cpu;
u32 pid;
u32 tid;
u32 fmt;
u64 ip;
u64 time;
char msg[MAX_AUXTRACE_ERROR_MSG];
};
struct aux_event {
struct perf_event_header header;
u64 aux_offset;
u64 aux_size;
u64 flags;
};
struct itrace_start_event {
struct perf_event_header header;
u32 pid, tid;
};
struct context_switch_event {
struct perf_event_header header;
u32 next_prev_pid;
u32 next_prev_tid;
};
struct thread_map_event_entry {
u64 pid;
char comm[16];
};
struct thread_map_event {
struct perf_event_header header;
u64 nr;
struct thread_map_event_entry entries[];
};
enum {
PERF_STAT_CONFIG_TERM__AGGR_MODE = 0,
PERF_STAT_CONFIG_TERM__INTERVAL = 1,
PERF_STAT_CONFIG_TERM__SCALE = 2,
PERF_STAT_CONFIG_TERM__MAX = 3,
};
struct stat_config_event_entry {
u64 tag;
u64 val;
};
struct stat_config_event {
struct perf_event_header header;
u64 nr;
struct stat_config_event_entry data[];
};
struct stat_event {
struct perf_event_header header;
u64 id;
u32 cpu;
u32 thread;
union {
struct {
u64 val;
u64 ena;
u64 run;
};
u64 values[3];
};
};
enum {
PERF_STAT_ROUND_TYPE__INTERVAL = 0,
PERF_STAT_ROUND_TYPE__FINAL = 1,
};
struct stat_round_event {
struct perf_event_header header;
u64 type;
u64 time;
};
struct time_conv_event {
struct perf_event_header header;
u64 time_shift;
u64 time_mult;
u64 time_zero;
};
struct feature_event {
struct perf_event_header header;
u64 feat_id;
char data[];
};
struct compressed_event {
struct perf_event_header header;
char data[];
};
union perf_event {
struct perf_event_header header;
struct perf_record_mmap mmap;
struct perf_record_mmap2 mmap2;
struct perf_record_comm comm;
struct perf_record_namespaces namespaces;
struct perf_record_fork fork;
struct perf_record_lost lost;
struct perf_record_lost_samples lost_samples;
struct perf_record_read read;
struct perf_record_throttle throttle;
struct perf_record_sample sample;
struct perf_record_bpf_event bpf;
struct perf_record_ksymbol ksymbol;
struct attr_event attr;
struct event_update_event event_update;
struct event_type_event event_type;
struct tracing_data_event tracing_data;
struct build_id_event build_id;
struct id_index_event id_index;
struct auxtrace_info_event auxtrace_info;
struct auxtrace_event auxtrace;
struct auxtrace_error_event auxtrace_error;
struct aux_event aux;
struct itrace_start_event itrace_start;
struct context_switch_event context_switch;
struct thread_map_event thread_map;
struct cpu_map_event cpu_map;
struct stat_config_event stat_config;
struct stat_event stat;
struct stat_round_event stat_round;
struct time_conv_event time_conv;
struct feature_event feat;
struct compressed_event pack;
};
void perf_event__print_totals(void);
struct perf_tool;
@ -621,7 +351,7 @@ int perf_event__synthesize_stat_config(struct perf_tool *tool,
perf_event__handler_t process,
struct machine *machine);
void perf_event__read_stat_config(struct perf_stat_config *config,
struct stat_config_event *event);
struct perf_record_stat_config *event);
int perf_event__synthesize_stat(struct perf_tool *tool,
u32 cpu, u32 thread, u64 id,
struct perf_counts_values *count,
@ -758,7 +488,7 @@ int kallsyms__get_function_start(const char *kallsyms_filename,
const char *symbol_name, u64 *addr);
void *cpu_map_data__alloc(struct perf_cpu_map *map, size_t *size, u16 *type, int *max);
void cpu_map_data__synthesize(struct cpu_map_data *data, struct perf_cpu_map *map,
void cpu_map_data__synthesize(struct perf_record_cpu_map_data *data, struct perf_cpu_map *map,
u16 type, int max);
void event_attr_init(struct perf_event_attr *attr);

10
tools/perf/util/evlist.c
View File

@ -16,10 +16,12 @@
#include "evsel.h"
#include "debug.h"
#include "units.h"
#include "util.h"
#include "asm/bug.h"
#include "bpf-event.h"
#include <signal.h>
#include <unistd.h>
#include <sched.h>
#include "parse-events.h"
#include <subcmd/parse-options.h>
@ -1823,6 +1825,14 @@ static void *perf_evlist__poll_thread(void *arg)
struct evlist *evlist = arg;
bool draining = false;
int i, done = 0;
/*
* In order to read symbols from other namespaces perf to needs to call
* setns(2). This isn't permitted if the struct_fs has multiple users.
* unshare(2) the fs so that we may continue to setns into namespaces
* that we're observing when, for instance, reading the build-ids at
* the end of a 'perf record' session.
*/
unshare(CLONE_FS);
while (!done) {
bool got_data = false;

1
tools/perf/util/evlist.h
View File

@ -13,7 +13,6 @@
#include "event.h"
#include "evsel.h"
#include "mmap.h"
#include "util.h"
#include <signal.h>
#include <unistd.h>

3
tools/perf/util/evsel.c
View File

@ -40,6 +40,7 @@
#include "stat.h"
#include "string2.h"
#include "memswap.h"
#include "util.h"
#include "util/parse-branch-options.h"
#include <internal/xyarray.h>
@ -282,7 +283,7 @@ struct evsel *perf_evsel__new_idx(struct perf_event_attr *attr, int idx)
static bool perf_event_can_profile_kernel(void)
{
return geteuid() == 0 || perf_event_paranoid() == -1;
return perf_event_paranoid_check(1);
}
struct evsel *perf_evsel__new_cycles(bool precise)

57
tools/perf/util/header.c
View File

@ -42,6 +42,7 @@
#include "tool.h"
#include "time-utils.h"
#include "units.h"
#include "util.h"
#include "cputopo.h"
#include "bpf-event.h"
@ -1877,7 +1878,7 @@ static void print_mem_topology(struct feat_fd *ff, FILE *fp)
}
}
static int __event_process_build_id(struct build_id_event *bev,
static int __event_process_build_id(struct perf_record_header_build_id *bev,
char *filename,
struct perf_session *session)
{
@ -1946,7 +1947,7 @@ static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
u8 build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
char filename[0];
} old_bev;
struct build_id_event bev;
struct perf_record_header_build_id bev;
char filename[PATH_MAX];
u64 limit = offset + size;
@ -1987,7 +1988,7 @@ static int perf_header__read_build_ids(struct perf_header *header,
int input, u64 offset, u64 size)
{
struct perf_session *session = container_of(header, struct perf_session, header);
struct build_id_event bev;
struct perf_record_header_build_id bev;
char filename[PATH_MAX];
u64 limit = offset + size, orig_offset = offset;
int err = -1;
@ -2009,7 +2010,7 @@ static int perf_header__read_build_ids(struct perf_header *header,
*
* "perf: 'perf kvm' tool for monitoring guest performance from host"
*
* Added a field to struct build_id_event that broke the file
* Added a field to struct perf_record_header_build_id that broke the file
* format.
*
* Since the kernel build-id is the first entry, process the
@ -3677,7 +3678,7 @@ int perf_event__synthesize_features(struct perf_tool *tool,
{
struct perf_header *header = &session->header;
struct feat_fd ff;
struct feature_event *fe;
struct perf_record_header_feature *fe;
size_t sz, sz_hdr;
int feat, ret;
@ -3740,7 +3741,7 @@ int perf_event__process_feature(struct perf_session *session,
{
struct perf_tool *tool = session->tool;
struct feat_fd ff = { .fd = 0 };
struct feature_event *fe = (struct feature_event *)event;
struct perf_record_header_feature *fe = (struct perf_record_header_feature *)event;
int type = fe->header.type;
u64 feat = fe->feat_id;
@ -3777,10 +3778,10 @@ int perf_event__process_feature(struct perf_session *session,
return 0;
}
static struct event_update_event *
static struct perf_record_event_update *
event_update_event__new(size_t size, u64 type, u64 id)
{
struct event_update_event *ev;
struct perf_record_event_update *ev;
size += sizeof(*ev);
size = PERF_ALIGN(size, sizeof(u64));
@ -3800,7 +3801,7 @@ perf_event__synthesize_event_update_unit(struct perf_tool *tool,
struct evsel *evsel,
perf_event__handler_t process)
{
struct event_update_event *ev;
struct perf_record_event_update *ev;
size_t size = strlen(evsel->unit);
int err;
@ -3819,15 +3820,15 @@ perf_event__synthesize_event_update_scale(struct perf_tool *tool,
struct evsel *evsel,
perf_event__handler_t process)
{
struct event_update_event *ev;
struct event_update_event_scale *ev_data;
struct perf_record_event_update *ev;
struct perf_record_event_update_scale *ev_data;
int err;
ev = event_update_event__new(sizeof(*ev_data), PERF_EVENT_UPDATE__SCALE, evsel->id[0]);
if (ev == NULL)
return -ENOMEM;
ev_data = (struct event_update_event_scale *) ev->data;
ev_data = (struct perf_record_event_update_scale *)ev->data;
ev_data->scale = evsel->scale;
err = process(tool, (union perf_event*) ev, NULL, NULL);
free(ev);
@ -3839,7 +3840,7 @@ perf_event__synthesize_event_update_name(struct perf_tool *tool,
struct evsel *evsel,
perf_event__handler_t process)
{
struct event_update_event *ev;
struct perf_record_event_update *ev;
size_t len = strlen(evsel->name);
int err;
@ -3858,8 +3859,8 @@ perf_event__synthesize_event_update_cpus(struct perf_tool *tool,
struct evsel *evsel,
perf_event__handler_t process)
{
size_t size = sizeof(struct event_update_event);
struct event_update_event *ev;
size_t size = sizeof(struct perf_record_event_update);
struct perf_record_event_update *ev;
int max, err;
u16 type;
@ -3875,7 +3876,7 @@ perf_event__synthesize_event_update_cpus(struct perf_tool *tool,
ev->type = PERF_EVENT_UPDATE__CPUS;
ev->id = evsel->id[0];
cpu_map_data__synthesize((struct cpu_map_data *) ev->data,
cpu_map_data__synthesize((struct perf_record_cpu_map_data *)ev->data,
evsel->core.own_cpus,
type, max);
@ -3886,17 +3887,17 @@ perf_event__synthesize_event_update_cpus(struct perf_tool *tool,
size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
{
struct event_update_event *ev = &event->event_update;
struct event_update_event_scale *ev_scale;
struct event_update_event_cpus *ev_cpus;
struct perf_record_event_update *ev = &event->event_update;
struct perf_record_event_update_scale *ev_scale;
struct perf_record_event_update_cpus *ev_cpus;
struct perf_cpu_map *map;
size_t ret;
ret = fprintf(fp, "\n... id: %" PRIu64 "\n", ev->id);
ret = fprintf(fp, "\n... id: %" PRI_lu64 "\n", ev->id);
switch (ev->type) {
case PERF_EVENT_UPDATE__SCALE:
ev_scale = (struct event_update_event_scale *) ev->data;
ev_scale = (struct perf_record_event_update_scale *)ev->data;
ret += fprintf(fp, "... scale: %f\n", ev_scale->scale);
break;
case PERF_EVENT_UPDATE__UNIT:
@ -3906,7 +3907,7 @@ size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
ret += fprintf(fp, "... name: %s\n", ev->data);
break;
case PERF_EVENT_UPDATE__CPUS:
ev_cpus = (struct event_update_event_cpus *) ev->data;
ev_cpus = (struct perf_record_event_update_cpus *)ev->data;
ret += fprintf(fp, "... ");
map = cpu_map__new_data(&ev_cpus->cpus);
@ -4052,9 +4053,9 @@ int perf_event__process_event_update(struct perf_tool *tool __maybe_unused,
union perf_event *event,
struct evlist **pevlist)
{
struct event_update_event *ev = &event->event_update;
struct event_update_event_scale *ev_scale;
struct event_update_event_cpus *ev_cpus;
struct perf_record_event_update *ev = &event->event_update;
struct perf_record_event_update_scale *ev_scale;
struct perf_record_event_update_cpus *ev_cpus;
struct evlist *evlist;
struct evsel *evsel;
struct perf_cpu_map *map;
@ -4076,11 +4077,11 @@ int perf_event__process_event_update(struct perf_tool *tool __maybe_unused,
evsel->name = strdup(ev->data);
break;
case PERF_EVENT_UPDATE__SCALE:
ev_scale = (struct event_update_event_scale *) ev->data;
ev_scale = (struct perf_record_event_update_scale *)ev->data;
evsel->scale = ev_scale->scale;
break;
case PERF_EVENT_UPDATE__CPUS:
ev_cpus = (struct event_update_event_cpus *) ev->data;
ev_cpus = (struct perf_record_event_update_cpus *)ev->data;
map = cpu_map__new_data(&ev_cpus->cpus);
if (map)
@ -4152,7 +4153,7 @@ int perf_event__process_tracing_data(struct perf_session *session,
char buf[BUFSIZ];
/* setup for reading amidst mmap */
lseek(fd, offset + sizeof(struct tracing_data_event),
lseek(fd, offset + sizeof(struct perf_record_header_tracing_data),
SEEK_SET);
size_read = trace_report(fd, &session->tevent,

39
tools/perf/util/hist.c
View File

@ -2439,7 +2439,7 @@ void hists__match(struct hists *leader, struct hists *other)
{
struct rb_root_cached *root;
struct rb_node *nd;
struct hist_entry *pos, *pair, *pos_pair, *tmp_pair;
struct hist_entry *pos, *pair;
if (symbol_conf.report_hierarchy) {
/* hierarchy report always collapses entries */
@ -2456,24 +2456,8 @@ void hists__match(struct hists *leader, struct hists *other)
pos = rb_entry(nd, struct hist_entry, rb_node_in);
pair = hists__find_entry(other, pos);
if (pair && list_empty(&pair->pairs.node)) {
list_for_each_entry_safe(pos_pair, tmp_pair, &pos->pairs.head, pairs.node) {
if (pos_pair->hists == other) {
/*
* XXX maybe decayed entries can appear
* here? but then we would have use
* after free, as decayed entries are
* freed see hists__delete_entry
*/
BUG_ON(!pos_pair->dummy);
list_del_init(&pos_pair->pairs.node);
hist_entry__delete(pos_pair);
break;
}
}
if (pair)
hist_entry__add_pair(pair, pos);
}
}
}
@ -2558,6 +2542,25 @@ int hists__link(struct hists *leader, struct hists *other)
return 0;
}
int hists__unlink(struct hists *hists)
{
struct rb_root_cached *root;
struct rb_node *nd;
struct hist_entry *pos;
if (hists__has(hists, need_collapse))
root = &hists->entries_collapsed;
else
root = hists->entries_in;
for (nd = rb_first_cached(root); nd; nd = rb_next(nd)) {
pos = rb_entry(nd, struct hist_entry, rb_node_in);
list_del_init(&pos->pairs.node);
}
return 0;
}
void hist__account_cycles(struct branch_stack *bs, struct addr_location *al,
struct perf_sample *sample, bool nonany_branch_mode)
{

1
tools/perf/util/hist.h
View File

@ -217,6 +217,7 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *he);
void hists__match(struct hists *leader, struct hists *other);
int hists__link(struct hists *leader, struct hists *other);
int hists__unlink(struct hists *hists);
struct hists_evsel {
struct evsel evsel;

6
tools/perf/util/intel-bts.c
View File

@ -834,7 +834,7 @@ static const char * const intel_bts_info_fmts[] = {
[INTEL_BTS_SNAPSHOT_MODE] = " Snapshot mode %"PRId64"\n",
};
static void intel_bts_print_info(u64 *arr, int start, int finish)
static void intel_bts_print_info(__u64 *arr, int start, int finish)
{
int i;
@ -848,12 +848,12 @@ static void intel_bts_print_info(u64 *arr, int start, int finish)
int intel_bts_process_auxtrace_info(union perf_event *event,
struct perf_session *session)
{
struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
struct perf_record_auxtrace_info *auxtrace_info = &event->auxtrace_info;
size_t min_sz = sizeof(u64) * INTEL_BTS_SNAPSHOT_MODE;
struct intel_bts *bts;
int err;
if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event) +
if (auxtrace_info->header.size < sizeof(struct perf_record_auxtrace_info) +
min_sz)
return -EINVAL;

12
tools/perf/util/intel-pt.c
View File

@ -3044,7 +3044,7 @@ static const char * const intel_pt_info_fmts[] = {
[INTEL_PT_FILTER_STR_LEN] = " Filter string len. %"PRIu64"\n",
};
static void intel_pt_print_info(u64 *arr, int start, int finish)
static void intel_pt_print_info(__u64 *arr, int start, int finish)
{
int i;
@ -3063,23 +3063,23 @@ static void intel_pt_print_info_str(const char *name, const char *str)
fprintf(stdout, " %-20s%s\n", name, str ? str : "");
}
static bool intel_pt_has(struct auxtrace_info_event *auxtrace_info, int pos)
static bool intel_pt_has(struct perf_record_auxtrace_info *auxtrace_info, int pos)
{
return auxtrace_info->header.size >=
sizeof(struct auxtrace_info_event) + (sizeof(u64) * (pos + 1));
sizeof(struct perf_record_auxtrace_info) + (sizeof(u64) * (pos + 1));
}
int intel_pt_process_auxtrace_info(union perf_event *event,
struct perf_session *session)
{
struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
struct perf_record_auxtrace_info *auxtrace_info = &event->auxtrace_info;
size_t min_sz = sizeof(u64) * INTEL_PT_PER_CPU_MMAPS;
struct intel_pt *pt;
void *info_end;
u64 *info;
__u64 *info;
int err;
if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event) +
if (auxtrace_info->header.size < sizeof(struct perf_record_auxtrace_info) +
min_sz)
return -EINVAL;

4
tools/perf/util/python.c
View File

@ -431,8 +431,8 @@ static char pyrf_context_switch_event__doc[] = PyDoc_STR("perf context_switch ev
static PyMemberDef pyrf_context_switch_event__members[] = {
sample_members
member_def(perf_event_header, type, T_UINT, "event type"),
member_def(context_switch_event, next_prev_pid, T_UINT, "next/prev pid"),
member_def(context_switch_event, next_prev_tid, T_UINT, "next/prev tid"),
member_def(perf_record_switch, next_prev_pid, T_UINT, "next/prev pid"),
member_def(perf_record_switch, next_prev_tid, T_UINT, "next/prev tid"),
{ .name = NULL, },
};

4
tools/perf/util/s390-cpumsf.c
View File

@ -1109,11 +1109,11 @@ static int s390_cpumsf__config(const char *var, const char *value, void *cb)
int s390_cpumsf_process_auxtrace_info(union perf_event *event,
struct perf_session *session)
{
struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
struct perf_record_auxtrace_info *auxtrace_info = &event->auxtrace_info;
struct s390_cpumsf *sf;
int err;
if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event))
if (auxtrace_info->header.size < sizeof(struct perf_record_auxtrace_info))
return -EINVAL;
sf = zalloc(sizeof(struct s390_cpumsf));

29
tools/perf/util/session.c
View File

@ -29,6 +29,7 @@
#include "thread-stack.h"
#include "sample-raw.h"
#include "stat.h"
#include "util.h"
#include "arch/common.h"
#ifdef HAVE_ZSTD_SUPPORT
@ -63,8 +64,8 @@ static int perf_session__process_compressed_event(struct perf_session *session,
decomp->size = decomp_last_rem;
}
src = (void *)event + sizeof(struct compressed_event);
src_size = event->pack.header.size - sizeof(struct compressed_event);
src = (void *)event + sizeof(struct perf_record_compressed);
src_size = event->pack.header.size - sizeof(struct perf_record_compressed);
decomp_size = zstd_decompress_stream(&(session->zstd_data), src, src_size,
&(decomp->data[decomp_last_rem]), decomp_len - decomp_last_rem);
@ -835,9 +836,9 @@ static void perf_event__thread_map_swap(union perf_event *event,
static void perf_event__cpu_map_swap(union perf_event *event,
bool sample_id_all __maybe_unused)
{
struct cpu_map_data *data = &event->cpu_map.data;
struct perf_record_cpu_map_data *data = &event->cpu_map.data;
struct cpu_map_entries *cpus;
struct cpu_map_mask *mask;
struct perf_record_record_cpu_map *mask;
unsigned i;
data->type = bswap_64(data->type);
@ -852,7 +853,7 @@ static void perf_event__cpu_map_swap(union perf_event *event,
cpus->cpu[i] = bswap_16(cpus->cpu[i]);
break;
case PERF_CPU_MAP__MASK:
mask = (struct cpu_map_mask *) data->data;
mask = (struct perf_record_record_cpu_map *)data->data;
mask->nr = bswap_16(mask->nr);
mask->long_size = bswap_16(mask->long_size);
@ -2375,10 +2376,10 @@ int perf_event__process_id_index(struct perf_session *session,
union perf_event *event)
{
struct evlist *evlist = session->evlist;
struct id_index_event *ie = &event->id_index;
struct perf_record_id_index *ie = &event->id_index;
size_t i, nr, max_nr;
max_nr = (ie->header.size - sizeof(struct id_index_event)) /
max_nr = (ie->header.size - sizeof(struct perf_record_id_index)) /
sizeof(struct id_index_entry);
nr = ie->nr;
if (nr > max_nr)
@ -2392,10 +2393,10 @@ int perf_event__process_id_index(struct perf_session *session,
struct perf_sample_id *sid;
if (dump_trace) {
fprintf(stdout, " ... id: %"PRIu64, e->id);
fprintf(stdout, " idx: %"PRIu64, e->idx);
fprintf(stdout, " cpu: %"PRId64, e->cpu);
fprintf(stdout, " tid: %"PRId64"\n", e->tid);
fprintf(stdout, " ... id: %"PRI_lu64, e->id);
fprintf(stdout, " idx: %"PRI_lu64, e->idx);
fprintf(stdout, " cpu: %"PRI_ld64, e->cpu);
fprintf(stdout, " tid: %"PRI_ld64"\n", e->tid);
}
sid = perf_evlist__id2sid(evlist, e->id);
@ -2420,14 +2421,14 @@ int perf_event__synthesize_id_index(struct perf_tool *tool,
pr_debug2("Synthesizing id index\n");
max_nr = (UINT16_MAX - sizeof(struct id_index_event)) /
max_nr = (UINT16_MAX - sizeof(struct perf_record_id_index)) /
sizeof(struct id_index_entry);
evlist__for_each_entry(evlist, evsel)
nr += evsel->ids;
n = nr > max_nr ? max_nr : nr;
sz = sizeof(struct id_index_event) + n * sizeof(struct id_index_entry);
sz = sizeof(struct perf_record_id_index) + n * sizeof(struct id_index_entry);
ev = zalloc(sz);
if (!ev)
return -ENOMEM;
@ -2467,7 +2468,7 @@ int perf_event__synthesize_id_index(struct perf_tool *tool,
}
}
sz = sizeof(struct id_index_event) + nr * sizeof(struct id_index_entry);
sz = sizeof(struct perf_record_id_index) + nr * sizeof(struct id_index_entry);
ev->id_index.header.size = sz;
ev->id_index.nr = nr;

2
tools/perf/util/session.h
View File

@ -28,7 +28,7 @@ struct perf_session {
struct itrace_synth_opts *itrace_synth_opts;
struct list_head auxtrace_index;
struct trace_event tevent;
struct time_conv_event time_conv;
struct perf_record_time_conv time_conv;
bool repipe;
bool one_mmap;
void *one_mmap_addr;

12
tools/perf/util/stat.c
View File

@ -382,7 +382,7 @@ int perf_event__process_stat_event(struct perf_session *session,
union perf_event *event)
{
struct perf_counts_values count;
struct stat_event *st = &event->stat;
struct perf_record_stat *st = &event->stat;
struct evsel *counter;
count.val = st->val;
@ -402,12 +402,12 @@ int perf_event__process_stat_event(struct perf_session *session,
size_t perf_event__fprintf_stat(union perf_event *event, FILE *fp)
{
struct stat_event *st = (struct stat_event *) event;
struct perf_record_stat *st = (struct perf_record_stat *)event;
size_t ret;
ret = fprintf(fp, "\n... id %" PRIu64 ", cpu %d, thread %d\n",
ret = fprintf(fp, "\n... id %" PRI_lu64 ", cpu %d, thread %d\n",
st->id, st->cpu, st->thread);
ret += fprintf(fp, "... value %" PRIu64 ", enabled %" PRIu64 ", running %" PRIu64 "\n",
ret += fprintf(fp, "... value %" PRI_lu64 ", enabled %" PRI_lu64 ", running %" PRI_lu64 "\n",
st->val, st->ena, st->run);
return ret;
@ -415,10 +415,10 @@ size_t perf_event__fprintf_stat(union perf_event *event, FILE *fp)
size_t perf_event__fprintf_stat_round(union perf_event *event, FILE *fp)
{
struct stat_round_event *rd = (struct stat_round_event *)event;
struct perf_record_stat_round *rd = (struct perf_record_stat_round *)event;
size_t ret;
ret = fprintf(fp, "\n... time %" PRIu64 ", type %s\n", rd->time,
ret = fprintf(fp, "\n... time %" PRI_lu64 ", type %s\n", rd->time,
rd->type == PERF_STAT_ROUND_TYPE__FINAL ? "FINAL" : "INTERVAL");
return ret;

15
tools/perf/util/symbol.c
View File

@ -4,6 +4,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <linux/capability.h>
#include <linux/kernel.h>
#include <linux/mman.h>
#include <linux/time64.h>
@ -15,8 +16,10 @@
#include <inttypes.h>
#include "annotate.h"
#include "build-id.h"
#include "cap.h"
#include "util.h"
#include "debug.h"
#include "event.h"
#include "machine.h"
#include "map.h"
#include "symbol.h"
@ -2195,13 +2198,19 @@ static bool symbol__read_kptr_restrict(void)
char line[8];
if (fgets(line, sizeof(line), fp) != NULL)
value = ((geteuid() != 0) || (getuid() != 0)) ?
(atoi(line) != 0) :
(atoi(line) == 2);
value = perf_cap__capable(CAP_SYSLOG) ?
(atoi(line) >= 2) :
(atoi(line) != 0);
fclose(fp);
}
/* Per kernel/kallsyms.c:
* we also restrict when perf_event_paranoid > 1 w/o CAP_SYSLOG
*/
if (perf_event_paranoid() > 1 && !perf_cap__capable(CAP_SYSLOG))
value = true;
return value;
}

4
tools/perf/util/thread_map.c
View File

@ -369,7 +369,7 @@ void thread_map__read_comms(struct perf_thread_map *threads)
}
static void thread_map__copy_event(struct perf_thread_map *threads,
struct thread_map_event *event)
struct perf_record_thread_map *event)
{
unsigned i;
@ -383,7 +383,7 @@ static void thread_map__copy_event(struct perf_thread_map *threads,
refcount_set(&threads->refcnt, 1);
}
struct perf_thread_map *thread_map__new_event(struct thread_map_event *event)
struct perf_thread_map *thread_map__new_event(struct perf_record_thread_map *event)
{
struct perf_thread_map *threads;

4
tools/perf/util/thread_map.h
View File

@ -8,7 +8,7 @@
#include <internal/threadmap.h>
#include <perf/threadmap.h>
struct thread_map_event;
struct perf_record_thread_map;
struct perf_thread_map *thread_map__new_dummy(void);
struct perf_thread_map *thread_map__new_by_pid(pid_t pid);
@ -16,7 +16,7 @@ struct perf_thread_map *thread_map__new_by_tid(pid_t tid);
struct perf_thread_map *thread_map__new_by_uid(uid_t uid);
struct perf_thread_map *thread_map__new_all_cpus(void);
struct perf_thread_map *thread_map__new(pid_t pid, pid_t tid, uid_t uid);
struct perf_thread_map *thread_map__new_event(struct thread_map_event *event);
struct perf_thread_map *thread_map__new_event(struct perf_record_thread_map *event);
struct perf_thread_map *thread_map__new_str(const char *pid,
const char *tid, uid_t uid, bool all_threads);

27
tools/perf/util/util-cxx.h
View File

@ -1,27 +0,0 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Support C++ source use utilities defined in util.h
*/
#ifndef PERF_UTIL_UTIL_CXX_H
#define PERF_UTIL_UTIL_CXX_H
#ifdef __cplusplus
extern "C" {
#endif
/*
* Now 'new' is the only C++ keyword found in util.h:
* in tools/include/linux/rbtree.h
*
* Other keywords, like class and delete, should be
* redefined if necessary.
*/
#define new _new
#include "util.h"
#undef new
#ifdef __cplusplus
}
#endif
#endif